Como excluo um ramo do Git local e remotamente?

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

Para remover umramificação localda sua máquina:

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

Para remover umramificação remotado 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 um ramo remoto:

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. O ramo local X.
2. O ramo de origem remoto X.
3. A ramificação de controle remoto local Origin/X que rastreia a ramificação remota X.

O pôster original usado

git branch -rd Origin/bugfix

que excluiu apenas seu ramificação de rastreamento remoto localOrigin/bugfix, e não o ramo remoto real bugfix em 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 rastreamento remoto

Observe que a exclusão da ramificação remota X da linha de comando usando git Pushtambém excluirá a ramificação de rastreamento remoto localOrigin/X, portanto, não é necessário remover a ramificação de rastreamento remoto obsoleta com git fetch --Prune ou git fetch -p, embora não seja possível não vai doer se você fez isso de qualquer maneira.

Você pode verificar se a ramificação de controle remoto Origin/X 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 ramificação de rastreamento remoto local obsoleta Origem/X

Se você não deletou sua ramificação remota X da linha de comando (como acima), então seu repositório local ainda conterá (uma obsoleta) ramificação de controle 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 menor -p. Observe que isso remove todas as ramificações de rastreamento remoto locais obsoletas de qualquer ramificação remota que não exista mais no controle 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" learned--all e --multipleoptions, para executar a busca de muitos repositórios, e --Pruneopção__ para remover as ramificações de rastreamento remoto que ficaram obsoletas.Estes fazem "git remote update" e "git remote Prune" less necessário (não há planos para remover "atualização remota" nem "Remoção remota").

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

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

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

Veja também

• git-branch (1) Página do manual .
• git-fetch (1) Página do manual .
• Pro Git § 3.5 Git Branching - Ramos Remotos .

Etapas para excluir um ramo:

Para excluir a ramificação remote:

git Push Origin --delete <your_branch> 

Para deletar a ramificação 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 faça git Push Origin --delete para delete APENAS sua ramificação remota , adicione o nome da ramificação no final e isso será deletado e empurrado para remoto ao mesmo tempo ...

Além disso, git branch -D, que simplesmente exclui a ramificação localONLY! ...

-D significa --delete --force que irá deletar a ramificação mesmo que ela não esteja mesclada (force delete), mas você também pode usar -d que significa --delete que gera um erro respectivo do status de mesclagem da ramificação ...

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

Você também pode usar o seguinte para excluir o ramo remoto

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ê deseja 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ê excluir as ramificações usando

git branch -d <branchname> # deletes local branch

ou

git Push Origin :<branchname> # deletes remote branch

apenas as referências são apagadas. 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 são visíveis quando fazem um git branch -a.

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

git remote Prune <repository>

Isso geralmente é git remote Prune Origin.

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 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 existam localmente. Ou mais abrangente,

git Push --mirror

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

Eu uso o seguinte em meu Bash settings:

alias git-shoot="git Push Origin --delete"

Então você pode ligar:

git-shoot branchname

Desde janeiro de 2013, o GitHub incluiu Delete branch botão ao lado de cada ramificação na página "Filiais".

Publicação relevante no blog: Criar e excluir ramificações

Se você quiser concluir essas duas etapas com um único comando, poderá 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'

NOTE: Se estiver usando -d (d minúsculo), o ramo só será deletado se tiver sido mesclado. Para forçar a exclusão a acontecer, você precisará usar -D (letra maiúscula D).

Excluir localmente:

Para excluir um ramo local, você pode usar:

git branch -d <branch_name> 

Para excluir um ramo forçadamente, use -D em 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 sua filial local e remotamente

• Check-out para a filial master - git checkout master

• Exclua sua ramificação remota - git Push Origin --delete <branch-name>

• Exclua sua ramificação local - git branch --delete <branch-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, costumo usar 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 com bastante frequência

Um forro comando delete 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"

Excluindo filiais

Vamos supor que nosso trabalho no ramo "formulário de contato" esteja pronto e já o tenhamos integrado ao "mestre". Já que 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

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

Simplesmente diga:

git branch -d <branch-name>
git Push Origin :<branch-name>

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

git Push Origin --delete <branch Name>

é mais fácil de lembrar do que

git Push Origin :branchName

Para excluir Localmente - (Normal),

git branch -d my_branch

Se a sua ramificação no processo de rebase/intercalação e isso não foi feito corretamente, você receberá um erro Rebase/Merge in progress. 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,

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

Muitas das outras respostas levarão a erros/avisos. Essa abordagem é relativamente infalível, embora você ainda precise de git branch -D branch_to_delete se não for totalmente integrada 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 que 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 filiais remotas mais atualizadas

git fetch
git remote Prune Origin
git branch -r

Eu fiquei doente de procurar por essa resposta, então eu tomei uma abordagem similar para a 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 de Origin como também localmente.

Antes de executar

git branch --delete <branch>

certifique-se de determinar primeiro o nome EXATO do ramo remoto executando:

git ls-remote

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

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

Chame esse arquivo git-remove, torne-o executável e coloque-o em seu caminho. Em seguida, 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

Eu adicionei os seguintes aliases ao meu arquivo .gitconfig. Isso me permite excluir ramos com ou sem especificar o nome da ramificação. O nome da filial é padronizado para o ramo atual se nenhum argumento for passado.

[alias]
    branch-name = rev-parse --abbrev-ref HEAD     

    rm-remote-branch = !"f() { branch=${1-$(git branch-name)}; git Push Origin :$branch; }; f"
    rm-local-branch = !"f() { branch=${1-$(git branch-name)}; git checkout master; git branch -d $branch; }; f"
    rm-branch-fully = !"f() { branch=${1-$(git branch-name)}; git rm-local-branch $branch; git rm-remote-branch $branch; }; f"

Uma opção alternativa para a linha de comando para excluir ramificações remotas é a página de ramificações GitHub .

Veja por exemplo: https://github.com/angular/angular.js/branches

Encontrada na página Code -> Branches de um repositório GitHub.

Eu geralmente prefiro a linha de comando, mas esta página GitHub mostra muito mais informações sobre os ramos, como data da última atualização e usuário e número de commits à frente e atrás . É útil quando se lida com um grande número de ramificações.

Eu também tive problemas semelhantes, e isso parece funcionar: Isso exclui ramificação local. git branch -d the_local_branch

Isso remove o ramo remoto git Push Origin :the_remote_branch

Fonte: Cartões Makandra

Há uma boa resposta, mas, no caso de você ter uma tonelada de ramificações, excluí-las uma a uma local e remotamente seria uma tarefa tediosa. Você pode usar esse script para automatizar essas tarefas.

branch_not_delete=( "master" "develop" "our-branch-1" "our-branch-2")


for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do

    # delete prefix remotes/Origin/ from branch name
    branch_name="$(awk '{gsub("remotes/Origin/", "");print}' <<< $branch)"

    if ! [[ " ${branch_not_delete[*]} " == *" $branch_name "* ]]; then
        # delete branch remotly and locally
        git Push Origin :$branch_name
    fi
done 

• Listar os ramos que você não deseja excluir
• Iterar sobre remotos ramo e se eles não estão em nossa "lista de preservação", nós apagamos.

Fonte: removendo-git-branches-at-once

Usando GitBash você pode executar o seguinte:

git branch --delete <branch>

OR

A partir do aplicativo de desktop do GitHub, quando você tem o ramo de check-out, você pode excluir o Local branch através da faixa de menu Branch:

Se você NÃO estiver usando o aplicativo da área de trabalho do GitHub e estiver usando um IDE como o Visual Studio para seu controle de origem local, tudo o que você precisa fazer é seguir alguns passos rápidos:

1. Confira um ramo diferente daquele que você deseja excluir.
2. Clique com o botão direito no ramo que você deseja excluir.
3. Selecione a opção Delete no menu de contexto.

Então, uma vez logado na sua conta do GitHub, vá ao repositório e clique na abaAll Branches. A partir daí, basta clicar no pequeno ícone da lixeira à direita do nome do brach que você deseja excluir.

* Lembre-se: se o ramo não for publicado, não é necessário tentar excluí-lo do seu repositório on-line.

Eu criei a seguinte função conveniente no meu arquivo .bash_aliases:

git-delete-branch() 
{ 
    if [[ -n $1 ]]; then
        git checkout master > /dev/null;
        branch_name="$1";
        echo "Deleting local $branch_name branch...";
        git branch -D "$branch_name";
        echo "Deleting remote $branch_name branch...";
        git Push Origin --delete "$branch_name";
        git remote Prune Origin;
        echo "Your current branches are:";
        git branch -a;
    else
        echo "Usage: git-delete-branch <branch_name>";
    fi
}

De acordo com o documento mais recente que usa o terminal nós podemos excluir o modo seguinte.

delete no local:

git branch -D usermanagement

excluir no local remoto:

git Push --delete Origin usermanagement

É muito simples

Para excluir ramificação remota

git Push -d Origin <branch-name>

OR

git Push Origin :<branch-name>

Para excluir ramificação local

git branch -D <branch-name>