Come faccio a eliminare un ramo Git localmente e da remoto?

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

Per rimuovere aramo localedalla tua macchina:

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

Per rimuovere aramo remotodal server:

git Push Origin --delete {the_remote_branch}

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

Le risposte brevi

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

Eliminazione di un 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

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 un ramo di localizzazione remota locale:

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

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

Quando hai a che fare con l'eliminazione dei rami sia a livello locale che remoto, tieni presente che ci sono 3 diversi rami coinvolti :

1. Il ramo locale X.
2. Il ramo di origine remoto X.
3. Il ramo locale di localizzazione remota Origin/X che tiene traccia del ramo remoto X.

Il poster originale usato

git branch -rd Origin/bugfix

che ha eliminato solo il suo ramo di localizzazione remota locale Origin/bugfix, e non il ramo remoto effettivo bugfix su 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 localizzazione remota.

Se si preme per eliminare i rami remoti, vengono eliminati anche i rami di tracciamento remoto

Si noti che l'eliminazione del ramo remoto X dalla riga di comando utilizzando un git Push eliminerà anche il ramo di localizzazione remota locale Origin/X, quindi non è necessario Potare il ramo di remote-tracking obsoleto con git fetch --Prune o git fetch -p, sebbene non sarebbe male se lo facessi comunque.

È possibile verificare che il ramo di tracciamento remoto Origin/X sia stato 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

Eliminazione del ramo di tracciamento remoto locale obsoleto Origine/X

Se non hai eliminato il ramo remoto X dalla riga di comando (come sopra), allora il repository locale conterrà ancora un ramo Origin/X (ora obsoleto). Questo può accadere se si elimina un ramo remoto direttamente attraverso l'interfaccia web di GitHub, ad esempio.

Un modo tipico per rimuovere questi rami obsoleti di tracciamento remoto (a partire dalla versione 1.6.6 di Git) è semplicemente eseguire git fetch con --Prune o inferiore -p. Nota che questo rimuove tutti i rami obsoleti locali di tracciamento remoto per eventuali rami remoti che non esistono più sul telecomando :

git fetch Origin --Prune
git fetch Origin -p # Shorter

Ecco la citazione pertinente dal 1.6.6 note di rilascio (sottolinea il mio):

"git fetch" appreso --all e --multipleoptions, per eseguire il recupero da molti repository e--Prune opzione per rimuovere i rami di monitoraggio remoto che sono andati in stallo. Questi renderanno "git remote update" e "git remote Prune" meno necessari (non vi è alcun piano per rimuovere "remote update", né "remote Prune", comunque).

Alternativa alla potatura automatica di cui sopra per i rami obsoleti di localizzazione remota

In alternativa, invece di eliminare i rami obsoleti locali di localizzazione remota tramite git fetch -p, puoi evitare di eseguire l'operazione extra di rete rimuovendo manualmente i branch con i flag --remote o -r:

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

Guarda anche

• git-branch (1) Pagina manuale .
• git-fetch (1) Pagina manuale .
• Pro Git § 3.5 Git Branching - Remote Branches .

Passi per l'eliminazione di un ramo:

Per eliminare il ramo remoto:

git Push Origin --delete <your_branch> 

Per eliminare il branch locale , hai three ways :

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!

Semplicemente fai git Push Origin --delete su elimina SOLO il tuo ramo remoto , aggiungi il nome del ramo alla fine e questo verrà eliminato e Spingilo su remoto allo stesso tempo ...

Inoltre, git branch -D, che semplicemente elimina il ramo localeSOLO! ...

-D sta per --delete --force che cancellerà il ramo anche se non è unito (force delete), ma puoi anche usare -d che sta per --delete che genera un errore rispettivo dello stato di fusione dei branch ...

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.

Se si desidera eliminare un ramo, prima effettuare il checkout al ramo diverso dal ramo da eliminare.

git checkout other_than_branch_to_be_deleted

Eliminazione del ramo locale:

git branch -D branch_to_be_deleted

Eliminazione del ramo remoto:

git Push Origin --delete branch_to_be_deleted

Suggerimento: quando si eliminano i rami utilizzando

git branch -d <branchname> # deletes local branch

o

git Push Origin :<branchname> # deletes remote branch

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

Per risolvere questo problema, i membri del tuo team possono Potare i rami cancellati con

git remote Prune <repository>

Questo è 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>

Questo è semplice: basta eseguire il seguente comando:

Per eliminare un ramo Git sia localmente che remotamente, prima cancella il ramo locale usando il comando:

git branch -d example

(qui example è il nome del ramo)

E dopo quello cancella il ramo remoto usando il comando:

git Push Origin :example

Un altro approccio è: -

git Push --Prune Origin

ATTENZIONE: Questo cancellerà tutti i rami remoti che non esistono localmente. O più esaurientemente,

git Push --mirror

renderà efficacemente il repository remoto simile alla copia locale del repository (le testine locali, i telecomandi e i tag sono speculari sul telecomando).

Io uso quanto segue nelle impostazioni Bash :

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

Quindi puoi chiamare:

git-shoot branchname

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

Post di blog pertinenti: Crea ed elimina rami

Se vuoi completare entrambi i passaggi con un singolo comando, puoi creare un alias per questo aggiungendo il seguente ~/.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'

NOTE: Se si utilizza -d (lettera d in minuscolo), il ramo verrà eliminato solo se è stato unito. Per forzare l'eliminazione, è necessario utilizzare -D (maiuscolo D).

Elimina localmente:

Per eliminare un ramo locale, puoi usare:

git branch -d <branch_name> 

Per eliminare un ramo forzatamente, usa -D anziché -d.

git branch -D <branch_name>

Elimina in remoto:

Ci sono due opzioni:

git Push Origin :branchname  

git Push Origin --delete branchname 

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

Per eliminare il tuo ramo localmente e in remoto

• Checkout al ramo 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 farlo anche usando git remote Prune Origin

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

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

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

grb delete branch

Trovo che io usi anche i comandi publish e track abbastanza spesso

Un liner comando delete sia locale che remoto :

D=branch-name; git branch -D $D; git Push Origin :$D

oppure aggiungi l'alias qui sotto al tuo ~/.gitconfig ; utilizzo: 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 "contact-form" sia fatto e lo abbiamo già integrato in "master". Dal momento che non ne abbiamo più bisogno, possiamo cancellarlo (localmente):

$ git branch -d contact-form

E per eliminare il ramo remoto:

git Push Origin --delete contact-form

Elimina il ramo remoto

git Push Origin :<branchname>

Elimina il ramo locale

git branch -D <branchname>

Elimina passaggi filiale locale:

1. checkout ad un altro ramo
2. elimina il ramo locale

Dì semplicemente:

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

Ora puoi farlo con GitHub Desktop app.

Dopo aver lanciato l'app

1. Clicca sul progetto che contiene il ramo
2. Passa al ramo che desideri eliminare  
3. Dal menu "Succursale", seleziona "Annulla pubblicazione ..." per fare in modo che il ramo venga eliminato dai server GitHub.  
4. Dal menu "Succursale", seleziona, "Elimina" branch_name "...", per fare in modo che il ramo venga cancellato dalla tua macchina locale (ovvero la macchina su cui stai lavorando)  

git Push Origin --delete <branch Name>

è più facile da ricordare che

git Push Origin :branchName

Per eliminare localmente - (Normale),

git branch -d my_branch

Se il tuo ramo nel progresso di rifondazione/fusione e ciò non è stato fatto correttamente significa che riceverai un errore Rebase/Merge in progress in tal caso, non sarai in grado di eliminare il tuo ramo.

Quindi o la tua necessità di risolvere il ribasso/fusione altrimenti puoi forzare Elimina usando,

git branch -D my_branch

Per eliminare in remoto:

git Push --delete Origin my_branch

può fare lo stesso usando,

git Push Origin :my_branch   # easy to remember both will do the same.

Rappresentazione grafica,

Questo non funzionerà se si ha 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 '[email protected]: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 al posto del ramo si utilizzerà:

git Push Origin :refs/tags/branch-or-tag-name

Molte delle altre risposte porteranno a errori/avvertimenti. Questo approccio è relativamente infallibile, anche se potrebbe essere ancora necessario git branch -D branch_to_delete se non è completamente integrato in some_other_branch, ad esempio.

git checkout some_other_branch
git Push Origin :branch_to_delete
git branch -d branch_to_delete

L'eliminazione remota non è necessaria se si elimina il ramo remoto. Viene utilizzato solo per ottenere i telecomandi più aggiornati disponibili su un repository che stai monitorando. Ho osservato che git fetch aggiungerà i telecomandi, non li rimuoverò. Ecco un esempio di quando git remote Prune Origin farà effettivamente qualcosa:

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

git fetch
git remote Prune Origin
git branch -r

Mi sono stancato di googling per questa risposta, quindi ho adottato un approccio simile a la risposta che crizCraig ha pubblicato in precedenza.

Aggiunto il seguente al mio profilo Bash:

function gitdelete(){
    git Push Origin --delete $1
    git branch -D $1
}

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

gitdelete my-branch-name

... che poi cancella my-branch-name da Origin come pure localmente.

Prima dell'esecuzione

git branch --delete <branch>

assicurati di determinare prima quale sia il nome ESATTO del ramo remoto eseguendo:

git ls-remote

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

git Push Origin :bugfix  # Deletes remote branch
git branch -d bugfix     # Must delete local branch manually

Se sei sicuro di volerlo cancellare, corri

git branch -D bugfix

Ora per ripulire i rami remoti eliminati

git remote Prune Origin

Mashup di tutte le altre risposte. Richiede Ruby 1.9.3+, testato solo su OS X.

Chiama questo file git-remove, rendilo eseguibile e mettilo nel tuo percorso. Quindi utilizzare, ad esempio, 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

Ho aggiunto i seguenti alias al mio file .gitconfig. Questo mi consente di eliminare i rami con o senza specificare il nome del ramo. Il nome del ramo è impostato di default sul ramo corrente se non viene passato alcun argomento.

[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"

Un'opzione alternativa alla riga di comando per l'eliminazione dei rami remoti è la GitHub branches page .

Vedi ad esempio: https://github.com/angular/angular.js/branches

Trovato nella pagina Code -> Branches di un repository GitHub.

Generalmente preferisco la linea di comando ma questa Pagina GitHub ti mostra molte più informazioni sui rami, come ultima data di aggiornamento e user , e numero di commit avanti e indietro . È utile quando si ha a che fare con un gran numero di rami.

Ho anche avuto problemi simili, e questo sembra funzionare: questo elimina il ramo locale. git branch -d the_local_branch

Rimuove il ramo remoto git Push Origin :the_remote_branch

Fonte: Makandra Cards

Ci sono buone risposte, ma, nel caso in cui tu abbia una tonnellata di rami, cancellandoli uno per uno localmente e remotly, sarebbe un compito noioso. È possibile utilizzare questo script per automatizzare queste attività.

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 

• Elenca i rami che non vuoi eliminare
• Esaminare il ramo dei telecomandi e se non sono nella nostra "lista di riserva", abbiamo eliminato.

Fonte: rimozione-git-branches-at-once

Usando GitBash puoi eseguire quanto segue:

git branch --delete <branch>

OR

Dall'app desktop GitHub, quando si ha il ramo estratto, è possibile eliminare Local branch tramite la striscia di menu Branch:

Se tu ARE NON utilizza l'app desktop GitHub e stai usando un IDE come Visual Studio per il tuo controllo sorgente locale, tutto ciò che devi fare è un paio di passaggi veloci:

1. Controlla una filiale diversa da quella che desideri eliminare.
2. Fare clic con il pulsante destro del ramo che si desidera eliminare.
3. Seleziona l'opzione Elimina dal menu di scelta rapida.

Quindi, una volta effettuato l'accesso al tuo account GitHub online, vai al repository e fai clic suTutti i ramitab. Da lì, fai clic sull'icona del cestino sulla destra sul nome del brach che desideri eliminare.

* Tieni presente che se la filiale non è pubblicata, non è necessario provare a eliminarla dal tuo repository online.

Ho creato la seguente comoda funzione nel mio file .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
}

Secondo l'ultimo documento che utilizza il terminale possiamo cancellare il seguente modo.

elimina in locale:

git branch -D usermanagement

elimina in postazione remota:

git Push --delete Origin usermanagement

È molto semplice

Per eliminare il ramo remoto

git Push -d Origin <branch-name>

OR

git Push Origin :<branch-name>

Per eliminare il ramo locale

git branch -D <branch-name>