git-branch fetch - Como eu excluo uma ramificação do Git local e remotamente?




para que (25)

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?


Answers

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 .


A resposta de Mateus é ó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 um ramo local da sua máquina:

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

Para remover uma ramificação remota do servidor:

git push origin --delete {the_remote_branch}

Referência: https://makandracards.com/makandra/621-git-delete-a-branch-local-or-remote


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 .


Para excluir sua filial local e remotamente

  • Checkout para master branch - git checkout master

  • Exclua sua ramificação remota - git push origin --delete <branch-name>

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


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

git push origin --delete branchName

é mais fácil de lembrar do que

git push origin :branchName

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)

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


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.


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.


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

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,


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

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

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


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

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:


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.


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

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


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

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

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


Simplesmente diga:

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

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.


editar Desatualizado, apenas use o git push -u origin $BRANCHNAME

Use git publish-branch de diversas ferramentas do Git de William ( repositório e clone gitorious ).

OK, não Ruby, então - ignorando as salvaguardas! - pegue as últimas três linhas do script e crie um script bash, git-publish-branch :

#!/bin/bash
REMOTE=$1 # Rewrite this to make it optional...
BRANCH=$2
# Uncomment the following line to create BRANCH locally first
#git checkout -b ${BRANCH}
git push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&
git config branch.${BRANCH}.remote ${REMOTE} &&
git config branch.${BRANCH}.merge refs/heads/${BRANCH}

Em seguida, execute git-publish-branch REMOTENAME BRANCHNAME , onde REMOTENAME geralmente é origin (você pode modificar o script para ter origem como padrão, etc ...)





git git-branch git-remote