Usuń gałęzie śledzenia już nie na zdalnym

Po poleceniu

git fetch -p

Usuwa zdalne odwołania, gdy uruchomisz

git branch -vv

Wyświetli "gone" jako status zdalnego. Na przykład,

$ git branch -vv
  master                 b900de9 [origin/master: behind 4] Fixed bug
  release/v3.8           fdd2f4e [origin/release/v3.8: behind 2] Fixed bug
  release/v3.9           0d680d0 [origin/release/v3.9: behind 2] Updated comments
  bug/1234               57379e4 [origin/bug/1234: gone] Fixed bug

Więc możesz napisać prosty skrypt usuwający lokalne gałęzie, które odeszły:

git fetch -p && for branch in `git branch -vv | grep ': gone]' | awk '{print $1}'`; do git branch -D $branch; done

Większość z tych odpowiedzi nie odpowiada na pierwotne pytanie. Poszperałem trochę i to było najczystszym rozwiązaniem, jakie znalazłem. Oto nieco dokładniejsza wersja tej odpowiedzi:

1. Sprawdź domyślną gałąź. Zwykle git checkout master
2. Run git fetch -p && git branch -vv | awk '/: gone]/{print $1}' | xargs git branch -d

Explanation:

Działa poprzez przycinanie gałęzi śledzących, a następnie usuwanie lokalnych, które pokazują, że "zniknęły" w git branch -vv.

Uwagi:

Jeśli twój język jest ustawiony na coś innego niż Angielski, musisz zmienić gone na odpowiednie słowo. Gałęzie, które są tylko lokalne, nie zostaną dotknięte. Gałęzie, które zostały usunięte w trybie zdalnym, ale nie zostały połączone, będą wyświetlać powiadomienie, ale nie zostaną usunięte w trybie lokalnym. Jeśli chcesz je również usunąć Zmień -d na -D.

Wydaje się, że rozwiązanie jest tutaj – https://stackoverflow.com/a/1072178/133986

W skrócie, git remote prune czy magia

Znalazłem odpowiedź tutaj: Jak mogę usunąć wszystkie gałęzie git, które zostały połączone?

git branch --merged | grep -v "\*" | xargs -n 1 git branch -d

Upewnij się, że utrzymamy mistrza

Możesz upewnić się, że master, lub jakakolwiek inna gałąź nie zostanie usunięta przez dodanie kolejnej grep po pierwszej. W takim przypadku możesz wybrać:

git branch --merged | grep -v "\*" | grep -v "YOUR_BRANCH_TO_KEEP" | xargs -n 1 git branch -d

Więc jeśli chcemy zachować master, develop i staging na przykład:

git branch --merged | grep -v "\*" | grep -v "master" | grep -v "develop" | grep -v "staging" | xargs -n 1 git branch -d

Make this an alias

Ponieważ jest trochę długi, możesz dodać alias do swojego .zshrc lub .bashrc. Mój nazywa się gbpurge (dla git branches purge):

alias gbpurge='git branch --merged | grep -v "\*" | grep -v "master" | grep -v "develop" | grep -v "staging" | xargs -n 1 git branch -d'

Następnie przeładuj swój .bashrc lub .zshrc:

. ~/.bashrc

Lub

. ~/.zshrc

Normalnie nie odpowiadałbym na pytanie, które ma już 16 odpowiedzi, ale wszystkie inne odpowiedzi są błędne, a właściwa odpowiedź jest tak prosta. Pytanie brzmi: "czy istnieje prosty sposób na usunięcie wszystkich gałęzi śledzenia, których zdalny odpowiednik już nie istnieje?"

Jeśli "prosty" oznacza nie kruchy, nie niebezpieczny i bez polegania na narzędziach, które nie wszyscy czytelnicy będą mieli, to właściwa odpowiedź brzmi: nie.

Niektóre odpowiedzi są proste, ale nie robią tego, o co poproszono. Inni tak to, o co pytano, ale nie jest proste: wszystkie polegają na parsowaniu wyjścia Gita (a w większości przypadków na bootowaniu) za pomocą poleceń manipulacji tekstem lub języków skryptowych, które mogą nie być obecne w każdym systemie.

Czytaj dalej: https://stackoverflow.com/a/20107184/587365 i https://stackoverflow.com/a/26152574/587365

Jeśli chcesz to zrobić bezpiecznie, dla przypadku użycia w pytaniu (garbage-zbieraj gałęzie śledzące, które zostały usunięte na serwer, ale nadal istnieje jako lokalne gałęzie) i tylko z wysokopoziomowymi poleceniami Git, musisz

• git fetch --prune (LUB git fetch -p, który jest aliasem, lub git prune remote origin, który robi to samo bez pobierania, i prawdopodobnie nie jest tym, czego chcesz przez większość czasu).
• zwróć uwagę na wszystkie zdalne gałęzie, które są zgłaszane jako usunięte. Lub, aby znaleźć je później, git branch -v (każda osierocona gałąź śledzenia będzie oznaczona "[gone]").
• git branch -d [branch_name] na każdym osieroconym śledzeniu oddział

Wyjaśnienie tła

Aby zrozumieć, co się dzieje, musisz zdać sobie sprawę, że w sytuacji śledzenia gałęzi, masz nie jedną gałąź, ale trzy. (I pamiętać, że "gałąź" jest etykietą wskaźnika do commita.)

Dla gałęzi feature/X Zdalne repozytorium będzie miało tę gałąź i wywoła ją feature/X. Twoje lokalne repozytorium ma gałąź remotes/origin/feature/X, co oznacza: "to właśnie serwer powiedział mi, że jego gałąź feature/X była ostatnim razem rozmawialiśmy " i wreszcie, lokalne repozytorium ma gałąź feature/X, która wskazuje na twój najnowszy commit i jest skonfigurowane tak, aby "śledzić" remotes/origin/feature/X, co oznacza, że możesz ciągnąć i naciskać, aby utrzymać trzy wyrównane.

W pewnym momencie ktoś usunął feature/X na serwerze. Od tego momentu zostajesz z lokalnym feature/X (którego prawdopodobnie już nie chcesz, ponieważ prace nad funkcją X są prawdopodobnie zakończone), i twoim remotes/origin/feature/X, który z pewnością jest bezużyteczny, ponieważ jego jedynym celem było zapamiętanie stan gałęzi serwera.

I Git pozwoli Ci automatycznie wyczyścić zbędne remotes/origin/feature/X -- to właśnie robi git fetch --prune -- ale z jakiegoś powodu, nie pozwala Ci automatycznie usunąć własnego feature/X... mimo że twoja feature/X nadal zawiera osierocone informacje o śledzeniu, ma więc informacje pozwalające zidentyfikować dawne gałęzie śledzenia, które zostały w pełni połączone. (W końcu może daćtobie informacje, które pozwalają wykonać operację ręcznie siebie.)

Usuń wszystkie gałęzie, które zostały połączone w master, ale nie próbuj usuwać samego master:

git checkout master && git pull origin master && git fetch -p && git branch -d $(git branch --merged | grep master -v)

Lub dodaj alias:

alias gitcleanlocal="git checkout master && git pull origin master && git fetch -p && git branch -d $(git branch --merged | grep master -v)"

Wyjaśnienie:

git checkout master checkout master branch

git pull origin master Upewnij się, że lokalna gałąź połączyła wszystkie zdalne zmiany

git fetch -p Usuwanie odwołań do zdalnych gałęzi, które zostały usunięte

git branch -d $(git branch master --merged | grep master -v) usuń wszystkie gałęzie, które zostały scalone w master, ale nie próbuj usuwać samego master

git fetch -p

Spowoduje to usunięcie wszystkich gałęzi, które nie są śledzone zdalnie.

Może być przydatna dla niektórych, prosta jedna linia, aby wyczyścić wszystkie lokalne gałęzie z wyjątkiem master I develop

git branch | grep -v "master" | grep -v "develop" | xargs git branch -D

Nie wydaje mi się, aby było do tego wbudowane polecenie, ale można bezpiecznie wykonać następujące czynności:

git checkout master
git branch -d bug-fix-a

Kiedy użyjesz -d, git odmówi usunięcia gałęzi, chyba że zostanie ona całkowicie scalona z HEAD lub jej zdalnie śledzącą gałęzią. Możesz więc zawsze zapętlić wyjście git for-each-ref i spróbować usunąć każdą gałąź. Problem z tym podejściem polega na tym, że podejrzewam, że prawdopodobnie nie chcesz, aby bug-fix-d został usunięty tylko dlatego, że origin/bug-fix-d zawiera jego historię. Zamiast tego możesz Utwórz skrypt podobny do następującego:

#!/bin/sh

git checkout master &&
for r in $(git for-each-ref refs/heads --format='%(refname:short)')
do
  if [ x$(git merge-base master "$r") = x$(git rev-parse --verify "$r") ]
  then
    if [ "$r" != "master" ]
    then
      git branch -d "$r"
    fi
  fi
done

uwaga: nie testowałem tego skryptu - używaj tylko ostrożnie...

Spowoduje to usunięcie wszystkich scalonych lokalnych rozgałęzionych z wyjątkiem lokalnego odniesienia głównego i obecnie używanego:

git branch --merged | grep -v "*" | grep -v "master" | xargs git branch -d

I spowoduje to usunięcie wszystkich gałęzi, które zostały już usunięte ze zdalnego repozytorium, do którego odnosi się " origin", ale nadal są dostępne lokalnie w " remotes/origin".

git remote prune origin

Rozwiązanie Windows

Dla Microsoft Windows Powershell:

git checkout master; git remote update origin --prune; git branch -vv | Select-String -Pattern ": gone]" | % { $_.toString().Trim().Split(" ")[0]} | % {git branch -d $_}

Explaination

git checkout master przełączniki do gałęzi master

git remote update origin --prune śliwki zdalne gałęzie

git branch -vv gets a verbose output of all branches (Git reference)

Select-String -Pattern ": gone]" pobiera tylko te zapisy, w których zostały usunięte z pilota.

% { $_.toString().Trim().Split(" ")[0]} Pobierz nazwę gałęzi

% {git branch -d $_} usuwa gałąź

Wzór pasujący do "gone" w większości innych rozwiązań był dla mnie trochę przerażający. Aby być bezpieczniejszym, używa się znacznika --format, aby wyciągnąć status śledzenia każdej gałęzi.

Potrzebowałem wersji przyjaznej dla Windows, więc to usuwa wszystkie gałęzie, które są wymienione jako" gone " za pomocą Powershell:

git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)" | 
    ? { $_ -ne "" } | 
    % { git branch -D $_ }

Pierwsza linia zawiera nazwę lokalnych gałęzi, których odgałęzienie jest "gone". Następna linia usuwa puste linie (które są wypisywane dla gałęzi, które nie zostały " usunięte"), następnie nazwa gałęzi jest przekazywana do polecenia, aby usunąć gałąź.

Na podstawie informacji powyżej, to działało dla mnie:

git br -d `git br -vv | grep ': gone] ' | awk '{print $1}' | xargs`

Usuwa wszystkie lokalne gałęzie z are ': gone] ' na zdalnym.

Yet-another-answer for the stos, drawing mustly from https://stackoverflow.com/a/48411554/2858703 (co mi się podoba, bo wydaje się usuwać wszelkie niejasności o tym, gdzie gone] będzie pasować w wyjściu git branch), ale dodanie * Nix bent:

git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname)%(end)" \
  | sed 's,^refs/heads/,,;/^$/d' \
  | xargs git branch -D

Mam to zapakowane w git-gone skrypt na mojej drodze:

#!/usr/bin/env bash

action() {
  ${DELETE} && xargs git branch -D || cat
}

get_gone() {
  git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname)%(end)" \
    | sed 's,^refs/heads/,,;/^$/d'

}

main() {
  DELETE=false
  while [ $# -gt 0 ] ; do
    case "${1}" in
      (-[dD] | --delete) DELETE=true ;;
    esac
    shift
  done
  get_gone | action
}

main "${@}"

NB-opcja --format wydaje się być całkiem nowa; musiałem uaktualnić Gita z wersji 2.10.something to 2.16.3 to get it.

grep gone <(git branch -v) | cut -d ' ' -f 3 | xargs git branch -d

Powyższe polecenie może być użyte do pobierania gałęzi, które są scalane i usuwane w zdalnym i usuwa lokalną gałąź, która nie jest już dostępna w zdalnym

Nic z tego nie było dla mnie dobre. Chciałem czegoś, co wyczyściłoby wszystkie lokalne gałęzie, które śledziły zdalną gałąź, na origin, gdzie zdalna gałąź została usunięta (gone). Nie chciałem usuwać lokalnych gałęzi, które nigdy nie zostały skonfigurowane do śledzenia zdalnej gałęzi (np.: moje lokalne gałęzie dev). Również chciałem prosty one-liner, który po prostu używa git, lub innych prostych narzędzi CLI, zamiast pisania niestandardowych skryptów. W końcu użyłem trochę grep i awk, aby to uprościć dowództwo.

To ostatecznie skończyło się w moim ~/.gitconfig:

[alias]
  prune-branches = !git remote prune origin && git branch -vv | grep ': gone]' | awk '{print $1}' | xargs -r git branch -D

Oto git config --global ... polecenie do łatwego dodania tego jako git prune-branches:

git config --global alias.prune-branches '!git remote prune origin && git branch -vv | grep '"'"': gone]'"'"' | awk '"'"'{print $1}'"'"' | xargs -r git branch -d'

Uwaga: w poleceniu config, używam opcji -d do git branch zamiast -D, Jak to robię w moim rzeczywistym config. Używam -D, ponieważ nie chcę słyszeć, jak Git skarży się na niezalegane gałęzie. Możesz również chcieć tej funkcjonalności. Jeśli tak, po prostu użyj -D zamiast -d na końcu tego polecenia konfiguracyjnego.

Wymyśliłem skrypt Basha. Zawsze trzyma gałęzie develop, qa, master.

git-clear() {
  git pull -a > /dev/null

  local branches=$(git branch --merged | grep -v 'develop' | grep -v 'master' | grep -v 'qa' | sed 's/^\s*//')
  branches=(${branches//;/ })

  if [ -z $branches ]; then
    echo 'No branches to delete...'
    return;
  fi

  echo $branches

  echo 'Do you want to delete these merged branches? (y/n)'
  read yn
  case $yn in
      [^Yy]* ) return;;
  esac

  echo 'Deleting...'

  git remote prune origin
  echo $branches | xargs git branch -d
  git branch -vv
}

To mi pomogło:

git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 <(git branch -vv | grep origin) | awk '{print $1}' | xargs git branch -d

Nie jestem pewien jak długo, ale używam teraz git-up, który się tym zajmuje.

Robię git up i zaczyna śledzić nowe gałęzie i usuwa stare.

Żeby było jasne, nie jest to out-of-box Git command - https://github.com/aanand/git-up

BTW to również blokuje brudne drzewo i sprawia, że rebases wciąż z just git up.

Hope it ' ll be useful for someone

Oto rozwiązanie, którego używam do skorupy ryby. Sprawdzone na Mac OS X 10.11.5, fish 2.3.0 i git 2.8.3.

function git_clean_branches
  set base_branch develop

  # work from our base branch
  git checkout $base_branch

  # remove local tracking branches where the remote branch is gone
  git fetch -p

  # find all local branches that have been merged into the base branch
  # and delete any without a corresponding remote branch
  set local
  for f in (git branch --merged $base_branch | grep -v "\(master\|$base_branch\|\*\)" | awk '/\s*\w*\s*/ {print $1}')
    set local $local $f
  end

  set remote
  for f in (git branch -r | xargs basename)
    set remote $remote $f
  end

  for f in $local
    echo $remote | grep --quiet "\s$f\s"
    if [ $status -gt 0 ]
      git branch -d $f
    end
  end
end

Kilka uwag:

Upewnij się, że ustawiłeś poprawny base_branch. W tym przypadku używam develop jako gałęzi bazowej, ale może to być cokolwiek.

Ta część jest bardzo ważna: grep -v "\(master\|$base_branch\|\*\)". Zapewnia to, że nie usuniesz master lub podstawowej gałęzi.

Używam git branch -d <branch> jako dodatkowego zabezpieczenia, aby nie usuwać żadnej gałęzi, która nie została w pełni połączona z upstream lub current Głowa.

Łatwym sposobem testowania jest zastąpienie git branch -d $f przez echo "will delete $f".

Przypuszczam, że powinienem również dodać: używaj na własne ryzyko!

Używam krótkiej metody, aby zrobić sztuczkę, polecam zrobić to samo, ponieważ może to zaoszczędzić kilka godzin i dać większą widoczność

Wystarczy dodać następujący fragment do swojego .bashrc (.bashprofile na macos).

git-cleaner() { git fetch --all --prune && git branch --merged | grep -v -E "\bmaster|preprod|dmz\b" | xargs -n 1 git branch -d ;};

1. Pobierz wszystkie piloty
2. Get only merged branches from git
3. Usuń z tej listy gałęzie "chronione / ważne"
4. usuń resztę (np. oczyść i połącz gałęzie)

Będziesz musiał edytować grep regex w celu dopasowania do Twoich potrzeb (tutaj zapobiega usunięciu master, preprod i dmz)

Na podstawie Git Tip: usuwanie starych lokalnych gałęzi , które wyglądają podobnie do Jasona.rozwiązanie Rickmana zaimplementowałem w tym celu własne polecenie o nazwie git gone używając Basha:

$ git gone
usage: git gone [-pndD] [<branch>=origin]
OPTIONS
  -p  prune remote branch
  -n  dry run: list the gone branches
  -d  delete the gone branches
  -D  delete the gone branches forcefully

EXAMPLES
git gone -pn    prune and dry run
git gone -d     delete the gone branches

git gone -pn łączy w sobie przycinanie i wymienianie "znikniętych" gałęzi:

$ git gone -pn
  bport/fix-server-broadcast         b472d5d2b [origin/bport/fix-server-broadcast: gone] Bump modules
  fport/rangepos                     45c857d15 [origin/fport/rangepos: gone] Bump modules

Następnie możesz pociągnąć za spust za pomocą git gone -d lub git gone -D.

Uwagi

• Wyrażenie regularne, którego użyłem to "$BRANCH/.*: gone]" Gdzie $BRANCH normalnie byłoby origin. To pewnie nie działa, jeśli twoje wyjście Git jest zlokalizowane na francuskim itp.
• Sebastian Wiesner również przeportował go do Rusta dla użytkowników Windows. Ten jest również nazywany git gone .

Używam tej metody, żeby mieć większą kontrolę.

git branch -D $(git branch | grep -v "master" | grep -v "develop")

Jest to usunięcie wszelkich gałęzi nie nazwanych: master lub develop.

To usunie wszystkie zdalne gałęzie, które nie są obecne lokalnie (w Rubim):

bs = `git branch`.split; bs2 = `git branch -r | grep origin`.split.reject { |b| bs.include?(b.split('/')[1..-1].join('/')) }; bs2.each { |b| puts `git  push origin --delete #{b.split('/')[1..-1].join('/')}` }

Wyjaśnione:

# local branches
bs = `git branch`.split
# remote branches
bs2 = `git branch -r | grep origin`.split
# reject the branches that are present locally (removes origin/ in front)
bs2.reject! { |b| bs.include?(b.split('/')[1..-1].join('/')) }
# deletes the branches (removes origin/ in front)
bs2.each { |b| puts `git  push origin --delete #{b.split('/')[1..-1].join('/')}` }