Puoi eliminare più rami in un solo comando con Git?

Mi piacerebbe per ripulire il mio repository locale, che ha una tonnellata di vecchi rami: ad esempio 3.2, 3.2.1, 3.2.2, etc.

Speravo in un modo subdolo per rimuoverne molti contemporaneamente. Dato che seguono principalmente una convenzione di rilascio dei punti, ho pensato che forse ci fosse una scorciatoia per dire:

git branch -D 3.2.*

e uccidi tutti i rami 3.2.x.

Ho provato quel comando e, ovviamente, non ha funzionato.

Non con quella sintassi. Ma puoi farlo in questo modo:

git branch -D 3.2 3.2.1 3.2.2

Fondamentalmente, git branch cancellerà più rami per te con una sola chiamata. Sfortunatamente non completa il nome del ramo. Sebbene, in bash, puoi fare:

git branch -D `git branch | grep -E '^3\.2\..*'`

Bene, nel peggiore dei casi, potresti usare:

git branch | grep '3\.2' | xargs git branch -d

git branch  | cut -c3- | egrep "^3.2" | xargs git branch -D
  ^                ^                ^         ^ 
  |                |                |         |--- create arguments
  |                |                |              from standard input
  |                |                |
  |                |                |---your regexp 
  |                |
  |                |--- skip asterisk 
  |--- list all 
       local
       branches

MODIFICARE:

Una versione più sicura (suggerita da Jakub Narębski e Jefromi), poiché l'output di git branch non è pensato per essere utilizzato negli script:

git for-each-ref --format="%(refname:short)" refs/heads/3.2\* | xargs git branch -D

... o senza xargs:

git branch -D `git for-each-ref --format="%(refname:short)" refs/heads/3.2\*`

È possibile utilizzare git branch --list per elencare i rami idonei e utilizzare git branch -D / -d per rimuovere i rami idonei.

Un esempio di copertina:

git branch -d `git branch --list '3.2.*'`

Di recente, stavo cercando una soluzione per lo stesso problema, finalmente ho trovato una risposta e funziona molto bene:

1. Apri il terminale o equivalente.
2. Digitare git branch | grep "pattern" per un'anteprima dei rami che verranno eliminati.
3. Digitare git branch | grep "pattern" | xargs git branch -D

Questa soluzione è fantastica e se vuoi una spiegazione completa di ogni comando e di come funziona, è data qui .

Uso

git for-each-ref --format='%(refname:short)' 'refs/heads/3.2.*' |
   xargs git branch -D

Forse lo troverai utile:

Se si desidera rimuovere tutti i rami che non sono ad esempio "master", "pippo" e "barra"

git branch -D `git branch | grep -vE 'master|foo|bar'`

grep -v 'qualcosa' è un abbinamento con inversione.

Ho messo le mie iniziali e un trattino (at-) come i primi tre caratteri del nome del ramo per questo motivo esatto:

git branch -D `git branch --list 'at-*'`

Se non sei limitato all'utilizzo del prompt dei comandi git, puoi sempre eseguire git guie utilizzare la voce di menu Branch-> Elimina. Seleziona tutti i rami che desideri eliminare e lascialo strappare.

Soluzione Powershell:

Se usi Windows, puoi usare PowerShell per rimuovere più rami contemporaneamente ...

git branch -D ((git branch | Select-String -Pattern '^\s*3\.2\..*') | foreach{$_.ToString().Trim()})
//this will remove all branches starting with 3.2.

git branch -D ((git branch | Select-String -Pattern 'feature-*') | foreach{$_.ToString().Trim()})
// this will delete all branches that contains the word "feature-" as a substring.

Puoi anche mettere a punto il funzionamento della corrispondenza del modello usando il comando Select-String di Powershell. Dai un'occhiata ai documenti PowerShell .

Mantieni "sviluppa" ed elimina tutti gli altri in locale

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

Ho creato una piccola funzione che potrebbe essere utile sulla base della risposta fornita da @gawi (sopra).

removeBranchesWithPrefix() {
  git for-each-ref --format="%(refname:short)" refs/heads/$1\* | xargs git branch -d
}

Aggiungilo al tuo .bash_profilee riavvia il tuo terminale. Quindi puoi chiamare dalla riga di comando in questo modo:

removeBranchesWithPrefix somePrefix

Nota

L'ho attualmente configurato per un'eliminazione graduale, il che significa che non eliminerà i rami se non sono già stati uniti. Se ti piace vivere al limite, cambia -din -De cancellerà tutto con il prefisso a prescindere!

Se hai davvero bisogno di pulire tutti i tuoi rami, prova

git branch -d $(git branch)

Elimina tutte le filiali unite locali tranne quella che stai attualmente effettuando il check-in.

È un buon modo per rendere pulito il tuo locale

Potrebbe piacerti questo piccolo elemento ... Estrae l'elenco e chiede la conferma di ogni elemento prima di eliminare definitivamente tutte le selezioni ...

git branch -d `git for-each-ref --format="%(refname:short)" refs/heads/\* | while read -r line; do read -p "remove branch: $line (y/N)?" answer </dev/tty; case "$answer" in y|Y) echo "$line";; esac; done`

Usa -D per forzare le cancellazioni (come al solito).

Per leggibilità, ecco quella suddivisa riga per riga ...

git branch -d `git for-each-ref --format="%(refname:short)" refs/heads/\* |
    while read -r line; do 
        read -p "remove branch: $line (y/N)?" answer </dev/tty;
        case "$answer" in y|Y) echo "$line";; 
        esac; 
    done`

ecco l'approccio xargs ...

git for-each-ref --format="%(refname:short)" refs/heads/\* |
while read -r line; do 
    read -p "remove branch: $line (y/N)?" answer </dev/tty;
    case "$answer" in 
        y|Y) echo "$line";; 
    esac; 
done | xargs git branch -D

infine, mi piace avere questo nel mio .bashrc

alias gitselect='git for-each-ref --format="%(refname:short)" refs/heads/\* | while read -r line; do read -p "select branch: $line (y/N)?" answer </dev/tty; case "$answer" in y|Y) echo "$line";; esac; done'

In questo modo posso solo dire

gitSelect | xargs git branch -D.

Per le anime pure che usano PowerShell qui il piccolo script git branch -d $(git branch --list '3.2.*' | %{$_.Trim() })

funziona correttamente per me:

git branch | xargs git branch -d

git branch | xargs git branch -D

elimina tutte le filiali locali

Utilizzare il seguente comando per rimuovere tutti i rami (il ramo estratto non verrà eliminato).

git branch | cut -d '*' -f 1 | tr -d " \t\r" | xargs git branch -d

Modifica: sto usando un Mac OS

Se sei su Windows, puoi usare PowerShell per fare questo:

 git branch | grep 'feature/*' |% { git branch -D $_.trim() }

sostituire feature/*con qualsiasi motivo che ti piace.

Puoi usare questo comando: git branch -D $(printf "%s\n" $(git branch) | grep '3.2')

È possibile utilizzare git guiper eliminare più rami contemporaneamente. Da Prompt dei comandi / Bash -> git gui-> Remoto -> Elimina ramo ... -> seleziona i rami remoti che desideri rimuovere -> Elimina.

Oggi ho appena ripulito un gran numero di filiali locali / remote obsolete.

Di seguito è riportato come l'ho fatto:

1. elenca tutti i nomi delle filiali in un file di testo:

git branch -a >> BranchNames.txt

2. aggiungi i rami che voglio cancellare per comandare "git branch -D -r":

git branch -D -r origin / dirA / branch01 origin / dirB / branch02 origin / dirC / branch03 (... aggiungi qualsiasi nome di ramo)

3. eseguire il cmd

E questo funziona in modo molto più veloce e affidabile di " git push origin --delete ".

Questo potrebbe non essere il modo più intelligente come elencato in altre risposte, ma questo è piuttosto semplice e facile da usare.

Se hai installato Git GUI, che è un componente aggiuntivo predefinito per Windows, è il più semplice. Puoi usare ctrl per scegliere più rami ed eliminarli con un clic.

Se stai usando Fish shell, puoi sfruttare le stringfunzioni :

git branch -d (git branch -l "<your pattern>" | string trim)

Questo non è molto diverso dalle opzioni Powershell in alcune delle altre risposte.

Se avessi tutti i rami da eliminare in un file di testo (rami-a-del.txt) (un ramo per riga), allora potresti farlo per eliminare tutti questi rami dal telecomando (origine): xargs -a branches-to-del.txt git push --delete origin

Per eliminare più rami in base a un modello specificato, procedi come segue:

Apri il terminale o equivalente e digita i seguenti comandi:

git branch | grep "<pattern>" (preview of the branches based on pattern)

git branch | grep "<pattern>" | xargs git branch -D (replace the <pattern> with a regular expression to match your branch names)

Rimuovere tutti i rami 3.2.x, è necessario digitare

git branch | grep "3.2" | xargs git branch -D

È tutto!

Sei bravo ad andare!

Come in Git, tutti i rami non sono nulla in base al riferimento al repository git, perché non eliminare semplicemente i rami che stanno andando .git/refe quindi se qualcosa che non viene lasciato fuori che non è interessante nel repository verrà automaticamente raccolto, quindi non ho bisogno di preoccuparti.

git branch -D <branchName>

Puoi rimuovere tutti i rami rimuovendo tutti i riferimenti non necessari:

rm .git/refs/heads/3.2.*