come posso eliminare un ramo Git localmente e da remoto?

voglio eliminare un ramo sia localmente che da remoto.

tentativi falliti per eliminare ramo remoto:

$ 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 con successo il ramo remotes/origin/bugfix sia in locale che in remoto?


En title : How do I delete a Git branch locally and remotely?

106 Comments:

  1. sommario esecutivo

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

    si noti che nella maggior parte dei casi il nome remoto è origin.

    eliminare ramo locale

    per eliminare il ramo locale utilizzare uno dei seguenti:

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

    nota: l'opzione -d è un alias per --delete, che elimina solo il ramo se è già stato completamente unito nel ramo upstream. si potrebbe anche usare -D, che è un alias per --delete --force, che elimina il ramo "indipendentemente dal suo stato unito." [fonte: man git-branch]

    elimina ramo remoto [Aggiornato il 08 settembre 2017]

    a partire da Git v1.7.0, puoi cancellare un ramo remoto usando

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

    che potrebbe essere più facile da ricordare che

    $ 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 puoi anche usare git push con l'opzione -d come alias per --delete.

    pertanto, la versione di Git che hai installato determinerà se hai bisogno di usare la sintassi più semplice o più difficile.

    elimina ramo remoto [Risposta originale da 5-Jan-2010]

    dal capitolo 3 di Pro Git di Scott Chacon:

    Deleting Remote Branches

    Suppose you’re done with a remote branch — say, you and your collaborators are finished with a feature and have merged it into your remote’s master branch (or whatever branch your stable code-line is in). You can delete a remote branch using the rather obtuse syntax git push [remotename] :[branch]. If you want to delete your server-fix branch from the server, you run the following:

    { 5 }

    Boom. No more branch on your server. You may want to dog-ear this page, because you’ll need that command, and you’ll likely forget the syntax. A way to remember this command is by recalling the git push [remotename] [localbranch]:[remotebranch] syntax that we went over a bit earlier. If you leave off the [localbranch] portion, then you’re basically saying, “Take nothing on my side and make it be [remotebranch].”

    ho pubblicato git push origin :bugfix e ha funzionato splendidamente. Scott Chacon aveva ragione - Voglio orecchio cane che pagina (o praticamente orecchio cane rispondendo a questo su Stack & nbsp; Overflow).

    poi si dovrebbe eseguire questo su altre macchine

    git fetch --all --prune
    

    per propagare i cambiamenti.

    1. se si conosce la sintassi git push origin local_branch:remote_branch, allora la sintassi per eliminare un ramo con git push origin :remote_branch è una specie di carino. c'è un vuoto prima del :
    1. non dimenticare di fare un git fetch --all --prune su altre macchine dopo aver eliminato il ramo remoto sul server. | | | Dopo aver eliminato il ramo locale con git branch -d e aver eliminato il ramo remoto con git push origin --delete altre macchine possono ancora avere "rami di tracciamento obsoleti" (per vederli fare git branch -a). per sbarazzarsi di questi fare git fetch --all --prune.
    1. oltre a @TrevorBoydSmith's git branch -a per visualizzare tutti i rami, è anche possibile utilizzare git branch -r per visualizzare solo i rami remoti. vedere anche git remote show origin - fonte: http://gitready.com/intermediate/2009/02/13/list-remote-branches.html
    1. ho dovuto eseguire git branch -D Branch_Name per sbarazzarsi del ramo locale
    1. la domanda era "Cosa devo fare in modo diverso per eliminare con successo il ramo remotes / origin / bugfix sia localmente che su GitHub?" dopo aver eseguito i comandi nella risposta aggiornata, il ramo locale è ancora presente. sarebbe bello se la risposta accettata fosse una risposta completa. e 'assolutamente incredibile quanto difficile Git faccia compiti semplici...
    1. sto ottenendo error: Cannot delete the branch '19_jan_improvements_post_v1' which you are currently on. quando sto cercando di eliminare un ramo locale, che sto lavorando su quel ramo. non sono in grado di checkout di un ramo diverso anche, perché devo unire alcuni file e quindi dà questo errore - error: you need to resolve your current index first. cosa fare se semplicemente non mi interessa la fusione di questi file e comunque voglio sbarazzarsi del ramo locale.
    1. non funziona se sei nel ramo. devi fare un git checkout master o qualsiasi altra cosa per uscire dal branch prima.
    1. per capire meglio la sintassi git push origin: vai a https://stackoverflow.com/questions/1519006/how-do-you-create-a-remote-git-branch
    1. si noti che -d come alias per --delete funziona anche con la chiamata push. così funziona anche git push origin -d <branch_name>
    1. @Alex78191 Perché non si può voler spingere il ramo a tutti i telecomandi. comunque uso questo alias quando voglio spingere tutto il mio ramo verso tutti i miei telecomandi. https://stackoverflow.com/a/18674313/1308453
    1. puoi anche usare lo strumento albero dei sorgenti se non vuoi ricordare i comandi git.
    1. il --delete potrebbe essere più facile da ricordare, ma è troppo tardi se si capisce già il push remote :deadbr, più la cosa carina di quest'ultimo è che funziona anche per i tag.
    1. nel riepilogo esecutivo si dispone di git push --delete <remote_name> <branch_name>, ma nella prima sezione "Elimina Remote Branch Update" si dispone di git push <remote_name> --delete <branch_name>. cioè vale a dire i parametri sono in ordine diverso. posso suggerire di fare lo stesso per evitare confusione per favore.
    1. ho eseguito la prima riga del sommario esecutivo e la seconda non era "necessaria" (?). il ramo è andato sia localmente che in remoto.
    1. @DanielSpringer Questo non dovrebbe essere il caso. cancellerà il ramo remoto origin/mybranch nel repo e sul server, ma non cancellerà nessun ramo locale (mybranch).
    1. nota che questo può fallire con ! [remote rejected] <branch_name> (refusing to delete the current branch: refs/heads/<branch_name>) error: failed to push some refs to 'git@github.com:<org_name>/<project_name>.git' se hai impostato questo ramo in Github come ramo predefinito. se avete, andate al vostro progetto in Github - > "Impostazioni" - > "Filiali" e poi cambiate il ramo predefinito in un altro. poi ripetere il comando per eliminare il ramo funzionerà.
    1. @Matthew Rankin all'inizio della risposta afferma $ git push --delete <remote_name> <branch_name> e, successivamente, $ git push <remote_name> --delete <branch_name>. sono entrambi equivalenti?
  2. puoi anche usare quanto segue per eliminare il ramo remoto

    git push --delete origin serverfix
    

    che fa la stessa cosa

    git push origin :serverfix
    

    ma può essere più facile da ricordare.

    1. hai dimenticato la parte su come eliminare il ramo locale che può essere fatto da: git branch -d <local_branch> o git branch -D <local_branch> per l'eliminazione di forza
  3. oltre alle altre risposte, uso spesso lo strumento git _ remote _ branch. si tratta di un'installazione extra, ma si ottiene un modo conveniente per interagire con i rami remoti. in questo caso, per cancellare:

    grb delete branch
    

    trovo che uso spesso anche i comandi publish e track

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

    per rimuovere un ramo locale dalla tua macchina:

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

    per rimuovere un ramo remoto dal server:

    git push origin --delete {the_remote_branch}

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

    1. @megido bene -D forza cancella, -d ti dà un avvertimento se non è già fusa.
    1. se il ramo locale non si fonde con master e viene eseguito 'git branch -d your_branch allora si avrà un errore del tipo error: The branch 'your_branch' is not fully merged. If you are sure you want to delete it, run 'git branch -D your_branch'.
    1. altri con cloni dei repository dove sono stati rimossi i branch remoti dovrebbero funzionare git remote prune <name> (ad esempio git remote prune origin) per rimuovere localmente rami stantii che non esistono più nel telecomando.
    1. se il tuo ramo nel tuo fork (non sempre origine), usa il repository appropriato. ad es. per esempio Git push myRepo: mrbranchtodelete
    1. se stai cancellando un ramo, sia in locale che in remoto, perché importa se ci sono commit non fuse? stai soffiando via comunque...
    1. @ganders Il punto è che si potrebbe non rendersi conto che ci sono stati unmerged commit, e potrebbe non voler eliminare il ramo più dopo aver imparato che. -d ti protegge da perdere accidentalmente il lavoro.
    1. vorrei aggiungere che -d dà un avviso se non è collegato all'HEAD corrente. se avete bisogno di chiarezza vi consiglio questo comando git branch -a --merged origin/master Esso elenca tutti i rami, sia locale che remoto; che sono stati uniti in master. ulteriori informazioni qui
  5. suggerimento: quando si eliminano i rami utilizzando

    git branch -d <branchname> # deletes local branch
    

    o o o o o

    git push origin :<branchname> # deletes remote branch
    

    solo i riferimenti vengono eliminati. anche se il ramo è in realtà rimosso sul telecomando i riferimenti ad esso esiste ancora nei repository locali dei tuoi membri del team. ciò significa che per gli altri membri del team i rami eliminati sono ancora visibili quando fanno un git branch -a.

    per risolvere questo i tuoi membri della squadra possono potare i rami eliminati con

    git remote prune <repository>
    

    questo è tipicamente git remote prune origin.

    1. si dovrebbe chiarire che l'operazione precedente git push elimina il ramo locale e il ramo remoto.
    1. si noti che git remote prune è un modo un po 'obsoleto per rimuovere i rami obsoleti di tracciamento remoto, il modo più recente per farlo è usare git fetch --prune o git fetch -p.
    1. @RRMadhav, infatti non vedrete il ramo cancellato dopo averlo cancellato dal momento che il riferimento al ramo remoto verrà rimosso localmente. chiunque altro sulla tua squadra che ha controllato quel ramo avrà ancora quel riferimento e lo vedrà ancora a meno che non potano il ramo.
  6. un altro approccio è:

    git push --prune origin
    

    attenzione: questo cancellerà tutti i rami remoti che non esistono localmente. o più completo,

    git push --mirror
    

    farà in modo che il repository remoto appaia come la copia locale del repository (le testine locali, i telecomandi ed i tag sono copiati su remoto).

    1. Git push --prune origin non ha fatto nulla per me su gitlab: Git clone git: / / repo.git; git branch -d -r origin / some-branch; git push --prune origin; yields: tutto aggiornato; git fetch; riporta i branch eliminati localmente; git push --mirror; ora sono davvero scomparsi!
  7. se si desidera completare entrambi questi passaggi con un solo comando, è possibile fare un alias per esso aggiungendo il sotto al ~/.gitconfig:

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

    in alternativa, è possibile aggiungere questo alla configurazione globale dalla riga di comando utilizzando

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

    nota: se si utilizza -d (lowercase d), il ramo verrà eliminato solo se è stato fuso. per forzare l'eliminazione, è necessario utilizzare -D (D maiuscola).

    1. questo è quello che stavo cercando. il mio alias di funzione shell non funzionava (Unexpected EOF) e non riuscivo a capire perché, ma questo funziona alla grande! l'unica modifica che ho fatto è stata sostituire && con ; in modo che anche se il primo comando fallisce il secondo esegua ancora (a volte esiste solo locale o solo remoto).
  8. è anche possibile farlo utilizzando git remote prune origin

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

    pota ed elimina rami di tracciamento remoto da un elenco git branch -r.

  9. uso le seguenti impostazioni Bash:

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

    poi si può chiamare:

    git-shoot branchname
    
    1. ho finito per aggiungere l'alias "shoot" nel mio .gitconfig shoot = push origin --delete
    1. se la tua origine è una Stash Atlassian e il ramo è impostato come predefinito, si otterrà un errore "Per impostazione predefinita, l'eliminazione del ramo corrente è negato...". ho dovuto cambiare il ramo di default in Stash per puntare ad un altro ramo prima di poter eliminare.
    1. questo è perfettamente semplice come l'hai fatto, ma fyi git ti permette anche di fare comandi personalizzati. mettere git push origin --delete $1 in un file sul percorso chiamato git-shoot e git shoot branchname funzionerà anche.
    1. ho solo iniziato a usare Github quest'anno, quindi mi chiedevo perché questa era una domanda così altamente valutato, e perché nessuna delle migliori risposte stavano suggerendo di eliminarlo solo dall'interfaccia web Github! interessante che è solo una recente aggiunta.
    1. stavo andando indicare questo fuori. nota che il pulsante non cancella il ramo locale... vedi questa risposta per come farlo: http://stackoverflow.com/a/10999165/901641
  10. git branch -D <name-of-branch>
    git branch -D -r origin/<name-of-branch>
    git push origin :<name-of-branch>
    
    1. si noti che -D forza la cancellazione. e 'sempre meglio utilizzare -d, che ricorderà se avete bisogno di fare qualcosa di pericoloso.
    1. Ahahah:) dipende da te: USA -d se vuoi vedere git crying o -D se vuoi piangere.
  11. mashup di tutte le altre risposte. richiede Ruby 1.9.3+, testato solo su OS X.

    chiami questo file git-remove, lo faccia eseguibile, e lo metta nel Suo percorso. quindi utilizzare, per 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
    
    1. una lettera per gentile concessione di questa risposta: http://stackoverflow.com/a/8072675/8047
    1. @chhh allora è necessario estendere questa funzionalità per rendere questa una variabile invece di un presupposto.
    1. spiacenti, ma installa Ruby per questo tipo di lavoro? più logica è l'implementazione su bash, che funzionerà fuori dalla scatola.
    1. @Reishin Ruby è installato sul box proprio come Bash, almeno su OSX. vedere: http://stackoverflow.com/questions/2342894/why-and-when-to-use-shell-instead-of-ruby, dove questo argomento è stato scartato come opinion-based da SO.
    1. @Yar questo link è fuori dal contesto e hanno un ambito più ampio. dico solo git e dato che l'argomento non è nato solo per OSX, scegliere è strano per altri sistemi (ad esempio * UNIX, Windows)
  12. molte delle altre risposte porteranno ad errori / avvertimenti. questo approccio è relativamente sciocco prova anche se si può ancora bisogno di git branch -D branch_to_delete se non è completamente fusa in some_other_branch, per esempio.

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

    potature remote non è necessario se hai cancellato il ramo remoto. è usato solo per ottenere i telecomandi più aggiornati disponibili su un repository che stai monitorando. ho osservato git fetch aggiungerà telecomandi, non rimuoverli. ecco un esempio di quando git remote prune origin effettivamente fare qualcosa:

    utente A fa i passi sopra. utente B eseguirà i seguenti comandi per vedere i rami remoti più aggiornati

    git fetch
    git remote prune origin
    git branch -r
    
  13. le risposte brevi

    se volete spiegazioni più dettagliate dei seguenti comandi, guardate le lunghe risposte 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 un ramo locale:

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

    eliminazione di un ramo locale di tracciamento remoto:

    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 risposta lunga: ci sono 3 diversi rami da eliminare!

    quando si ha a che fare con l'eliminazione di rami sia in locale che in remoto, tenere presente che ci sono 3 diversi rami coinvolti:

    1. il ramo locale X.
    2. il ramo di origine remota X.
    3. il ramo locale di tracciamento remoto origin/X che traccia il ramo remoto X.

    Visualization of 3 branches

    il poster originale usato

    git branch -rd origin/bugfix
    

    che ha cancellato solo il suo ramo locale di tracciamento remoto origin/bugfix, e non il ramo remoto effettivo bugfix su origin.

    Diagram 2

    per cancellare quel ramo remoto, devi

    git push origin --delete bugfix
    

    Diagram 3

    dettagli aggiuntivi Dettagli

    le seguenti sezioni descrivono ulteriori dettagli da considerare quando si eliminano i rami di tracciamento remoto e remoto.

    spingendo per eliminare i rami remoti elimina anche i rami di tracciamento remoto

    si noti che cancellare il ramo remoto X dalla riga di comando usando un git push cancellerà anche il ramo locale di tracciamento remoto origin/X, quindi non è necessario eliminare il ramo obsoleto con git fetch --prune o git fetch -p, anche se non sarebbe male se lo facessi comunque.

    è possibile verificare che il ramo di tracciamento remoto origin/X sia stato cancellato eseguendo le seguenti operazioni:

    # 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'obsoleta origine locale del ramo di tracciamento remoto / X

    se non hai cancellato il tuo ramo remoto X dalla riga di comando (come sopra), allora il tuo repo locale conterrà ancora (un ramo ormai obsoleto) il tracciamento remoto origin/X. questo può accadere se hai cancellato un ramo remoto direttamente attraverso l'interfaccia web di GitHub, per esempio.

    un modo tipico per rimuovere questi obsoleti rami di tracciamento remoto (dalla versione 1.6.6 di Git) è semplicemente eseguire git fetch con il --prune o più corto -p. si noti che questo rimuove tutti i rami locali obsoleti per il tracciamento remoto di qualsiasi ramo remoto che non esiste più sul telecomando:

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

    ecco la citazione relativa dalle note di rilascio 1.6.6 (miniera di enfasi):

    "git fetch" learned --all and --multipleoptions, to run fetch from many repositories, and --prune option to remove remote tracking branches that went stale. These make "git remote update" and "git remote prune" less necessary (there is no plan to remove "remote update" nor "remote prune", though).

    alternativa alla potatura automatica sopra indicata per rami remoti obsoleti

    in alternativa, invece di potare i vostri obsoleti rami locali di tracciamento remoto attraverso git fetch -p, potete evitare di effettuare l'operazione di rete extra semplicemente rimuovendo manualmente il ramo (es) con i flag --remote o -r:

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

    vedi anche

    1. dalla vostra illustrazione, posso vedere ci sono repo clone locale e repo origine remota. quindi ci sono almeno due rami fisici. dove è il terzo ramo da eliminare? il terzo ramo è solo un puntatore che punta ad una commit nel repo clone locale?
    1. @huggie che è praticamente corretto. i branch in Git sono solo i segnalibri attaccati alle commit. così nei miei grafici sopra, ci sono X e origin/X segnalibri nel clone locale (2 rami), e poi c'è X sul telecomando (fare 3 rami).
  14. nota del moderatore: se intendete rispondere a questa domanda, fate notare che ci sono già 40 risposte pubblicate. la tua nuova risposta aggiungerà qualche valore sostanziale?
  15. 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 questo 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 usa:

    git push origin :refs/tags/branch-or-tag-name
    
    1. questo va bene, ma le persone in realtà non dovrebbero nominare i loro rami e tag con lo stesso nome e lo stesso schema di denominazione, in primo luogo.
    1. bene, il mio scenario era che stavo convertendo un ramo in una modifica ed ha avuto senso affinchè la modifica abbia lo stesso nome del ramo. convertendo voglio dire unire il ramo B a A e taggare l'ultima commit nel ramo B con il tag B in modo che dopo aver cancellato il ramo B possa ancora essere facilmente ripristinato semplicemente controllando il tag B.
  16. se vuoi eliminare un ramo, verifica prima il 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
    
  17. questo è semplice: basta eseguire il seguente comando:

    per eliminare un ramo Git sia in locale che in remoto, prima elimina il ramo locale usando il comando:

    git branch -d example
    

    (qui example è il nome del ramo)

    e dopo di che eliminare ramo remoto con il comando:

    git push origin :example
    
  18. semplicemente dire:

    git branch -d <branch-name>
    git push origin :<branch-name>
    
    1. questo funziona se il proprio ramo. ma se si stanno potando tutti i rami non necessari nel repo (alcuni dei quali non sono tuoi) non sarebbe sufficiente
  19. git push origin --delete <branch Name>
    

    è più facile da ricordare che

    git push origin :branchName
    
  20. eliminare localmente:

    per eliminare un ramo locale, è possibile utilizzare:

    git branch -d <branch_name> 
    

    per eliminare forzatamente un ramo, utilizzare -D invece di -d.

    git branch -D <branch_name>
    

    eliminare da remoto:

    ci sono due opzioni:

    git push origin :branchname  
    
    git push origin --delete branchname 
    

    vorrei suggerire di utilizzare il secondo modo in quanto è più intuitivo.

  21. nota: per Git 2.5 + (Q2 2015), il messaggio esatto sarà "deleted remote-tracking branch": vedere https://github.com/git/git/commit/ccd593cffaa020ff767860ec211462b8dbd727a6#diff-d18f86ea14e2f1e5bff391b2e54438cbR268
  22. ora puoi farlo con l'app GitHub Desktop.

    dopo il lancio dell'app

    1. clicca sul progetto che contiene il ramo
    2. passare al ramo che si desidera eliminare
    3. dal menu "Branch", selezionare, "unpublish...", per avere il ramo cancellato dai server GitHub. unpublish branch
    4. dal menu "Branch", seleziona "Elimina" branch _ name "...", per far cancellare il branch dalla tua macchina locale (alias la macchina su cui stai lavorando)
    1. non ho downvote, ma il mio pensiero è che non sta aiutando presuntuosamente. la domanda è ovviamente chiedere una risposta più tipo Commandline senza dover usare un programma esterno, se la gente stava cliccando qui, probabilmente non sarà alla ricerca di un github per modi desktop.
    1. @Daemedeor, non sono d'accordo. nel 2010, quando il OP ha fatto la domanda, il modo di fare l'interfaccia utente non esisteva e l'unica opzione era la riga di comando. per indicare che si desidera una riga di comando solo opzione dovrebbe essere indicato nella domanda o con il tag, [etichetta: interfaccia linea di ricetrasmissione], che in questo caso non è presente.
    1. il comando git per cancellare un ramo remoto fa schifo e tendo a dimenticarlo (sia vecchio che nuovo). per fortuna ci sono strumenti GUI che hanno l'opzione. Git Gui, TortoiseGit e GitHub Desktop ce l'hanno - vorrei che anche le estensioni Git avessero questa funzionalità. comunque, quello che ricordo è avviare Git Gui all'interno delle Estensioni Git quando ho bisogno di cancellare un ramo remoto.
  23. eliminazione di rami

    Let's assume our work on branch "contact-form" is done and we've already integrated it into "master". Since we don't need it anymore, we can delete it (locally):

    { 1 }

    e per eliminare il ramo remoto:

    git push origin --delete contact-form
    
  24. elimina ramo remoto

    git push origin :<branchname>

    elimina ramo locale

    git branch -D <branchname>

    elimina i passaggi del ramo locale:

    1. checkout di un altro ramo
    2. elimina ramo locale
    1. @SamithaChathuranga no, git push origin :<branchname> già inserisce un ramo 'vuoto' nel telecomando (quindi elimina il ramo remoto)
  25. per eliminare il ramo localmente e da remoto

    • checkout per ramo master - git checkout master

    • cancella il ramo remoto - git push origin --delete <branch-name>

    • elimina il ramo locale - git branch --delete <branch-name>

  26. un'opzione alternativa alla riga di comando per l'eliminazione di rami remoti è la pagina rami GitHub.

    vedere per esempio: https://github.com/angular/angular.js/branches

    si trova nella pagina Code - > Branches di un repository GitHub.

    io preferisco generalmente la linea di comando me stesso, ma questa pagina GitHub mostra un sacco di informazioni sui rami, come l'ultima data aggiornata e l'utente, e il numero di commit avanti e indietro. è utile quando si tratta di un gran numero di rami.

  27. mi sono ammalato di googling per questa risposta, così ho preso un approccio simile alla risposta che CrizCraig pubblicato in precedenza.

    aggiunto il seguente al mio profilo Bash:

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

    poi ogni volta che sono finito con un ramo (fuso in master, per esempio) eseguo quanto segue nel mio terminale:

    gitdelete my-branch-name
    

    ... che poi elimina my-branch-name da origin così come localmente.

    1. espansione su questo, --delete "$@" e -D "$@" invece di $1 sarà gestire per più rami.
  28. git push origin :bugfix  # Deletes remote branch
    git branch -d bugfix     # Must delete local branch manually
    

    se sei sicuro di volerlo cancellare, esegui

    git branch -D bugfix
    

    ora per ripulire i rami remoti cancellati eseguire

    git remote prune origin
    
  29. ho avuto anche problemi simili, e questo sembra funzionare: questo elimina ramo locale. git branch -d the_local_branch

    questo rimuove il ramo remoto git push origin :the_remote_branch

    fonte: carte Makandra

  30. prima di eseguire prima

    git branch --delete <branch>
    

    assicuratevi di determinare prima quale sia il nome EXACT del ramo remoto eseguendo:

    git ls-remote
    

    questo vi dirà cosa inserire ESATTAMENTE per <branch> valore. (branch è sensibile al caso!)

  31. ci sono buone risposte, ma, nel caso in cui si dispone di una tonnellata di rami, eliminarli uno ad uno localmente e remotamente, 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 
    
    • elencare i rami che non si desidera eliminare
    • iterare sul ramo telecomandi e se non sono nella nostra "lista conserva", abbiamo cancellato.

    fonte: removing-git-branches-at-once

  32. un comando di linea elimina sia locale che remoto:

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

    o aggiungete l'alias qui sotto al vostro ~ / .gitconfig; uso: git kill branch-name

    [alias]
        kill = "!f(){ git branch -D \"$1\";  git push origin --delete \"$1\"; };f"
    
    1. l'uso git branch -D Afferma attentamente in uno script, poiché forza-cancella un ramo senza controllarlo è stato fuso. utilizzare -d per essere sicuro.
  33. usando GitBash puoi eseguire quanto segue:

    git branch --delete <branch>
    

    o o o o o

    dall'app desktop GitHub, quando hai il ramo selezionato, puoi eliminare il ramo locale tramite la barra dei menu Branch:

    enter image description here

    se NON utilizzi l'app desktop GitHub e stai usando un IDE come Visual Studio per il tuo controllo sorgente locale, tutto quello che devi fare è un paio di passi veloci:

    1. controlla un ramo diverso da quello che vuoi eliminare.
    2. fare clic con il pulsante destro del mouse sul ramo che si desidera eliminare.
    3. selezionare l'opzione Elimina dal menu contestuale.

    poi, una volta effettuato l'accesso al tuo account GitHub online, vai nel repository e fai clic sulla scheda Tutti i rami. da lì, basta fare clic sul piccolo cestino icona a destra sul nome del brach che si desidera eliminare.

    enter image description here

    * Tenete a mente - se il ramo non è pubblicato, non c'è bisogno di cercare di eliminarlo dal tuo repository online.

    1. non vedo questi Overview, Yours, Active, State e All branches scheda sul sito web GitHub. sembra che questa sia una vecchia istantanea. sotto la scheda Code, vedo sotto-schede come commit, branch, release e contributori. quando sono proprietario di un repository vedo una scheda aggiuntiva chiamata MIT.
    1. git branch --delete <branch> non elimina un ramo remoto, è necessario git push <server> --delete <branch> per farlo
  34. ho aggiunto i seguenti alias al mio file .gitconfig. questo mi permette di cancellare rami con o senza specificare il nome del ramo. il nome del ramo viene impostato in default al 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"
    
    1. fare attenzione con l'opzione de -D. in un batch considerare utilizzando inferiore -d
    1. nel mio caso, sono quasi sempre eliminazione dopo la fusione (o senza la necessità di unire). utilizzando lower -d sarà necessario unire il ramo prima di eliminare, usando -D si forza la cancellazione del ramo.
  35. per eliminare localmente - (normale),

    git branch -d my_branch
    

    se il tuo ramo nel rebasing / merge progresso e che non è stato fatto correttamente significa, si otterrà un errore Rebase/Merge in progress in modo che in quel caso, non sarà in grado di eliminare il ramo.

    quindi o il vostro bisogno di risolvere rifondazione / fusione altrimenti si può fare forza Delete utilizzando,

    git branch -D my_branch
    

    per cancellare in Remote:

    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,

    enter image description here

  36. passi per l'eliminazione di un ramo:

    per eliminare il ramo remoto:

    git push origin --delete <your_branch> 
    

    per cancellare il ramo locale, hai 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
    

    spiegare: OK, basta spiegare cosa sta succedendo qui!

    basta fare git push origin --delete per eliminare il ramo remoto SOLO, aggiungere il nome del ramo alla fine e questo cancellerà e lo spingerà a remoto allo stesso tempo...

    inoltre, git branch -D, che semplicemente eliminare il ramo locale SOLO!...

    -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 lancia un errore relativo allo stato di fusione del ramo...

    creo anche l'immagine qui sotto per mostrare i passi:

    delete a remote and local branch in git

    1. git branch -a visualizzerà branches locali e remoti. sarà di aiuto per voi diagramma introdurre.
    1. quando i branch vengono eliminati all'origine, il tuo repository locale non se ne accorgerà.

      avrai ancora le tue versioni memorizzate nella cache locale di quei rami (il che è effettivamente buono) ma git branch -a li elencherà ancora come rami remoti.

      è possibile ripulire tali informazioni localmente come questo:

      git remote prune origin Le copie locali dei rami cancellati non vengono rimosse da questo.

      lo stesso effetto si ottiene utilizzando git fetch --prune

  37. 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
    }
    
  38. secondo l'ultimo documento che utilizza terminale possiamo cancellare in modo seguente.

    cancellare in locale:

    git branch -D usermanagement
    

    cancellazione in posizione remota:

    git push --delete origin usermanagement
    
  39. Its very simple

    per eliminare ramo remoto

    git push -d origin <branch-name>
    

    o o o o o

    git push origin :<branch-name>
    

    per eliminare ramo locale

    git branch -D <branch-name>
    
    1. -d opzione è un alias per --delete e se --delete lavoro poi -d dovrebbe anche funzionare, se si vuole con forza eliminare un ramo è possibile utilizzare -D invece di -d o --delete.

More similar articles:

  • come posso aggiungere un ramo remoto esistente al mio repository clonato localmente?
  • come posso inviare un nuovo ramo locale ad un repository Git remoto e monitorarlo?
  • come eliminare il ramo "remoto" che mostra ancora localmente?
  • come leggere questo output di Git, con confusione nel repository remoto/ramo locale
  • come posso documentare un ramo in un repository remoto?
  • eliminare ramo locale chiamato "remoto"
  • Git - Impossibile eliminare ramo remoto
  • come posso creare un ramo localmente che traccia un ramo remoto
  • come provare una versione di un'app da un ramo dedicato su un server remoto?
  • come unire un ramo da un remoto all'origine/master
  • come impostare un ramo git per inviare a un remoto con un nome di ramo differente e tirare da url completamente diversi
  • come estrarre il ramo remoto da repo di qualcun altro
  • Git: come cambiare il ramo attivo nel repository remoto?
  • come posso creare un ramo git come develop/user1/issue1
  • come eliminare ramo locale e remoto usando git
  • come posso fare il checkout di un ramo remoto?
  • come funziona il rebasing master su un ramo locale "remoto"?
  • con git, come rimuovere una copia locale di un ramo remoto? o almeno tirare senza fondere?
  • modulo Git per tenere traccia del ramo remoto
  • Git - Sostituisci ramo locale con ramo remoto
  • come inviare da remoto e ramo A a remoto e ramo B con terminale Git?
  • Git invia un ramo da un remoto ad un altro?
  • Git rifiuta di tracciare o riconoscere il ramo remoto
  • Git remote prune origin non elimina il ramo locale anche se il suo ramo remoto a monte viene eliminato
  • c'è qualche modo per permettere di spingere solo il ramo locale specificato verso il remoto specificato?
  • come inviare solo ramo corrente da repo locale a remoto in git?
  • come fare git config rispetta l'impostazione push remoto del ramo
  • Git: fondere un ramo remoto localmente
  • come cancellare con forza un ramo remoto in GitHub?
  • come rimuovere il ramo remoto e la sua cronologia di commit da git?