Você pode excluir várias ramificações em um comando com o Git?

Eu gostaria de limpar o meu repositório local, que tem uma tonelada de ramos velhos: por exemplo 3.2, 3.2.1, 3.2.2, etc.

Eu estava esperando uma maneira sorrateira de remover muitos deles ao mesmo tempo. Como eles geralmente seguem uma convenção de liberação de pontos, pensei que talvez houvesse um atalho para dizer:

git branch -D 3.2.*

e mate todos os ramos 3.2.x.

Eu tentei esse comando e, é claro, não funcionou.

Não com essa sintaxe. Mas você pode fazer assim:

git branch -D 3.2 3.2.1 3.2.2

Basicamente, o git branch excluirá várias ramificações para você com uma única invocação. Infelizmente, ele não conclui o nome do ramo. Embora, no bash, você possa:

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

Bem, no pior dos casos, você pode usar:

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

EDITAR:

Uma versão mais segura (sugerida por Jakub Narębski e Jefromi), pois a saída do ramo git não deve ser usada no script:

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

... ou o xargs-free:

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

Você pode usar o git branch --list para listar os ramos elegíveis e o git branch -D / -d para remover os ramos elegíveis.

Um exemplo de revestimento:

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

Recentemente, eu estava procurando a solução do mesmo problema, finalmente encontrei uma resposta e está funcionando muito bem:

1. Abra o terminal ou equivalente.
2. Digite o ramo git | grep "pattern" para uma visualização dos ramos que serão excluídos.
3. Digite o ramo git | grep "padrão" | xargs git branch -D

Esta solução é incrível e, se você quiser uma explicação completa de cada comando e como ele está funcionando, é fornecido aqui .

Usar

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

Talvez você ache isso útil:

Se você deseja remover todos os ramos que não são, por exemplo, 'mestre', 'foo' e 'bar'

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

grep -v 'something' é um combinador com inversão.

Coloquei minhas iniciais e um hífen (at-) como os três primeiros caracteres do nome do ramo por esse motivo exato:

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

Se você não estiver limitado a usar o prompt de comando git, sempre poderá executar git guie usar o item de menu Filial-> Excluir. Selecione todos os ramos que você deseja excluir e deixe rasgar.

Solução Powershell:

Se você estiver executando o Windows, poderá usar o PowerShell para remover várias ramificações de uma só vez ...

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.

Você também pode ajustar como a correspondência de padrões deve funcionar usando o comando Select-String do Powershell. Dê uma olhada nos documentos do PowerShell .

Mantenha "desenvolver" e exclua todos os outros em locais

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

Fiz uma pequena função que pode ser útil com base na resposta fornecida por @ gawi (acima).

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

Adicione isso ao seu .bash_profilee reinicie seu terminal. Em seguida, você pode chamar da linha de comando da seguinte maneira:

removeBranchesWithPrefix somePrefix

Nota

Atualmente, tenho a configuração para uma exclusão reversível, o que significa que não excluirá as ramificações, a menos que elas já tenham sido mescladas. Se você gosta de viver no limite, mude -dpara -De ele excluirá tudo com o prefixo, independentemente!

Se você realmente precisa limpar todos os seus galhos, tente

git branch -d $(git branch)

Ele excluirá todas as suas ramificações locais mescladas, exceto a que você está fazendo check-in.

É uma boa maneira de limpar seu local

Você pode gostar deste pequeno item ... Ele puxa a lista e solicita a confirmação de cada item antes de finalmente excluir todas as seleções ...

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`

Use -D para forçar exclusões (como de costume).

Para facilitar a leitura, aqui está o que separamos linha por linha ...

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`

aqui está a abordagem 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

finalmente, eu gosto de ter isso no meu .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'

Dessa forma, eu posso apenas dizer

gitSelect | xargs git branch -D.

Para almas puras que usam o PowerShell aqui, o pequeno script git branch -d $(git branch --list '3.2.*' | %{$_.Trim() })

funciona corretamente para mim:

git branch | xargs git branch -d

git branch | xargs git branch -D

excluir todas as ramificações locais

Use o comando a seguir para remover todas as ramificações (a ramificação com check-out não será excluída).

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

Edit: Estou usando um Mac Os

Se você está no Windows, pode usar o PowerShell para fazer isso:

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

substitua feature/*por qualquer padrão que desejar.

Você pode usar este comando: git branch -D $(printf "%s\n" $(git branch) | grep '3.2')

Você pode usar git guipara excluir várias ramificações de uma só vez. Em Prompt de Comando / Bash -> git gui-> Remoto -> Excluir ramificação ... -> selecione ramificações remotas que você deseja remover -> Excluir.

Acabei de limpar um grande conjunto de filiais locais / remotas obsoletas hoje.

Abaixo está como eu fiz isso:

1. liste todos os nomes de ramificações em um arquivo de texto:

git branch -a >> BranchNames.txt

2. acrescente os ramos que desejo excluir ao comando "git branch -D -r":

git branch -D -r origem / dirA / branch01 origem / dirB / branch02 origem / dirC / branch03 (... acrescente quaisquer nomes de ramos)

3. execute o cmd

E este funciona muito mais rápido e confiável do que " git push origin --delete ".

Essa pode não ser a maneira mais inteligente, conforme listado em outras respostas, mas essa é bastante direta e fácil de usar.

Se você instalou a GUI do Git, que é um complemento padrão para Windows, é a mais simples. Você pode usar ctrl para escolher vários ramos e excluí-los com um clique.

Se você estiver usando o Fish shell, poderá aproveitar as stringfunções :

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

Isso não é muito diferente das opções do PowerShell em algumas das outras respostas.

Se você tiver todos os ramos a serem excluídos em um arquivo de texto (ramos para del.txt) (um ramo por linha), poderá fazer isso para excluir todos os ramos do controle remoto (origem): xargs -a branches-to-del.txt git push --delete origin

Para excluir várias ramificações com base em um padrão especificado, faça o seguinte:

Abra o terminal ou equivalente e digite os seguintes comandos:

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)

Remova todas as ramificações 3.2.x, você precisa digitar

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

Isso é tudo!

Você está pronto para ir!

Como no Git, todas as ramificações não são nada por referências ao .git/refrepositório git, por que você não exclui as ramificações e, se algo deixado de fora que não é interessante no repositório será automaticamente coletado como lixo? precisa se preocupar.

git branch -D <branchName>

Você pode remover todas as ramificações removendo todas as referências desnecessárias:

rm .git/refs/heads/3.2.*