Voglio eliminare un ramo sia localmente che da remoto.

Tentativi non riusciti di eliminare una diramazione 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.

Cosa devo fare in modo diverso per eliminare correttamente il remotes/origin/bugfixramo sia localmente che da remoto?

Sintesi

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

Si noti che nella maggior parte dei casi il nome remoto è origin. In tal caso dovrai usare il comando in questo modo.

$ git push -d origin <branch_name>

Elimina filiale locale

Per eliminare il ramo locale utilizzare uno dei seguenti:

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

Nota: l' -dopzione è un alias per --delete, che elimina il ramo solo se è già stato unito completamente nel suo ramo a monte. È inoltre possibile utilizzare -D, che è un alias per --delete --force, che elimina il ramo "indipendentemente dal suo stato unito". [Fonte: man git-branch]

Elimina filiale remota [Aggiornato l'8 settembre 2017]

A partire da Git v1.7.0 , puoi eliminare un ramo remoto usando

$ git push <remote_name> --delete <branch_name>

che potrebbe essere più facile da ricordare di

$ git push <remote_name> :<branch_name>

che è stato aggiunto in Git v1.5.0 "per eliminare un ramo remoto o un tag".

A partire da Git v2.8.0 è inoltre possibile utilizzare git pushl' -dopzione come alias per --delete.

Pertanto, la versione di Git installata determinerà se è necessario utilizzare la sintassi più semplice o più difficile.

Elimina filiale remota [Risposta originale dal 5-gen-2010]

Dal capitolo 3 di Pro Git di Scott Chacon:

Eliminazione di filiali remote

Supponiamo che tu abbia finito con un ramo remoto - diciamo, tu e i tuoi collaboratori avete finito con una funzione e l'avete unito nel ramo principale del vostro telecomando (o in qualunque ramo si trovi nella vostra linea di codice stabile). È possibile eliminare un ramo remoto utilizzando la sintassi piuttosto ottusa git push [remotename] :[branch]. Se si desidera eliminare il ramo della correzione del server dal server, eseguire quanto segue:

$ git push origin :serverfix
To git@github.com:schacon/simplegit.git
 - [deleted]         serverfix

Boom. Niente più filiali sul tuo server. Potresti voler ascoltare questa pagina perché avrai bisogno di quel comando e probabilmente dimenticherai la sintassi. Un modo per ricordare questo comando è ricordare la git push [remotename] [localbranch]:[remotebranch]sintassi che abbiamo analizzato un po 'prima. Se lasci la [localbranch]porzione, in pratica stai dicendo: "Non prendere nulla dalla mia parte e falla [remotebranch]".

Ho pubblicato git push origin: bugfixe ha funzionato magnificamente. Scott Chacon aveva ragione: avrò voglia di orecchio di quella pagina (o praticamente orecchio di cane rispondendo a questo su Stack Overflow).

Quindi dovresti eseguirlo su altre macchine

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

per propagare i cambiamenti.

La risposta di Matthew è ottima per rimuovere rami remoti e apprezzo anche la spiegazione, ma per fare una semplice distinzione tra i due comandi:

Per rimuovere una filiale locale dal tuo computer:

git branch -d {the_local_branch}(utilizzare -Dinvece per forzare l'eliminazione del ramo senza controllare lo stato unito)

Per rimuovere un ramo remoto dal server:

git push origin --delete {the_remote_branch}

Riferimento: Git: elimina un ramo (locale o remoto)

Le brevi risposte

Se desideri spiegazioni più dettagliate dei seguenti comandi, consulta le risposte lunghe nella sezione successiva.

Eliminazione di un ramo remoto

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

Eliminazione di una filiale locale

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

Eliminazione di una filiale di localizzazione remota

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

La lunga risposta : ci sono tre diversi rami da eliminare!

Quando hai a che fare con l'eliminazione di filiali sia localmente che da remoto, tieni presente che sono coinvolti tre diversi rami :

1. La filiale locale X.
2. Il ramo di origine remoto X.
3. Il ramo di localizzazione remoto locale origin/Xche tiene traccia del ramo remoto X.

Il poster originale utilizzato:

git branch -rd origin/bugfix

Quali cancellato solo il suo locale filiali remote-tracking origin/bugfix , e non la filiale remota reale bugfixsu origin.

Per eliminare quel ramo remoto effettivo , è necessario

git push origin --delete bugfix

Dettagli aggiuntivi

Le seguenti sezioni descrivono ulteriori dettagli da considerare quando si eliminano i rami remoti e di monitoraggio remoto.

La pressione per eliminare i rami remoti rimuove anche i rami di tracciamento remoto

Si noti che l'eliminazione del ramo remoto Xdalla riga di comando mediante a git push rimuoverà anche il ramo di tracciamento remoto locale origin/X , quindi non è necessario potare il ramo di tracciamento remoto obsoleto con git fetch --pruneo git fetch -p. Tuttavia, non sarebbe male se lo facessi comunque.

Puoi verificare che anche il ramo di tracciamento remoto sia origin/Xstato eliminato eseguendo quanto segue:

# 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

Potatura dell'origine / X del ramo di localizzazione remota obsoleta locale

Se non hai eliminato il tuo ramo remoto Xdalla riga di comando (come sopra), il tuo repository locale conterrà comunque (un ramo di tracciamento remoto ormai obsoleto) origin/X. Questo può accadere se, ad esempio, hai eliminato un ramo remoto direttamente tramite l'interfaccia web di GitHub.

Un modo tipico per rimuovere questi rami obsoleti di tracciamento remoto (dalla versione 1.6.6 di Git) è semplicemente eseguire git fetchcon il --pruneo più breve -p. Tieni presente che ciò rimuove tutti i rami obsoleti di localizzazione remota per tutti i rami remoti che non esistono più sul telecomando :

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

Ecco la citazione pertinente dalle note di rilascio 1.6.6 (sottolineatura mia):

"git fetch" appreso --all e --multipleopzioni, per eseguire il recupero da molti repository e --pruneopzione per rimuovere i rami di tracciamento remoti che sono diventati obsoleti. Ciò rende meno necessari "git remote update" e "git remote prune" (non è tuttavia necessario rimuovere "remote update" né "remote prune").

Alternativa alla potatura automatica sopra per rami obsoleti di localizzazione remota

In alternativa, invece di eliminare le filiali obsolete di localizzazione remota locale git fetch -p, puoi evitare di eseguire le operazioni di rete extra semplicemente rimuovendo manualmente le filiali con i flag --remoteo -r:

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

Guarda anche

• Pagina di manuale di git-branch (1) .
• Pagina di manuale git-fetch (1) .
• Pro Git § 3.5 Git Branching - Branch remoti .

Passaggi per eliminare un ramo:

Per eliminare il ramo remoto:

git push origin --delete <your_branch>

Per eliminare la filiale locale , sono disponibili tre modi :

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

Spiega: OK, spiega solo cosa sta succedendo qui!

È sufficiente fare git push origin --deleteper eliminare la filiale remota solo , aggiungere il nome del ramo alla fine e questo sarà eliminare e spingerlo a distanza allo stesso tempo ...

Inoltre, git branch -Dche elimina semplicemente solo il ramo locale ! ...

-Dsta per il --delete --forcequale eliminerà il ramo anche se non è unito (forzare l'eliminazione), ma puoi anche usare -dquali supporti per --deletecui genera un errore relativo allo stato di unione del ramo ...

Creo anche l' immagine qui sotto per mostrare i passaggi:

È inoltre possibile utilizzare quanto segue per eliminare il ramo remoto

git push --delete origin serverfix

Che fa la stessa cosa di

git push origin :serverfix

ma potrebbe essere più facile da ricordare.

Suggerimento: quando si eliminano i rami usando

git branch -d <branchname> # Deletes local branch

o

git push origin :<branchname> # Deletes remote branch

vengono eliminati solo i riferimenti. Anche se il ramo viene effettivamente rimosso sul telecomando, i riferimenti ad esso esistono ancora nei repository locali dei membri del team. Ciò significa che per gli altri membri del team i rami eliminati sono ancora visibili quando lo fanno git branch -a.

Per risolvere questo, i membri del tuo team possono potare i rami eliminati con

git remote prune <repository>

Questo è in genere git remote prune origin.

Se si desidera eliminare un ramo, eseguire prima il checkout sul ramo diverso dal ramo da eliminare.

git checkout other_than_branch_to_be_deleted

Eliminazione della filiale locale:

git branch -D branch_to_be_deleted

Eliminazione del ramo remoto:

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>

Questo è semplice: basta eseguire il comando seguente:

Per cancellare un ramo Git sia localmente che da remoto, prima cancella il ramo locale usando questo comando:

git branch -d example

(Ecco exampleil nome del ramo.)

E dopo, elimina il ramo remoto usando questo comando:

git push origin :example

Un altro approccio è:

git push --prune origin

ATTENZIONE: questo eliminerà tutti i rami remoti che non esistono localmente. O in modo più completo,

git push --mirror

renderà efficacemente il repository remoto simile alla copia locale del repository (head, telecomandi e tag locali sono specchiati sul telecomando).

Uso quanto segue nelle mie impostazioni di Bash :

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

Quindi puoi chiamare:

git-shoot branchname

Elimina localmente:

Per eliminare una filiale locale, è possibile utilizzare:

git branch -d <branch_name>

Per eliminare un ramo con la forza, utilizzare -Dinvece di -d.

git branch -D <branch_name>

Elimina da remoto:

Esistono due opzioni:

git push origin :branchname

git push origin --delete branchname

Ti suggerirei di utilizzare il secondo modo in quanto è più intuitivo.

Da gennaio 2013, GitHub ha incluso a Delete branch pulsante accanto a ciascun ramo nella pagina "Filiali".

Post di blog pertinente: crea ed elimina filiali

Se vuoi completare entrambi questi passaggi con un singolo comando, puoi creare un alias aggiungendo quanto segue a ~/.gitconfig:

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

In alternativa, puoi aggiungerlo alla tua configurazione globale dalla riga di comando usando

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

NOTA : se si utilizza -d(d minuscola), il ramo verrà eliminato solo se è stato unito. Per forzare la cancellazione, dovrai usare -D(D maiuscola).

Per eliminare la filiale in locale e in remoto

• Acquista alla filiale principale - git checkout master

• Elimina la tua filiale remota - git push origin --delete <branch-name>

• Elimina la tua filiale locale - git branch --delete <branch-name>

Puoi anche farlo usando git remote prune origin

$ git remote prune origin
Pruning origin
URL: git@example.com/yourrepo.git
 * [pruned] origin/some-branchs

Elimina ed elimina i rami di localizzazione remota da un git branch -relenco.

Oltre alle altre risposte, utilizzo spesso lo strumento git_remote_branch . È un'installazione aggiuntiva, ma ti offre un modo conveniente per interagire con filiali remote. In questo caso, per eliminare:

grb delete branch

Trovo che uso anche i comandi publishe trackabbastanza spesso.

Un comando one-liner per eliminare sia locale che remoto :

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

Oppure aggiungi l'alias di seguito in ~ / .gitconfig . Uso:git kill branch-name

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

Eliminazione di rami

Supponiamo che il nostro lavoro sul ramo "modulo di contatto" sia terminato e l'abbiamo già integrato in "master". Dal momento che non ne abbiamo più bisogno, possiamo eliminarlo (localmente):

$ git branch -d contact-form

E per eliminare il ramo remoto:

git push origin --delete contact-form

Elimina ramo remoto

git push origin :<branchname>

Elimina la filiale locale

git branch -D <branchname>

Elimina i passaggi delle filiali locali:

1. checkout in un'altra filiale
2. elimina la filiale locale

Dì semplicemente:

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

git push origin --delete <branch Name>

è più facile da ricordare di

git push origin :branchName

Ora puoi farlo con l' applicazione desktop GitHub .

Dopo aver avviato l'applicazione

1. Fare clic sul progetto contenente il ramo

2. Passa al ramo che desideri eliminare

   

3. Dal menu "Ramo", seleziona "Annulla pubblicazione ..." per eliminare il ramo dai server GitHub.

   

4. Dal menu "Branch", seleziona "Elimina" branch_name "...", per eliminare il branch dal tuo computer locale (AKA il computer su cui stai attualmente lavorando)

   

È molto semplice:

Per eliminare il ramo remoto

git push -d origin <branch-name>

O

git push origin :<branch-name>

Per eliminare la filiale locale

git branch -D <branch-name>

Per eliminare localmente - (normale)

git branch -d my_branch

Se la tua filiale è in fase di rebasing / fusione e non è stata eseguita correttamente, significa che riceverai un errore, Rebase/Merge in progress , quindi in tal caso non sarai in grado di eliminare la tua filiale.

Quindi o è necessario risolvere il rebasing / fusione. Altrimenti, puoi forzare l' eliminazione usando,

git branch -D my_branch

Per eliminare in remoto :

git push --delete origin my_branch

Puoi fare lo stesso usando:

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

Rappresentazione grafica:

Questo non funzionerà se hai un tag con lo stesso nome del ramo sul telecomando:

$ 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'

In tal caso è necessario specificare che si desidera eliminare il ramo, non il tag:

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

Allo stesso modo, per eliminare il tag anziché il ramo dovresti usare:

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

Molte delle altre risposte porteranno a errori / avvisi. Questo approccio è relativamente a prova di errore anche se potresti ancora aver bisogno git branch -D branch_to_deletese non è completamente unito some_other_branch, per esempio.

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

La potatura remota non è necessaria se si è eliminato il ramo remoto. Viene utilizzato solo per ottenere i telecomandi più aggiornati disponibili su un repository che stai monitorando. Ho osservato git fetchaggiungerà telecomandi, non rimuoverli. Ecco un esempio di quando git remote prune origineffettivamente farà qualcosa:

L'utente A esegue i passaggi precedenti. L'utente B eseguirà i seguenti comandi per visualizzare i rami remoti più aggiornati:

git fetch
git remote prune origin
git branch -r

Mi sono stancato di cercare su Google questa risposta, quindi ho adottato un approccio simile alla risposta postata da CrizCraig precedenza.

Ho aggiunto quanto segue al mio profilo Bash:

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

Quindi ogni volta che ho finito con un ramo (unito master, per esempio), eseguo quanto segue nel mio terminale:

gitdelete my-branch-name

... che poi elimina my-branch-nameda origincome così come a livello locale.

Prima di eseguire

git branch --delete <branch>

assicurati di determinare prima qual è il nome esatto del ramo remoto eseguendo:

git ls-remote

Questo ti dirà cosa inserire esattamente per <branch>valore. ( branchè case sensitive!)

Uso:

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

Se sei sicuro di volerlo eliminare, esegui

git branch -D bugfix

Ora per ripulire i rami remoti eliminati eseguire

git remote prune origin