Como remover ramificações de rastreamento local que não existem mais no controle remoto

Com git remote prune origineu posso remover os ramos locais que não estão mais no controle remoto.

Mas também quero remover as ramificações locais criadas a partir dessas ramificações remotas (verificar se elas estão imersas seria bom).

Como posso fazer isso?

Após a remoção, você pode obter a lista de ramificações remotas com git branch -r. A lista de ramificações com sua ramificação de rastreamento remoto pode ser recuperada com git branch -vv. Portanto, usando essas duas listas, é possível encontrar as ramificações de rastreamento remoto que não estão na lista de controles remotos.

Essa linha deve funcionar (requer bashou zshnão funciona com o shell Bourne padrã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

Essa sequência obtém a lista de ramificações remotas e a passa egreppela entrada padrão. E filtra as ramificações que possuem uma ramificação de rastreamento remoto (usando git branch -vve filtrando as que possuem origin), obtendo a primeira coluna dessa saída, que será o nome da ramificação. Por fim, passando todos os nomes de ramificações para o comando delete branch.

Como está usando a -dopção, ele não excluirá as ramificações que não foram mescladas na ramificação em que você está quando executa este comando.

Lembre-se de que você precisará executar git fetch --prune primeiro , caso contrário git branch -r, ainda verá as ramificações remotas.

Se você deseja excluir todas as ramificações locais que já foram mescladas no mestre, você pode usar o seguinte comando:

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

Mais informações .

Entre as informações apresentadas por git help fetch, existe este pequeno item:

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

Então, talvez, git fetch -pé o que você está procurando?

EDIT: Ok, para aqueles que ainda debatem esta resposta três anos após o fato, aqui está um pouco mais de informações sobre por que eu a apresentei ...

Primeiro, o OP diz que deseja "remover também as ramificações locais criadas a partir dessas ramificações remotas [que não estão mais no controle remoto]". Isso não é inequivocamente possível em git. Aqui está um exemplo.

Digamos que eu tenha um repositório em um servidor central e ele tenha duas ramificações, chamadas Ae B. Se eu clonar esse repo no meu sistema local, meu clone terá refs locais (ainda não são ramificações reais) chamados origin/Ae origin/B. Agora, digamos que eu faça o seguinte:

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

Os fatos pertinentes aqui são que, por algum motivo, escolhi criar uma ramificação no repositório local que tenha um nome diferente da sua origem e também tenho uma ramificação local que ainda não existe no repositório de origem.

Agora, digamos que eu remova os ramos Ae Bno repositório remoto e atualizo meu repositório local ( git fetchde alguma forma), o que faz com que meus representantes locais origin/Ae origin/Bdesapareçam. Agora, meu repo local tem três ramos ainda, A, Z, e C. Nenhuma delas possui uma ramificação correspondente no repositório remoto. Dois deles foram "criados a partir de ... ramificações remotas", mas mesmo que eu saiba que costumava haver uma ramificação chamada Bna origem, não tenho como saber que Zfoi criada a partir deB, porque foi renomeado no processo, provavelmente por um bom motivo. Então, realmente, sem algum processo externo que registre os metadados de origem da ramificação, ou um humano que conhece o histórico, é impossível dizer qual das três ramificações, se houver, o OP está mirando para remoção. Sem algumas informações externas que gitnão são mantidas automaticamente para você, git fetch -pé o mais próximo possível e qualquer método automático para literalmente tentar o que o OP pediu corre o risco de excluir muitas ramificações ou perder algumas que o OP faria de outra forma deseja excluir.

Também existem outros cenários, como se eu crie três ramificações separadas origin/Apara testar três abordagens diferentes de alguma coisa e depois origin/Adesapareça. Agora eu tenho três ramificações, que obviamente não podem corresponder ao nome, mas foram criadas a partir de origin/A, portanto, uma interpretação literal da questão dos OPs exigiria a remoção das três. No entanto, isso pode não ser desejável, se você puder encontrar uma maneira confiável de combiná-los ...

Isso excluirá as ramificações locais para as quais as ramificações de rastreamento remoto foram removidas. (Verifique se você está no masterramo!)

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

Detalhes:

• git branch -vv exibe "ido" para ramificações locais que o controle remoto foi removido.

  mybranch abc1234 [origin/mybranch: gone] commit comments
  

• -dverificará se foi mesclado ( -Dserá excluído independentemente)

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

Pode-se configurar o Git para remover automaticamente referências a ramificações remotas excluídas ao buscar:

git config --global fetch.prune true

Ao ligar git fetchou git pulldepois, as referências às ramificações remotas excluídas são removidas automaticamente.

Há um pacote NPM limpo que faz isso por você (e deve funcionar em várias plataformas).

Instale-o com: npm install -g git-removed-branches

E, em seguida git removed-branches, mostrará todas as ramificações locais obsoletas e as git removed-branches --pruneexcluirá.

Mais informações aqui.

Solução Windows

Para o 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 $_}

Explicação

git checkout master muda para o ramo principal

git remote update origin --prune ameixas ramos remotos

git branch -vvobtém uma saída detalhada de todos os ramos ( referência do git )

Select-String -Pattern ": gone]" obtém apenas os registros de onde foram removidos do controle remoto.

% { $_.toString().Split(" ")[0]} obter o nome do ramo

% {git branch -d $_} exclui a ramificação

Ele listará as ramificações locais cuja ramificação de rastreamento remoto foi excluída do controle remoto.

$ git remote prune origin --dry-run

Se você deseja des-referenciar essas ramificações locais de local que não são rastreadas

$ git remote prune origin

Como o @tzacks observa ... existe um pacote npm que é útil para isso. Apenas faça:

npx git-removed-branches --prune

(Eu teria comentado, mas não a reputação suficiente)

Se você estiver usando o Windows e o Powershell, poderá usar o seguinte para excluir todas as filiais locais que foram mescladas na filial atualmente com check-out:

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

Explicação

• Lista a ramificação atual e as ramificações que foram mescladas a ela
• Filtra a ramificação atual
• Limpa todos os espaços iniciais ou finais da gitsaída para cada nome de filial restante
• Exclui as ramificações locais mescladas

Vale a pena rodar git branch --mergedpor si só primeiro apenas para garantir que ele apenas remova o que você espera.

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

Linha única ainda mais curta e segura:

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

Certifique-se de fazer o checkout para a ramificação que ainda não foi mesclada antes de executá-la. Porque você não pode excluir o ramo em que você está atualmente registrado.

Eu queria algo que limpasse todas as ramificações locais que estavam rastreando uma ramificação remota origin, onde o ramo remoto foi excluído ( gone). Eu não queria excluir ramificações locais que nunca foram configuradas para rastrear uma ramificação remota (ou seja: minhas ramificações locais de desenvolvimento). Além disso, eu queria um one-liner simples que apenas usasse git, ou outras ferramentas CLI simples, em vez de escrever scripts personalizados. Acabei usando um pouco de grepe awkpara fazer esse comando simples, depois o adicionei como um alias no meu ~/.gitconfig.

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

Aqui está um git config --global ...comando para adicionar isso facilmente como 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: O uso da -Dbandeira git branchpode ser muito perigoso. Portanto, no comando config acima, uso a -dopção em git branchvez de -D; Eu uso -Dna minha configuração real. Uso -Dporque não quero ouvir o Git reclamar de galhos imersos, só quero que eles desapareçam. Você também pode querer essa funcionalidade. Nesse caso, basta usar em -Dvez de -dno final desse comando de configuração.

Para remover ramificações remotas:

$git remote prune origin

Para remover ramificações locais que já foram mescladas:

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

Não parece haver uma linha segura, muitos casos extremos (como um ramo que tenha "mestre" como parte do nome, etc.). Mais seguras são estas etapas:

1. git branch -vv | grep 'gone]' > stale_branches.txt
2. visualize o arquivo e remova linhas dos ramos que você deseja manter (como ramo principal!); você não precisa editar o conteúdo de nenhuma linha
3. awk '{print $1}' stale_branches.txt | xargs git branch -d

Com base nas respostas acima, estou usando este forro mais curto:

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

Além disso, se você já tiver podado e tiver galhos pendentes locais, isso os limpará:

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

não sabe como fazer tudo de uma vez, mas o git git branch -d <branchname>excluirá SOMENTE uma ramificação local se ela for completamente mesclada. Observe as letras minúsculas d.

git branch -D <branchname> (observe a letra D maiúscula) excluirá uma filial local, independentemente de seu status mesclado.

Você pode usar este comando:

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

Git Clean: Excluir ramificações já mescladas, incluindo quebra de comando

Com base nas respostas acima, vim com esta solução de uma linha:

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 uma variante da resposta do @ wisbucky, adicionei o seguinte como um alias ao meu ~/.gitconfigarquivo:

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"

Com isso, um simples git pruneitgoodlimpará as ramificações locais e remotas que não são mais necessárias após as mesclagens.

A versão Powershell de git branch --merged master | grep -v '^[ *]*master$' | xargs git branch -d

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

Isso removerá quaisquer ramificações locais que foram mescladas no mestre, enquanto você estiver no ramo mestre .

git checkout master para trocar.

A variante de Schleis não funciona para mim (Ubuntu 12.04), então deixe-me propor minhas variantes (claras e brilhantes :):

Variante 1 (eu preferiria esta opção):

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

Variante 2:

uma. Funcionamento a seco:

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

b. Remova ramificações:

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

A seguir, é apresentada uma adaptação da resposta do @ wisbucky para usuários do Windows:

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

Eu uso o posh-git e, infelizmente, o PS não gosta de nus for, então criei um script de comando simples chamado 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

Chame-o sem parâmetros para ver uma lista e, em seguida, chame-o com "-d" para executar a exclusão real ou "-D" para quaisquer ramificações que não sejam totalmente mescladas, mas que você deseja excluir de qualquer maneira.

Tente isso no git bash, para buscar e remover referências a ramificações excluídas e depois remover as ramificações locais que estavam rastreando as ramificações removidas:

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

Lembre-se de fazer o checkout primeiro de um ramo que não será excluído, para que não bloqueie a exclusão do ramo.

Transformei a resposta aceita em um script robusto. Você o encontrará no repositório 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>

Cheguei a esta página buscando a resposta para "como faço para excluir ramificações com check-out local que não têm mais ramificação upstream"

Também não me importei se a ramificação local ainda não havia sido mesclada, pois a canalização git branch -dsimplesmente avisará em vez de excluir ramificações locais não imersas.

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

Em Powershell :

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

Aqui está a minha solução:

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

• -p é remover todas as referências de rastreamento remoto que não existem mais no controle remoto. Portanto, o primeiro passo removerá referências a ramificações remotas.

• -vv é para mostrar sha1 e confirmar a linha de assunto para cada cabeçalho, juntamente com o relacionamento com o ramo upstream (se houver). A segunda etapa obterá todos os ramos locais e o comando grep filtrará os ramos que foram excluídos.

Exclua qualquer filial que não esteja atualizada com o mestre

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

Tenho certeza de que git remote prune originé isso que você quer.

Você pode executá-lo git remote prune origin --dry-runpara ver o que faria sem fazer alterações.

Usando a GUI? Procedimento manual, mas rápido e fácil.

$ git gui

Selecione "Filial -> Excluir". Você pode selecionar várias ramificações com a tecla Ctrl (Windows) e remover todas elas.