Como eu excluo uma ramificação do Git local e remotamente?

Desejo excluir uma ramificação localmente e na bifurcação do meu projeto remoto no GitHub .

Tentativas Falha ao Excluir Ramificação Remota

$ git branch -d remotes/origin/bugfix error: branch 'remotes/origin/bugfix' not found. $ git branch -d origin/bugfix error: branch 'origin/bugfix' not found. $ git branch -rd origin/bugfix Deleted remote branch origin/bugfix (was 2a14ef7). $ git push Everything up-to-date $ git pull From github.com:gituser/gitproject * [new branch] bugfix -> origin/bugfix Already up-to-date. 

O que eu preciso fazer de forma diferente para excluir com sucesso a ramificação remotes/origin/bugfix localmente e no GitHub?

Sumário executivo

 $ git push --delete   $ git branch -d  

Observe que, na maioria dos casos, o nome remoto é origin .

Excluir ramificação local

Para excluir a ramificação local , use um dos seguintes:

 $ git branch -d branch_name $ git branch -D branch_name 

Nota: A opção -d é um alias para --delete , que exclui somente a ramificação se já tiver sido totalmente mesclada em sua ramificação upstream. Você também pode usar -D , que é um alias para --delete --force , que exclui a ramificação “independentemente de seu status mesclado”. [Fonte: man git-branch ]

Excluir ramificação remota [Atualizado em 8 de setembro de 2017]

A partir do Git v1.7.0 , você pode excluir uma ramificação remota usando

 $ git push  --delete  

que pode ser mais fácil de lembrar do que

 $ git push  : 

que foi adicionado no Git v1.5.0 “para deletar uma ramificação remota ou uma tag.”

A partir do Git v2.8.0, você também pode usar o git push com a opção -d como um alias para --delete .

Portanto, a versão do Git que você instalou determinará se você precisa usar a syntax mais fácil ou mais difícil.

Excluir ramificação remota [Resposta original de 5 de janeiro de 2010]

Do capítulo 3 de Pro Git por Scott Chacon:

Excluindo Ramificações Remotas

Suponha que você tenha terminado com uma ramificação remota – digamos, você e seus colaboradores terminaram com um recurso e o mesclaram com a ramificação principal do seu controle remoto (ou qualquer ramificação na qual sua linha de código estável esteja). Você pode excluir uma ramificação remota usando a syntax rather git push [remotename] :[branch] . Se você deseja excluir sua ramificação de servidor do servidor, execute o seguinte:

 $ git push origin :serverfix To git@github.com:schacon/simplegit.git - [deleted] serverfix 

Estrondo. Não há mais ramificações no seu servidor. Você pode querer adivinhar essa página, porque precisará desse comando e provavelmente esquecerá a syntax. Uma maneira de lembrar este comando é chamar a syntax do git push [remotename] [localbranch]:[remotebranch] que analisamos um pouco antes. Se você deixar a porção [localbranch] , então você está basicamente dizendo: “Não pegue nada do meu lado e faça-o [remotebranch] ”.

Eu emiti a git push origin :bugfix e funcionou lindamente. Scott Chacon estava certo – eu vou querer ouvir essa página (ou praticamente ouvi-lo respondendo ao Stack Overflow).

Então você deve executar isso em outras máquinas

 git fetch --all --prune 

para propagar mudanças.

A resposta de Mateus é ótima para remover ramificações remotas e também aprecio a explicação, mas para fazer uma distinção simples entre os dois comandos:

Para remover um ramo local da sua máquina:

git branch -d {the_local_branch} (use -D para forçar a exclusão da ramificação sem verificar o status da git branch -d {the_local_branch} )

Para remover uma ramificação remota do servidor:

git push origin --delete {the_remote_branch}

Referência: https://makandracards.com/makandra/621-git-delete-a-branch-local-or-remote

As respostas curtas

Se você quiser explicações mais detalhadas dos seguintes comandos, veja as respostas longas na próxima seção.

Excluindo uma ramificação remota:

 git push origin --delete  # Git version 1.7.0 or newer git push origin : # Git versions older than 1.7.0 

Excluindo um ramo local:

 git branch --delete  git branch -d  # Shorter version git branch -D  # Force delete un-merged branches 

Excluindo uma ramificação de rastreamento remoto local:

 git branch --delete --remotes / git branch -dr / # Shorter git fetch  --prune # Delete multiple obsolete tracking branches git fetch  -p # Shorter 

A resposta longa: existem 3 ramos diferentes para excluir!

Quando você está lidando com a exclusão de filiais tanto local quanto remotamente, lembre-se de que há três filiais diferentes envolvidas :

  1. A ramificação local X
  2. O ramo de origem remota X
  3. A ramificação de rastreamento remoto local origin/X que rastreia a ramificação remota X

Visualização de 3 filiais

O pôster original usado

 git branch -rd origin/bugfix 

que apenas excluiu sua origin/bugfix rastreamento remoto local , e não a bugfix de bugfix ramificação remota real na origin .

Diagrama 2

Para excluir esse ramo remoto real , você precisa

 git push origin --delete bugfix 

Diagrama 3

detalhes adicionais

As seções a seguir descrevem detalhes adicionais a serem considerados ao excluir suas ramificações de controle remoto e remoto.

Pressionar para excluir ramificações remotas também exclui ramificações de controle remoto

Note que a exclusão da ramificação remota X da linha de comando usando um git push também excluirá a ramificação origin/X rastreamento remoto local , portanto, não é necessário remover a ramificação de rastreamento remoto obsoleta com git fetch --prune ou git fetch -p , embora não faria mal se você fez isso de qualquer maneira.

Você pode verificar se a origin/X ramo de rastreamento remoto também foi excluída executando o seguinte:

 # View just remote-tracking branches git branch --remotes git branch -r # View both strictly local as well as remote-tracking branches git branch --all git branch -a 

Podando a origem do ramo de rastreio remoto local obsoleto / X

Se você não excluiu sua ramificação remota X da linha de comando (como acima), então seu repository local ainda conterá (um obsoleto) origin/X ramo de rastreamento remoto origin/X Isso pode acontecer se você excluiu um branch remoto diretamente através da interface web do GitHub, por exemplo.

Uma maneira típica de remover essas ramificações de rastreamento remoto obsoletas (desde a versão 1.6.6 do Git) é simplesmente executar git fetch com o --prune ou --prune -p . Observe que isso remove todas as ramificações de rastreamento remoto locais obsoletas de quaisquer ramificações remotas que não existem mais no remoto :

 git fetch origin --prune git fetch origin -p # Shorter 

Aqui está a citação relevante das notas de lançamento 1.6.6 (ênfase minha):

“git fetch” aprendeu as opções --all e --multiple , para executar a busca a partir de muitos repositorys, e --prune opção para remover as ramificações de rastreamento remoto que ficaram obsoletas. Estes fazem “git remote update” e “git remote prune” menos necessários (não há planos para remover “remote update” nem “remote prune”, no entanto).

Alternativa à remoção automática acima para ramificações de rastreamento remotas obsoletas

Como alternativa, em vez de remover suas ramificações de rastreamento remoto obsoletas por meio do git fetch -p , você pode evitar fazer a operação de rede extra apenas removendo manualmente o (s) ramo (s) com os sinalizadores --remote ou -r :

 git branch --delete --remotes origin/X git branch -dr origin/X # Shorter 

Veja também

  • git-branch (1) Manual Page .
  • git-fetch (1) Página do manual .
  • Pro Git § 3.5 Git Branching – Ramificações remotas .

Etapas para excluir um ramo:

para excluir o ramo remoto:

 git push origin --delete  

para excluir o ramo local , você tem três maneiras:

 1: git branch -D  2: git branch --delete --force  //same as -D 3: git branch --delete  //error on unmerge 

Explique: OK, apenas explique o que está acontecendo aqui!

Simplesmente git push origin --delete para deletar sua filial remota APENAS , adicione o nome da ramificação no final e isso irá deletar e empurrá-la para o controle remoto ao mesmo tempo …

Além disso, git branch -D , que simplesmente exclui a filial local SOMENTE ! …

-D significa --delete --force que irá deletar o branch mesmo que ele não esteja mesclado (force delete), mas você também pode usar -d que significa --delete que --delete um erro respectivo do status de mesclagem do branch …

Eu também criei a imagem abaixo para mostrar os passos:

excluir um ramo remoto e local no git

Você também pode usar o seguinte para excluir a ramificação remota.

 git push --delete origin serverfix 

Qual faz a mesma coisa que

 git push origin :serverfix 

mas pode ser mais fácil de lembrar.

Se você quiser excluir uma ramificação, primeiro check-out para a ramificação diferente da ramificação a ser excluída.

 git checkout other_than_branch_to_be_deleted 

Excluindo o ramo local:

 git branch -D branch_to_be_deleted 

Excluindo o ramo remoto:

 git push origin --delete branch_to_be_deleted 

Dica: quando você exclui ramificações usando

 git branch -d  # deletes local branch 

ou

 git push origin : # deletes remote branch 

apenas as referências são eliminadas. Mesmo que a ramificação seja realmente removida no remoto, as referências a ela ainda existem nos repositorys locais dos membros de sua equipe. Isso significa que, para outros membros da equipe, as ramificações excluídas ainda estarão visíveis quando fizerem uma git branch -a .

Para resolver isso, os membros da sua equipe podem remover os ramos excluídos

 git remote prune  

Isso é tipicamente git remote prune origin .

 git branch -D  git branch -D -r origin/ git push origin : 

Isso é simples: basta executar o seguinte comando:

Para excluir uma ramificação do Git local e remotamente, primeiro exclua a ramificação local usando o comando:

 git branch -d example 

(aqui example é o nome da filial)

E depois disso, apague a ramificação remota usando o comando:

 git push origin :example 

Outra abordagem é

 git push --prune origin 

AVISO: Isso excluirá todas as ramificações remotas que não existem localmente. Ou mais abrangente,

 git push --mirror 

Isso fará com que o repository remoto pareça com a cópia local do repository (cabeças locais, controles remotos e tags são espelhados no remoto).

Eu uso o seguinte nas minhas configurações de Bash :

 alias git-shoot="git push origin --delete" 

Então você pode ligar:

 git-shoot branchname 

Desde janeiro de 2013, o GitHub incluiu um botão Excluir ramificação ao lado de cada ramificação em sua página “Ramificações”.

Postagem relevante no blog: criar e excluir ramificações

Se você quiser completar estes dois passos com um único comando, você pode criar um alias para ele adicionando o seguinte ao seu ~/.gitconfig :

 [alias] rmbranch = "!f(){ git branch -d ${1} && git push origin --delete ${1}; };f" 

Alternativamente, você pode adicionar isto à sua configuração global a partir da linha de comando usando

 git config --global alias.rmbranch \ '!f(){ git branch -d ${1} && git push origin --delete ${1}; };f' 

NOTA : Se estiver usando -d (d minúsculo), a ramificação só será excluída se tiver sido mesclada. Para forçar a exclusão, você precisará usar -D (D maiúsculo).

Para excluir sua filial local e remotamente

  • Checkout para master branch – git checkout master

  • Exclua sua ramificação remota – git push origin --delete

  • Exclua sua ramificação local – git branch --delete

Excluir localmente:

Para excluir um ramo local, você pode usar:

 git branch -d branch_name 

Para excluir um ramo forçadamente, use -D vez de -d .

 git branch -D branch_name 

Excluir remotamente:

Existem duas opções:

 git push origin :branchname git push origin --delete branchname 

Eu sugiro que você use a segunda via, pois é mais intuitivo.

Você também pode fazer isso usando git remote prune origin :

 $ git remote prune origin Pruning origin URL: git@example.com/yourrepo.git * [pruned] origin/some-branchs 

Ele remove e exclui filiais de rastreamento remoto de uma listview git branch -r .

Além das outras respostas, geralmente uso a ferramenta git_remote_branch . É uma instalação extra, mas dá a você uma maneira conveniente de interagir com ramificações remotas. Nesse caso, para excluir:

 grb delete branch 

Acho que também uso os comandos publish e track bastante frequência.

Excluindo Filiais

Vamos supor que nosso trabalho no ramo “formulário de contato” esteja pronto e já o tenhamos integrado ao “mestre”. Como não precisamos mais dele, podemos deletá-lo (localmente):

 $ git branch -d contact-form 

E para excluir o ramo remoto:

 git push origin --delete contact-form 

Um comando liner exclui local e remoto :

D=branch-name; git branch -D $D; git push origin :$D

ou adicione o alias abaixo ao seu ~ / .gitconfig ; uso: git kill branch-name

 [alias] kill = "!f(){ git branch -D \"$1\"; git push origin --delete \"$1\"; };f" 

Excluir ramificação remota

git push origin :

Excluir ramificação local

git branch -D

Exclua as etapas da filial local:

  1. checkout para outro ramo
  2. excluir filial local

Simplesmente diga:

 git branch -d  git push origin : 

Agora você pode fazer isso com o aplicativo GitHub Desktop .

Depois de lançar o aplicativo

  1. Clique no projeto que contém o ramo
  2. Mude para o ramo que você gostaria de excluir ramo de comutação
  3. No menu “Filial”, selecione “Anular a publicação …” para que o ramo seja excluído dos servidores do GitHub. cancelar publicação
  4. No menu “Filial”, selecione “Excluir” branch_name “…”, para que a ramificação seja excluída da sua máquina local (também conhecida como a máquina em que você está trabalhando) excluir filial local

Para excluir Localmente – (Normal),

 git branch -d my_branch 

Se a sua filial em rebasing / merging progress e isso não foi feito corretamente significa que você receberá um erro Rebase/Merge in progress então nesse caso, você não poderá excluir sua ramificação.

Então, ou a sua necessidade de resolver rebasing / fusão, caso contrário, você pode forçar a exclusão usando,

 git branch -D my_branch 

Para excluir no Remoto:

 git push --delete origin my_branch 

pode fazer o mesmo usando,

 git push origin :my_branch # easy to remember both will do the same. 

Representação gráfica,

insira a descrição da imagem aqui

 git push origin --delete branchName 

é mais fácil de lembrar do que

 git push origin :branchName 

Isso não funcionará se você tiver uma tag com o mesmo nome da ramificação no controle remoto:

 $ git push origin :branch-or-tag-name error: dst refspec branch-or-tag-name matches more than one. error: failed to push some refs to 'git@github.com:SomeName/some-repo.git' 

Nesse caso, você precisa especificar que deseja excluir a ramificação, não a tag:

 git push origin :refs/heads/branch-or-tag-name 

Da mesma forma, para excluir a tag em vez da ramificação, você usaria:

 git push origin :refs/tags/branch-or-tag-name 

Muitas das outras respostas levarão a erros / avisos. Esta abordagem é relativamente à prova de some_other_branch , embora você ainda possa precisar do git branch -D branch_to_delete se não for totalmente integrado a some_other_branch , por exemplo.

 git checkout some_other_branch git push origin :branch_to_delete git branch -d branch_to_delete 

A remoção remota não é necessária se você excluiu a ramificação remota. Ele é usado apenas para obter os controles remotos mais atualizados disponíveis em um repository que você está rastreando. Eu observei git fetch irá adicionar controles remotos, não removê-los. Aqui está um exemplo de quando git remote prune origin realmente fará alguma coisa:

O usuário A faz as etapas acima. O usuário B executaria os seguintes comandos para ver as ramificações remotas mais atualizadas

 git fetch git remote prune origin git branch -r 

Fiquei farto de procurar essa resposta, então tomei uma abordagem semelhante à resposta que o crizCraig postou anteriormente.

Adicionado o seguinte ao meu perfil Bash:

 function gitdelete(){ git push origin --delete $1 git branch -D $1 } 

Então toda vez que eu termino com um branch (mesclado em master , por exemplo) eu corro o seguinte no meu terminal:

 gitdelete my-branch-name 

… que então exclui my-branch-name da origin como também localmente.

 git push origin :bugfix # Deletes remote branch git branch -d bugfix # Must delete local branch manually 

Se tiver certeza de que deseja excluí-lo, execute

 git branch -D bugfix 

Agora, para limpar as ramificações remotas excluídas, execute

 git remote prune origin 

Antes de executar

 git branch --delete  

Certifique-se de determinar primeiro qual é o nome EXATO da ramificação remota executando:

 git ls-remote 

Isso lhe dirá o que inserir EXATAMENTE para o valor de . ( branch é sensível a maiúsculas!)

Mashup de todas as outras respostas. Requer Ruby 1.9.3+, testado apenas no OS X.

Chame esse arquivo de git-remove , torne-o executável e coloque-o em seu caminho. Então use, por exemplo, git remove temp .

 #!/usr/bin/env ruby require 'io/console' if __FILE__ == $0 branch_name = ARGV[0] if (ARGV[0]) print "Press Y to force delete local and remote branch #{branch_name}..." response = STDIN.getch if ['Y', 'y', 'yes'].include?(response) puts "\nContinuing." `git branch -D #{branch_name}` `git branch -D -r origin/#{branch_name}` `git push origin --delete #{branch_name}` else puts "\nQuitting." end end