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

Para remover um sucursal local da sua máquina:

git branch -d {the_local_branch} (usar -D em vez disso, para forçar a remoção do ramo sem verificar o estado reunido)

Para remover um ramo remoto 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 quiser explicações mais detalhadas dos seguintes comandos, veja as respostas longas na secção seguinte.

Apagar 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

Apagar um ramo local:

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

Apagar um ramo local de localização remota:

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: há 3 ramos diferentes para apagar!

1. o ramo local X.
2. o ramo de origem remota X.
3. o ramo local de localização remota origin/X que localiza o ramo remoto X.

O cartaz original usado

git branch -rd origin/bugfix

Para apagar esse remoto actual branch , precisas

git push origin --delete bugfix

Detalhes Adicionais

As secções seguintes descrevem detalhes adicionais a considerar ao apagar os seus ramos de localização remota e remota.

Lembre-se que a remoção do ramo remoto X da linha de comandos com um git push irá também apagar o ramo local de localização remota origin/X, por isso, não é necessário podar o ramo obsoleto de localização remota com git fetch --prune ou git fetch -p, embora não fizesse mal se o fizesses de qualquer maneira.

Pode verificar se o ramo de localização remota origin/X também foi apagado ao executar 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

Podar a obsoleta origem local do ramo de localização remota / X

Se não apagou o seu ramo remoto {[[8]} da linha de comandos( como em cima), então o seu repo local irá ainda conter (um agora obsoleto) ramo de localização remota origin/X. Isto pode acontecer se você removeu um ramo remoto diretamente através da interface web do GitHub, por exemplo.

Uma maneira típica de remover estes ramos obsoletos de rastreamento remoto (desde a versão 1.6.6 do Git) é simplesmente executar git fetch com o --prune ou mais curto -p. Note que isto remove todos os ramos de localização remota obsoletos para quaisquer ramos remotos que já não existam 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 mine):

"git fetch" aprendido --all e as opções --multiple, para correr buscar de muitos repositórios, e --prune opção para remover o seguimento remoto ramos que se tornaram obsoletos.{[47] } estes fazem "git remote update" e " git podar remoto " menos necessário (não existe nenhum plano para remover "remoto update " nor "remote prune", though).

Alternativa à poda acima automática para ramos obsoletos de localização remota

Em alternativa, em vez de podar os seus obsoletos ramos locais de localização remota através git fetch -p, você pode evitar fazer a operação de rede extra apenas removendo manualmente o(s) ramo (s) com as opções --remote ou -r:

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

Ver Também

• git-branch(1) Manual Page .
• git-fetch(1) Manual Page .
• Pro Git § 3.5 Git Ramificações - Ramificações Remotas.

Passos para apagar um ramo:

Para Apagar o ramo remoto :

git push origin --delete <your_branch> 

Para Apagar 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

Explica-me o que se passa aqui.

Basta fazer git push origin --delete para apagar apenas o seu ramo remoto {[[13]}, adicionar o nome do ramo no fim e isto irá apagar e empurrá-lo para o remoto ao mesmo tempo...

Também, git branch -D, que simplesmente apaga o local branch apenas!...

-D significa --delete --force que irão eliminar o ramo ainda não mesclada(força excluir), mas você também pode usar -d que significa --delete que lançar um erro respectivos do ramo de estado de impressão em série...

Também crio a imagem abaixo para mostrar os passos:

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

git push --delete origin serverfix

git push origin :serverfix

Se quiser apagar um ramo, faça a primeira saída para o ramo que não o ramo a ser apagado.

git checkout other_than_branch_to_be_deleted

Apagar a ramificação local:

git branch -D branch_to_be_deleted

Apagar o ramo remoto:

git push origin --delete branch_to_be_deleted

Dica: quando apagar ramos usando

git branch -d <branchname>    # deletes local branch

Ou

git push origin :<branchname> # deletes remote branch

Apenas as referências são suprimidas. Mesmo que o ramo seja realmente removido no Remoto, as referências a ele ainda existe nos repositórios locais de seus membros da equipe. Isto significa que para outros membros da equipe os ramos excluídos ainda são visíveis quando eles fazem um git branch -a.

git remote prune <repository>

Isto é tipicamente git remote prune origin.

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

Isto é simples: basta executar o seguinte comando:

Para remover um ramo git tanto localmente como remotamente, primeiro remova o ramo local com o comando:

git branch -d example

(aqui example é o nome do ramo)

E depois disso apagar ramo remoto usando o comando:

git push origin :example

Outra abordagem é

git push --prune origin

aviso: Isto irá apagar todos os ramos remotos que não existem localmente. ou de forma mais abrangente,

git push --mirror

Irá efectivamente fazer com que o repositório remoto se pareça com a cópia local do repositório (as cabeças, comandos e marcas locais são espelhados no remoto).

USO o seguinte na minha configuração Bash :

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

git-shoot branchname

Desde janeiro de 2013, o GitHub incluiu um botão apagar ramo ao lado de cada ramo na sua página de "Ramos".

Post relevante no blog: criar e apagar ramificações

Se quiser completar ambos os passos com um único comando, pode fazer um nome falso para ele, adicionando o abaixo ao seu ~/.gitconfig:

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

Em alternativa, poderá adicionar isto à sua configuração global a partir da linha de comandos usando

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

Nota : Se utilizar -d (minúsculas d), o ramo só será apagado se tiver sido fundido. Para forçar a remoção a acontecer, terá de usar -D (maiúsculas D).

Para apagar a sua ramificação local e remotamente

• Obter para ramo mestre- git checkout master

• Apagar o seu ramo remoto- git push origin --delete <branch-name>

• Apagar a sua ramificação local- git branch --delete <branch-name>

Apagar localmente:

Para apagar um ramo local, pode usar:

git branch -d branch_name 

Para apagar um ramo à força, use -D em vez de -d.

git branch -D branch_name

Apagar remotamente:

Há duas opções:

git push origin :branchname  

git push origin --delete branchname 

Também pode fazer isto usando git remote prune origin:

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

Extrai e apaga ramos de localização remota de uma lista git branch -r.

Para além das outras respostas, uso frequentemente a ferramenta git_remote_branch. É uma instalação extra, mas dá-lhe uma maneira conveniente de interagir com os ramos remotos. Neste caso, apagar:

grb delete branch

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

Apagar Ramos

Vamos assumir que o nosso trabalho em "contact-form" do ramo está feito e já o integrámos em "master". Uma vez que já não precisamos dele, podemos apagá-lo (localmente):

$ git branch -d contact-form

E por apagar o ramo remoto:

git push origin --delete contact-form

Um liner comando apagar tanto local como Remoto:

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

Ou adicionar a alcunha abaixo ao seu ~/.gitconfig; Utilização: git kill branch-name

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

Apagar ramo remoto

git push origin :<branchname>

Apagar a ramificação local

git branch -D <branchname>

Apagar os passos da ramificação local:

1. check-out para outro ramo
2. apagar a ramificação local

Basta dizer:

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

Agora pode fazê-lo com a aplicação GitHub Desktop.

Após o lançamento da aplicação

1. carregue no projecto que contém a ramificação
2. mude para o ramo que deseja apagar
3. do menu" Branch", seleccione, " Unpublish...", para ter o branch excluído dos servidores GitHub.
4. do menu" Branch", seleccione, 'Delete" branch_name "...', para ter o ramo apagado do seu local máquina (também conhecida como a máquina em que está actualmente a trabalhar)

Para apagar localmente- (Normal),

git branch -d my_branch

Se o seu ramo em rebocar / fundir o progresso e isso não foi feito correctamente significa, você vai ter um erro {[[4]} Então, nesse caso, você não será capaz de apagar o seu ramo.

Por isso, ou a sua necessidade de resolver o ajuste/fusão, caso contrário, poderá forçar a remoção usando,

git branch -D my_branch

Para Apagar 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.

Gráfico Representação,

git push origin --delete branchName

É mais fácil de lembrar do que

git push origin :branchName

Isto não vai funcionar se você tiver uma etiqueta com o mesmo nome que o ramo no 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, precisa de especificar que deseja apagar o ramo, não a marca:

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

Da mesma forma, para apagar a marca em vez do ramo que usaria:

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

Adicionei o seguinte ao meu perfil Bash:

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

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

gitdelete my-branch-name

...que então apaga my-branch-name de origin assim como localmente.

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

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

A poda remota não é necessária se apagares o ramo remoto. Só é usado para obter os comandos mais atualizados disponíveis num repo que você está rastreando. Observei que git fetch irá adicionar comandos, não removê-los. Aqui está um exemplo de quando git remote prune origin vai realmente fazer algo:

O Utilizador a faz os degraus acima. O utilizador B iria executar os seguintes comandos para ver os ramos remotos mais actualizados

git fetch
git remote prune origin
git branch -r

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

Se TEM a certeza que o quer apagar, execute

git branch -D bugfix

Agora para limpar os ramos remotos apagados executar

git remote prune origin

Antes de executar

git branch --delete <branch>

Certifique-se que determina primeiro Qual é o nome exacto do ramo remoto executando:

git ls-remote

Isto dir-lhe-á o que introduzir exactamente pelo valor <branch>. É sensível a maiúsculas!)

Mashup de todas as outras respostas. Necessita de Ruby 1.9.3+, testada apenas em OS X.

Ligue para este ficheiro git-remove, torne-o executável e coloque-o no 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