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




listar branches git (24)

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

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 <remote_name> <branch_name>
$ git branch -d <branch_name>

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 <remote_name> --delete <branch_name>

que pode ser mais fácil de lembrar do que

$ git push <remote_name> :<branch_name>

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 sintaxe 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 sintaxe rather git push [remotename] :[branch] . Se você deseja excluir sua ramificação de servidor do servidor, execute o seguinte:

$ git push origin :serverfix
To [email protected]: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 sintaxe. Uma maneira de lembrar este comando é chamar a sintaxe 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 ).

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

git fetch --all --prune

para propagar mudanças.


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"

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
  3. No menu "Filial", selecione "Anular a publicação ..." para que o ramo seja excluído dos servidores do GitHub.
  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)

Simplesmente diga:

git branch -d <branch-name>
git push origin :<branch-name>

Dica: quando você exclui ramificações usando

git branch -d <branchname>    # deletes local branch

ou

git push origin :<branchname> # 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 repositórios 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 <repository>

Isso é tipicamente git remote prune origin .


git push origin --delete branchName

é mais fácil de lembrar do que

git push origin :branchName

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.


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).


Etapas para excluir um ramo:

para excluir o ramo remoto:

git push origin --delete <your_branch> 

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

1: git branch -D <branch_name> 

2: git branch --delete --force <branch_name>  //same as -D

3: git branch --delete  <branch_name>         //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:


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

Chame esse arquivo 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

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 repositório 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

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

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

Excluir ramificação remota

git push origin :<branchname>

Excluir ramificação local

git branch -D <branchname>

Exclua as etapas da filial local:

  1. checkout para outro ramo
  2. excluir filial local

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.


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 <branch>  # Git version 1.7.0 or newer
git push origin :<branch>          # Git versions older than 1.7.0

Excluindo um ramo local:

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

Excluindo uma ramificação de rastreamento remoto local:

git branch --delete --remotes <remote>/<branch>
git branch -dr <remote>/<branch> # Shorter

git fetch <remote> --prune # Delete multiple obsolete tracking branches
git fetch <remote> -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

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 .

Para excluir esse ramo remoto real , você precisa

git push origin --delete bugfix

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 repositório 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 repositórios, 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 -D <name-of-branch>
git branch -D -r origin/<name-of-branch>
git push origin :<name-of-branch>

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

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 '[email protected]: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

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

$ git remote prune origin
Pruning origin
URL: [email protected]/yourrepo.git
 * [pruned] origin/some-branchs

Ele remove e exclui filiais de rastreamento remoto de uma listagem 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.


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.


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,







git-remote