Como é que apago uma ramificação Git tanto localmente como remotamente?
quero apagar um ramo tanto localmente como no meu fork remoto do projecto no GitHub .
tentativas falhadas de apagar 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 preciso fazer de diferente para apagar com sucesso o
remotes/origin/bugfix
tanto localmente como no GitHub?
30 answers
Resumo Executivo
$ git push --delete <remote_name> <branch_name>
$ git branch -d <branch_name>
Note que na maioria dos casos o nome remoto é origin
.
Apagar A Ramificação Local
Para apagar o ramolocal use um dos seguintes:
$ git branch -d branch_name
$ git branch -D branch_name
Nota: a opção -d
é um nome alternativo para --delete
, que só apaga o ramo se já tiver sido totalmente fundido no seu ramo a montante. Você também poderia usar -D
, que é um pseudônimo para --delete --force
, que apaga o ramo " independentemente de seu status fundido." [Fonte: man git-branch
]
Apagar ramo remoto [actualizado em 8-Sep-2017]
A partir de Git v1.7.0, pode apagar um remoto ramo que utiliza
$ 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 em Git v1.5.0 "para apagar um ramo remoto ou uma marca."
A partir de Git v2. 8. 0 também pode usar git push
com a opção -d
como nome alternativo para --delete
.
Portanto, a versão do Git você instalou irá ditar se você precisa usar a sintaxe mais fácil ou mais difícil.
Apagar ramo remoto [resposta Original de 5-Jan-2010]
Do Capítulo 3 do Pro Git por Scott Chacon:
Apagar Ramos Remotos
Suponha que você acabou com um ramo remoto-digamos, você e seus colaboradores estão acabados com um recurso e o fundiram no ramo mestre do seu remoto (ou seja qual for o ramo que seu codeline estável é em). Poderá remover um ramo remoto usando a sintaxe obtusegit push [remotename] :[branch]
. Se quiser apagar a sua ramificação serverfix do servidor, execute o seguinte:Boom. Não há mais ramificações no seu servidor. Você pode querer ouvir esta página, porque você vai precisar desse comando, e você provavelmente vai esquecer a sintaxe. Uma maneira de lembrar este comando é lembrando a sintaxe$ git push origin :serverfix To [email protected]:schacon/simplegit.git - [deleted] serverfix
git push [remotename] [localbranch]:[remotebranch]
que passamos um pouco mais cedo. Se você deixar de fora a parte[localbranch]
, Então você está basicamente dizendo, " Tome nada do meu lado e faz com que seja."
Eu emiti git push origin :bugfix
e funcionou lindamente. Scott Chacon estava certo - eu vou querer ouvir essa página (ou virtualmente a orelha do cão respondendo a isso no Stack Overflow).
Então você deve executar isso em outras máquinas
git fetch --all --prune
Para propagar alterações.
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!
Quando se trata de apagar ramos tanto localmente como remotamente, tenha em mente que existem 3 diferentes ramos envolvidos:- o ramo local
X
. - o ramo de origem remota
X
. - o ramo local de localização remota
origin/X
que localiza o ramo remotoX
.
O cartaz original usado
git branch -rd origin/bugfix
Que só apagou a sua ramificação local de localização remota. origin/bugfix
, e não o ramo remoto em 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.
Se empurrar para remover os ramos remotos também apaga os ramos remotosLembre-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
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
O que faz a mesma coisa que
git push origin :serverfix
Mas pode ser mais fácil de lembrar.
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"
Depois podes ligar para:
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
Sugiro que use o segundo caminho, porque é mais intuitivo.
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.
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:
- check-out para outro ramo
- 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
- carregue no projecto que contém a ramificação
- mude para o ramo que deseja apagar
- do menu" Branch", seleccione, " Unpublish...", para ter o branch excluído dos servidores GitHub.
- 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