Quero excluir uma ramificação local e remotamente.

Tentativas com falha para excluir uma 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 devo fazer de maneira diferente para excluir com êxito a remotes/origin/bugfixramificação local e remotamente?

Sumário executivo

$ git push -d <remote_name> <branch_name>
$ git branch -d <branch_name>

Observe que na maioria dos casos o nome remoto é origin. Nesse caso, você terá que usar o comando assim.

$ git push -d origin <branch_name>

Excluir filial local

Para excluir a filial local , use um dos seguintes:

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

Nota: A -dopção é um alias para --delete, que somente exclui a ramificação se ela 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 / set / 2017]

No 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 excluir uma ramificação remota ou uma marca".

A partir do Git v2.8.0, você também pode usar git pusha -dopção 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 do Pro Git, de Scott Chacon:

Excluindo ramificações remotas

Suponha que você tenha concluído um ramo remoto - digamos, você e seus colaboradores tenham concluído um recurso e o tenham mesclado no ramo mestre do controle remoto (ou em qualquer ramo em que esteja a linha de código estável). Você pode excluir uma ramificação remota usando a sintaxe bastante obtusa git push [remotename] :[branch]. Se você deseja excluir sua ramificação de correção 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 ouvir esta página, porque precisará desse comando e provavelmente esquecerá a sintaxe. Uma maneira de lembrar esse comando é lembrando a git push [remotename] [localbranch]:[remotebranch]sintaxe que analisamos um pouco antes. Se você deixar de lado a [localbranch]porção, estará basicamente dizendo: "Não tome nada do meu lado e faça acontecer [remotebranch]".

Eu emiti git push origin: bugfixe funcionou lindamente. Scott Chacon estava certo - vou querer colocar a orelha do cão nessa página (ou praticamente a orelha do cachorro, respondendo isso no Stack Overflow).

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

# Fetch changes from all remotes and locally delete 
# remote deleted branches/tags etc
# --prune will do the job :-;
git fetch --all --prune

propagar alterações.

A resposta de Matthew é ó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 uma filial local da sua máquina:

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

Para remover uma filial remota do servidor:

git push origin --delete {the_remote_branch}

Referência: Git: Excluir uma ramificação (local ou remota)

As respostas curtas

Se você quiser explicações mais detalhadas dos comandos a seguir, consulte 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 -d <branch>        # Shorter version (Git 1.7.0 or newer)
git push origin :<branch>          # Git versions older than 1.7.0

Excluindo uma ramificação local

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

Excluindo uma filial de rastreamento remoto local

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

git fetch <remote> --prune # Delete multiple obsolete remote-tracking branches
git fetch <remote> -p      # Shorter

A resposta longa : existem três ramos diferentes para excluir!

Ao lidar com a exclusão de ramificações local e remotamente, lembre-se de que existem três ramificações diferentes envolvidas :

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

O pôster original usado:

git branch -rd origin/bugfix

Que só apagados seu local de ramo de rastreamento remoto origin/bugfix , e não o ramo remoto real bugfixon origin.

Para excluir essa ramificação remota 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 remotas e de rastreamento remoto.

Pressionar para excluir ramificações remotas também remove ramificações de rastreamento remoto

Observe que excluir a ramificação remota Xda linha de comando usando a git push também removerá a ramificação local de rastreamento remoto origin/X , portanto, não é necessário remover a ramificação obsoleta do rastreamento remoto com git fetch --pruneou git fetch -p. No entanto, não faria mal se você fizesse isso de qualquer maneira.

Você pode verificar se a ramificação de rastreamento remoto origin/Xtambé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

Eliminando a origem obsoleta da filial de rastreamento remoto local / X

Se você não excluiu sua ramificação remota Xda linha de comando (como acima), seu repositório local ainda conterá uma ramificação de rastreamento remoto (agora obsoleta) origin/X. Isso pode acontecer se você excluir uma ramificação remota diretamente pela interface da web do GitHub, por exemplo.

Uma maneira típica de remover essas ramificações obsoletas de rastreamento remoto (desde o Git versão 1.6.6) é simplesmente executar git fetchcom o --pruneou mais curto -p. Observe que isso remove todas as ramificações locais obsoletas de rastreamento remoto de ramificações remotas que não existem mais no controle remoto :

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

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

"git fetch" aprendido --all e --multipleopções, para executar a busca em muitos repositórios e --pruneopção para remover ramificações de rastreamento remoto que ficaram obsoletas. Isso torna a "atualização remota git" e a "remoção remota git" menos necessárias (embora não exista nenhum plano para remover a atualização remota nem a remoção remota).

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

Como alternativa, em vez de remover suas ramificações obsoletas de rastreamento remoto local git fetch -p, você pode evitar a operação de rede extra apenas removendo manualmente as ramificações com os sinalizadores --remoteou -r:

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

Veja também

• Manual do git-branch (1) .
• Manual do git-fetch (1) .
• Pro Git § 3.5 Ramificação Git - Ramificações remotas .

Etapas para excluir uma ramificação:

Para excluir a ramificação remota:

git push origin --delete <your_branch>

Para excluir a filial 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!

Basta fazer git push origin --deletepara eliminar a sua filial remota única , adicione o nome do ramo no final e isso vai apagar e empurrá-lo para remoto , ao mesmo tempo ...

Além disso, git branch -Dque simplesmente apagar a filial local única ! ...

-Dsignifica --delete --forceque excluirá o ramo, mesmo que ele não seja mesclado (exclusão forçada), mas você também pode usar o -dque significa --deleteque gera um erro respectivo do status de mesclagem do ramo ...

Também crio a imagem abaixo para mostrar as etapas:

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

git push --delete origin serverfix

O que faz a mesma coisa que

git push origin :serverfix

mas pode ser mais fácil lembrar.

Dica: Ao excluir ramificações usando

git branch -d <branchname> # Deletes local branch

ou

git push origin :<branchname> # Deletes remote branch

somente as referências são excluídas. Mesmo que a ramificação seja realmente removida no controle remoto, as referências a ela ainda existem nos repositórios locais dos membros da sua equipe. Isso significa que, para outros membros da equipe, as ramificações excluídas ainda são visíveis quando fazem umagit branch -a .

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

git remote prune <repository>

Isto é tipicamente git remote prune origin.

Se você deseja excluir uma ramificação, primeiro faça o check-out da ramificação que não seja a ramificação a ser excluída.

git checkout other_than_branch_to_be_deleted

Excluindo a filial local:

git branch -D branch_to_be_deleted

Excluindo a ramificação remota:

git push origin --delete branch_to_be_deleted

git branch -D <name-of-branch>
git branch -D -r origin/<name-of-branch>
git push origin :<name-of-branch>

Isso é simples: basta executar o seguinte comando:

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

git branch -d example

(Aqui exampleestá o nome do ramo.)

E depois disso, exclua a ramificação remota usando este 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

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

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

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

Então você pode ligar para:

git-shoot branchname

Excluir localmente:

Para excluir uma filial local, você pode usar:

git branch -d <branch_name>

Para excluir uma ramificação à força, use em -Dvez 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 maneira, pois é mais intuitiva.

Desde janeiro de 2013, o GitHub incluiu um Delete branch botão ao lado de cada ramificação na sua página "Ramificações".

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

Se você deseja concluir essas duas etapas com um único comando, é possível criar um alias adicionando o seguinte ao seu ~/.gitconfig:

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

Como alternativa, você pode adicionar isso à sua configuração global na 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 será excluída apenas se tiver sido mesclada. Para forçar a exclusão, você precisará usar -D(D maiúsculo).

Para excluir sua filial local e remotamente

• Caixa para master branch - git checkout master

• Exclua sua filial remota - git push origin --delete <branch-name>

• Exclua sua filial local - git branch --delete <branch-name>

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 ramificações de rastreamento remoto de uma git branch -rlistagem.

Além das outras respostas, costumo usar a ferramenta git_remote_branch . É uma instalação extra, mas oferece uma maneira conveniente de interagir com ramificações remotas. Nesse caso, para excluir:

grb delete branch

Acho que também uso os comandos publishe com trackbastante frequência.

Um comando de uma linha para excluir 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"

Exclusão de ramificações

Vamos supor que nosso trabalho no ramo "formulário de contato" esteja concluído e já o integramos no "mestre". Como não precisamos mais dele, podemos excluí-lo (localmente):

$ git branch -d contact-form

E para excluir a filial remota:

git push origin --delete contact-form

Excluir filial remota

git push origin :<branchname>

Excluir filial local

git branch -D <branchname>

Exclua as etapas da filial local:

1. checkout para outro ramo
2. excluir filial local

Basta dizer:

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

git push origin --delete <branch Name>

é mais fácil lembrar do que

git push origin :branchName

Agora você pode fazer isso com a área de trabalho do GitHub aplicativo .

Depois de iniciar o aplicativo

1. Clique no projeto que contém a filial

2. Alterne para o ramo que você deseja excluir

   

3. No menu "Filial", selecione "Cancelar publicação ..." para excluir a filial dos servidores GitHub.

   

4. No menu "Filial", selecione "Excluir" branch_name "..." para excluir a ramificação da sua máquina local (também conhecida como a máquina em que você está trabalhando).

   

É muito simples:

Para excluir a ramificação remota

git push -d origin <branch-name>

Ou

git push origin :<branch-name>

Para excluir ramificação local

git branch -D <branch-name>

Para excluir localmente - (normal)

git branch -d my_branch

Se sua ramificação estiver em progresso de reestruturação / mesclagem e isso não foi feito corretamente, significa que você receberá um erro, Rebase/Merge in progress ; portanto, nesse caso, não será possível excluir sua ramificação.

Então, você precisa resolver a reestruturação / mesclagem. Caso contrário, você pode forçar a exclusão usando,

git branch -D my_branch

Para excluir no controle remoto :

git push --delete origin my_branch

Você pode fazer o mesmo usando:

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

Representação gráfica:

Isso não funcionará se você tiver uma tag com o mesmo nome da filial 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. Essa abordagem é relativamente à prova de idiotas, embora você ainda possa precisar git branch -D branch_to_deletese não estiver totalmente integrada 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 fetchadicionará controles remotos, não os removerá. Aqui está um exemplo de quando git remote prune originrealmente fará algo:

O usuário A executa 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 cansado de pesquisar essa resposta no Google, então adotei uma abordagem semelhante à resposta que o crizCraig postou anteriormente.

Adicionei o seguinte ao meu perfil do Bash:

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

Então, toda vez que termino uma ramificação (mesclada master, por exemplo), corro o seguinte no meu terminal:

gitdelete my-branch-name

... que em seguida, exclui my-branch-namede origincomo, bem como localmente.

Antes de executar

git branch --delete <branch>

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

git ls-remote

Isso informará o que digitar exatamente para o <branch>valor. ( branchdiferencia maiúsculas de minúsculas!)

Usar:

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 ramificações remotas excluídas, execute

git remote prune origin