Come eliminare i rami di localizzazione locali che non esistono più sul telecomando

Con git remote prune originposso rimuovere i rami locali che non sono più sul telecomando.

Ma voglio anche rimuovere i rami locali che sono stati creati da quei rami remoti (un controllo se non sono uniti sarebbe bello).

Come posso fare questo?

Dopo la potatura, puoi ottenere l'elenco dei rami remoti con git branch -r. L'elenco dei rami con il loro ramo di tracciamento remoto può essere recuperato con git branch -vv. Quindi usando questi due elenchi puoi trovare i rami di localizzazione remoti che non sono nell'elenco dei telecomandi.

Questa linea dovrebbe fare il trucco (richiede basho zshnon funzionerà con la shell Bourne standard):

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

Questa stringa ottiene l'elenco di rami remoti e lo passa egrepattraverso l'input standard. E filtra i rami che hanno un ramo di tracciamento remoto (usando git branch -vve filtrando quelli che lo hanno origin) quindi ottenendo la prima colonna di quell'output che sarà il nome del ramo. Passando infine tutti i nomi dei rami nel comando Elimina ramo.

Poiché utilizza l' -dopzione, non eliminerà i rami che non sono stati uniti nel ramo in cui ci si trova quando si esegue questo comando.

Ricorda inoltre che dovrai eseguire git fetch --prune prima , altrimenti git branch -rvedrai comunque i rami remoti.

Se si desidera eliminare tutti i rami locali che sono già stati uniti in master, è possibile utilizzare il comando seguente:

git branch --merged master | grep -v '^[ *]*master$' | xargs git branch -d

Maggiori informazioni .

Tra le informazioni presentate da git help fetch, c'è questo piccolo oggetto:

 -p, --prune
        After fetching, remove any remote-tracking branches which no longer exist on the remote.

Quindi, forse, git fetch -pè quello che stai cercando?

EDIT: Ok, per coloro che stanno ancora discutendo questa risposta 3 anni dopo il fatto, ecco alcune informazioni in più sul perché ho presentato questa risposta ...

In primo luogo, l'OP afferma che vogliono "rimuovere anche quei rami locali che sono stati creati da quei rami remoti [che non sono più sul telecomando]". Questo non è inequivocabilmente possibile in git. Ecco un esempio

Diciamo che ho un repository su un server centrale e ha due rami, chiamato Ae B. Se clonerò quel repository sul mio sistema locale, il mio clone avrà riferimenti locali (non ancora rami effettivi) chiamati origin/Ae origin/B. Ora diciamo che faccio quanto segue:

git checkout -b A origin/A
git checkout -b Z origin/B
git checkout -b C <some hash>

I fatti pertinenti qui sono che per qualche ragione ho scelto di creare un ramo sul mio repository locale che ha un nome diverso rispetto alla sua origine, e ho anche un ramo locale che non esiste (ancora) sul repository di origine.

Ora diciamo che posso rimuovere sia l' Ae Brami sul repo remoto e aggiornare il mio repo locale ( git fetchdi una qualche forma), che fa sì che i miei arbitri locali origin/Ae origin/Bdi scomparire. Ora, il mio repo locale ha tre rami ancora, A, Z, e C. Nessuno di questi ha un ramo corrispondente sul repository remoto. Due di loro sono stati "creati da ... rami remoti", ma anche se so che esisteva un ramo chiamato Bsull'origine, non ho modo di sapere che è Zstato creato daB, perché è stato rinominato nel processo, probabilmente per una buona ragione. Quindi, davvero, senza alcuni processi esterni che registrano metadati sull'origine dei rami, o un essere umano che conosca la storia, è impossibile dire quale dei tre rami, se ce ne sono, l'OP ha come obiettivo la rimozione. Senza alcune informazioni esterne che gitnon vengono conservate automaticamente per te, git fetch -pè il più vicino possibile e qualsiasi metodo automatico per tentare letteralmente ciò che l'OP ha chiesto corre il rischio di eliminare troppe filiali o di mancarne alcune che altrimenti l'OP vuoi cancellato.

Esistono anche altri scenari, ad esempio se creo tre rami separati origin/Aper testare tre diversi approcci a qualcosa e poi origin/Ascompare. Ora ho tre rami, che ovviamente non possono tutti corrispondere al nome, ma sono stati creati da origin/A, e quindi un'interpretazione letterale della domanda di OP richiederebbe la rimozione di tutti e tre. Tuttavia, ciò potrebbe non essere desiderabile, se potessi anche trovare un modo affidabile per abbinarli ...

Ciò eliminerà i rami locali per i quali sono stati potati i rami di tracciamento remoto. (Assicurati di essere sul masterramo!)

git checkout master
git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -d

Dettagli:

• git branch -vv visualizza "sparito" per le filiali locali che il telecomando è stato eliminato.

  mybranch abc1234 [origin/mybranch: gone] commit comments
  

• -dcontrollerà se è stato unito ( -Dlo eliminerà indipendentemente)

  error: The branch 'mybranch' is not fully merged.
  

È possibile configurare Git per rimuovere automaticamente i riferimenti ai rami remoti eliminati durante il recupero:

git config --global fetch.prune true

Quando si chiama git fetcho git pullsuccessivamente, i riferimenti ai rami remoti eliminati vengono rimossi automaticamente.

C'è un pacchetto NPM pulito che lo fa per te (e dovrebbe funzionare su più piattaforme).

Installalo con: npm install -g git-removed-branches

E poi git removed-branchesti mostrerà tutti i rami locali stantii e git removed-branches --pruneli cancellerà davvero.

Maggiori informazioni qui.

Soluzione Windows

Per 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 $_}

spiegazione

git checkout master passa al ramo principale

git remote update origin --prune pota i rami remoti

git branch -vvottiene un output dettagliato di tutti i rami ( riferimento git )

Select-String -Pattern ": gone]" ottiene solo i record in cui sono stati rimossi dal remoto.

% { $_.toString().Split(" ")[0]} ottenere il nome del ramo

% {git branch -d $_} cancella il ramo

Elencherà le filiali locali il cui ramo di tracciamento remoto viene eliminato da remoto

$ git remote prune origin --dry-run

Se si desidera annullare la referenziazione di questi rami locali da locali non tracciati

$ git remote prune origin

Come osserva @tzacks ... c'è un pacchetto npm che è utile per questo. Basta fare:

npx git-removed-branches --prune

(Avrei commentato ma non abbastanza reputazione)

Se si utilizzano Windows e Powershell, è possibile utilizzare quanto segue per eliminare tutti i rami locali che sono stati uniti nel ramo attualmente estratto:

git branch --merged | ? {$_[0] -ne '*'} | % {$_.trim()} | % {git branch -d $_}

Spiegazione

• Elenca il ramo corrente e i rami che sono stati uniti in esso
• Filtra il ramo corrente
• Pulisce gli spazi iniziali o finali gitdall'output per ciascun nome di ramo rimanente
• Elimina le filiali locali unite

Vale la pena correre git branch --mergedda solo prima solo per assicurarsi che rimuoverà solo quello che ti aspetti.

(Portato / automatizzato da http://railsware.com/blog/2014/08/11/git-housekeeping-tutorial-clean-up-outdated-branches-in-local-and-remote-repositories/ .)

One-liner ancora più corto e sicuro:

git branch -d $(git branch --merged | cut -c 3- | grep -v master)

Assicurati di effettuare il checkout al ramo che non è stato ancora unito, prima di eseguirlo. Perché non è possibile eliminare il ramo in cui si è attualmente registrati.

Volevo qualcosa che eliminasse tutti i rami locali che stavano monitorando un ramo remoto, su origin, dove il ramo remoto è stato eliminato ( gone). Non volevo eliminare i rami locali che non erano mai stati impostati per tenere traccia di un ramo remoto (es .: i miei rami di sviluppo locali). Inoltre, volevo un semplice one-liner che utilizza solo gito altri semplici strumenti CLI, piuttosto che scrivere script personalizzati. Ho finito per usare un po 'di grepe awkper fare questo semplice comando, quindi l'ho aggiunto come alias nel mio ~/.gitconfig.

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

Ecco un git config --global ...comando per aggiungere facilmente questo come 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'

NOTA: l'uso della -Dbandiera per git branchpuò essere molto pericoloso. Quindi, nel comando di configurazione sopra uso l' -dopzione git branchinvece di -D; Uso -Dnella mia configurazione attuale. Lo uso -Dperché non voglio sentire Git lamentarsi di rami non uniti, voglio solo che se ne vadano. Potresti volere anche questa funzionalità. In tal caso, utilizzare semplicemente -Danziché -dalla fine di quel comando di configurazione.

Per rimuovere filiali remote:

$git remote prune origin

Per rimuovere le filiali locali già unite:

$git branch -D $(git branch --merged)

Non sembra esserci un one-liner sicuro, troppi casi limite (come un ramo con "master" come parte del suo nome, ecc.). I passaggi più sicuri sono:

1. git branch -vv | grep 'gone]' > stale_branches.txt
2. visualizza il file e rimuovi le linee per i rami che vuoi conservare (come il ramo principale!); non è necessario modificare il contenuto di nessuna riga
3. awk '{print $1}' stale_branches.txt | xargs git branch -d

Sulla base delle risposte di cui sopra, sto usando questa copertina più corta:

git remote prune origin | awk 'BEGIN{FS="origin/"};/pruned/{print $2}' | xargs -r git branch -d

Inoltre, se hai già potato e hai rami penzolanti locali, questo li pulirà:

git branch -vv | awk '/^ .*gone/{print $1}' | xargs -r git branch -d

non sono sicuro di come fare tutto in una volta, ma git git branch -d <branchname> eliminerà un ramo locale SOLO se è completamente unito. Nota la minuscola d.

git branch -D <branchname> (nota la maiuscola D) eliminerà una filiale locale indipendentemente dal suo stato unito.

Puoi usare questo comando:

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

Git Clean: elimina i rami già uniti, inclusa la suddivisione del comando

Sulla base delle risposte di cui sopra sono arrivato con questa soluzione a una riga:

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

Usando una variante sulla risposta di @wisbucky, ho aggiunto quanto segue come alias al mio ~/.gitconfigfile:

pruneitgood = "!f() { \
    git remote prune origin; \
    git branch -vv | perl -nae 'system(qw(git branch -d), $F[0]) if $F[3] eq q{gone]}'; \
}; f"

Con questo, un semplice git pruneitgoodpulirà le filiali locali e remote che non sono più necessarie dopo le fusioni.

La versione Powershell di git branch --merged master | grep -v '^[ *]*master$' | xargs git branch -d

git branch --merged master | %{ if($_ -notmatch '\*.*master'){ git branch -d "$($_.Trim())" }}

Ciò rimuoverà tutti i rami locali che sono stati uniti in master, mentre ci si trova nel ramo principale .

git checkout master per passare.

La variante di Schleis non funziona per me (Ubuntu 12.04), quindi lasciami proporre le mie varianti (chiare e brillanti :):

Variante 1 (preferirei questa opzione):

git for-each-ref --format='%(refname:short) %(upstream)' refs/heads/ | awk '$2 !~/^refs\/remotes/' | xargs git branch -D 

Variante 2:

un. Funzionamento a secco:

comm -23 <( git branch | grep -v "/" | grep -v "*" | sort ) <( git br -r | awk -F '/' '{print $2}' | sort ) | awk '{print "git branch -D " $1}'

b. Rimuovi rami:

comm -23 <( git branch | grep -v "/" | grep -v "*" | sort ) <( git br -r | awk -F '/' '{print $2}' | sort ) | xargs git branch -D

Di seguito è riportato un adattamento della risposta di @wisbucky per gli utenti di Windows:

for /f "tokens=1" %i in ('git branch -vv ^| findstr ": gone]"') DO git branch %i -d

Uso posh-git e purtroppo a PS non piace il nudo for, quindi ho creato un semplice script di comando chiamato PruneOrphanBranches.cmd:

@ECHO OFF
for /f "tokens=1" %%i in ('git branch -vv ^| findstr ": gone]"') DO CALL :ProcessBranch %%i %1

GOTO :EOF

:ProcessBranch
IF /I "%2%"=="-d" (
    git branch %1 %2
) ELSE (
    CALL :OutputMessage %1
)
GOTO :EOF

:OutputMessage
ECHO Will delete branch [%1] 
GOTO :EOF

:EOF

Chiamalo senza parametri per visualizzare un elenco, quindi chiamalo con "-d" per eseguire l'effettiva eliminazione o "-D" per tutti i rami che non sono completamente uniti ma che desideri comunque eliminare.

Prova questo in git bash, per recuperare e eliminare i riferimenti ai rami eliminati, quindi elimina i rami locali che stavano monitorando quelli rimossi:

git fetch -p && git branch -d `git branch -vv | grep ': gone]' | awk '{print $1}' | xargs`

Ricorda di effettuare prima il checkout di un ramo che non verrà eliminato, in modo che non blocchi l'eliminazione del ramo.

Ho trasformato la risposta accettata in uno script solido. Lo troverai nel mio repository git-extensions .

$ git-prune --help
Remove old local branches that do not exist in <remote> any more.
With --test, only print which local branches would be deleted.
Usage: git-prune [-t|--test|-f|--force] <remote>

Ho raggiunto questa pagina cercando la risposta per "come posso eliminare i rami estratti localmente che non hanno più un ramo a monte"

Inoltre, non mi importava se la filiale locale fosse stata o meno ancora unita, dato che il piping in git branch -davrebbe semplicemente avvisato invece di eliminare le filiali locali non unite.

git branch -a | grep origin | tr -s ' ' | cut -d '/' -f3 | egrep -v -f /dev/fd/0 <(git branch -a | grep -v origin) | grep branch_prefix_that_I_care_about | xargs git branch -d

# translation
# git branch -a | grep origin | tr -s ' ' | cut -d '/' -f3
## this finds all remote branch names minus the "remote/origin/" part
#
# <(git branch -a | grep -v origin)
## this finds all local branch names and redirects it into the previous command
#
# egrep -v -f /dev/fd/0 STUFF
## this is doing some weird magic that I'm grokking as "take the set difference from whatever was piped in"
#
#
# overall translation: (STUFF TO CONSIDER) | egrep magic <(STUFF TO REMOVE FROM CONSIDERATION) | do cool things with resulting stuff

In Powershell :

git branch -D (git branch --merged |% { $_.trim() } )

Ecco la mia soluzione:

git fetch -p
git branch -vv | grep ": gone" | awk '{print $1}' | xargs git branch -d

• -p è di rimuovere tutti i riferimenti di tracciamento remoto che non esistono più sul telecomando. Quindi il primo passo rimuoverà i riferimenti ai rami remoti.

• -vv serve a mostrare sha1 e impegnare la riga dell'oggetto per ogni capo, insieme alla relazione con il ramo a monte (se presente). Il secondo passo otterrà tutti i rami locali e il comando grep filtrerà i rami che sono stati eliminati.

Elimina qualsiasi ramo non aggiornato con master

git co master && git branch | sed s/\*/\ / | xargs git branch -d 2> /dev/null

Sono abbastanza sicuro che git remote prune originè quello che vuoi.

Puoi eseguirlo come git remote prune origin --dry-runper vedere cosa farebbe senza apportare modifiche.

Usando la GUI? Procedura manuale, ma semplice e veloce.

$ git gui

Seleziona "Branch -> Elimina". È possibile selezionare più rami con Ctrl-clic (Windows) e rimuoverli tutti.