la réponse de Matthieu est grande pour enlever les branches éloignées et j'apprécie aussi l'explication, mais pour faire une simple distinction entre les deux commandes:

pour supprimer un branche locale de votre machine:

git branch -d {the_local_branch} (utilisez -D au lieu de forcer la suppression de la branche sans vérifier le statut fusionné)

pour supprimer un branche distante du serveur:

git push origin --delete {the_remote_branch}

référence: https://makandracards.com/makandra/621-git-delete-a-branch-local-or-remote

Les Réponses Courtes

si vous voulez des explications plus détaillées des commandes suivantes, voyez les réponses dans la section suivante.

suppression d'une branche distante:

git push origin --delete <branch>  # Git version 1.7.0 or newer
git push origin :<branch>          # Git versions older than 1.7.0

suppression d'une succursale locale:

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

suppression d'une branche locale de suivi à distance:

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 longue réponse: il y a 3 branches différentes à supprimer!

Lorsqu'il s'agit de supprimer des branches à la fois localement et à distance, gardez à l'esprit que il y a 3 branches différentes impliquées :

1. La branche locale X .
2. de La télécommande d'origine de la branche X .
3. Le local à distance-le suivi de la branche origin/X qui suit la branche distante X .

l'original de L'affiche

git branch -rd origin/bugfix

qui ne supprimait que sa local remote-tracking branch origin/bugfix , et non la véritable remote-tracking branch bugfix sur origin .

pour supprimer cette branche distante , vous avez besoin de

git push origin --delete bugfix

Détails Supplémentaires

les sections suivantes décrivent les détails supplémentaires à considérer lors de la suppression de vos branches distantes et de suivi à distance.

suppression de branches distantes par poussée supprime également les branches de suivi à distance

notez que la suppression de la branche distante X de la ligne de commande à l'aide d'un git push supprimera également la branche locale branche de suivi à distance origin/X , il n'est donc pas nécessaire de tailler la branche de suivi à distance obsolète avec git fetch --prune ou git fetch -p , bien que cela ne ferait pas de mal si vous le faisiez de toute façon.

vous pouvez vérifier que la branche de suivi à distance origin/X a aussi été supprimée en exécutant ce qui suit:

# 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

élagage de la branche de télésurveillance locale désuète origine / X

si vous n'avez pas supprimé votre branche distante X de la ligne de commande (comme ci-dessus), alors votre rapport local contiendra toujours (une branche maintenant obsolète) la branche de suivi à distance origin/X . Cela peut se produire si vous supprimez une branche distante directement via l'interface web de GitHub, par exemple.

une façon typique de supprimer ces branches obsolètes de suivi à distance (depuis la version 1.6.6 de Git) est d'exécuter simplement git fetch avec le --prune ou plus court -p . noter que ce supprime toutes les branches locales obsolètes de suivi à distance pour toutes les branches distantes qui n'existent plus sur la télécommande :

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

Voici la citation pertinente tirée du 1.6.6 notes de mise à jour (emphasis mine):

"git fetch" appris --all et --multiple options, pour courir chercher à partir de de nombreux dépôts, et --prune option de supprimer suivi à distance des branches qui sont devenues périmées. ceux-ci font "git remote update" et "git moins nécessaire( il n'y a pas de plan pour supprimer mise à jour", ni "à distance prune", tout de même).

alternative à l'élagage automatique ci-dessus pour les branches obsolètes de télésurveillance

alternativement, au lieu d'élaguer vos branches locales obsolètes à distance par git fetch -p , vous pouvez éviter de faire l'opération de réseau supplémentaire en enlevant simplement manuellement la(les) branche (s) avec les drapeaux --remote ou -r :

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

Voir Aussi

• git-branche(1) Page de Manuel de .
• git-fetch(1) page de manuel .
• Pro Git § 3.5 Git Branching-Remote Branches .

étapes pour supprimer une branche:

pour supprimer la branche distante:

git push origin --delete <your_branch> 

pour supprimer la branche locale , vous avez trois façons:

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

expliquer: ok, juste expliquer ce qui se passe ici!

simplement faire git push origin --delete à supprimer votre branche distante seulement , ajouter le nom de la branche à la fin et cela supprimera et poussera à distance en même temps...

aussi, git branch -D , qui suppriment simplement la branche locale seulement !...

-D signifie --delete --force qui supprimera la branche même si elle n'est pas fusionnée(force supprimer), mais vous pouvez également utiliser -d qui signifie --delete qui envoie une erreur relative au statut de fusion de la branche...

je crée aussi l'image ci-dessous pour montrer les étapes:

vous pouvez également utiliser ce qui suit pour supprimer la branche distante.

git push --delete origin serverfix

qui fait la même chose que

git push origin :serverfix

mais il peut être plus facile à retenir.

Si vous souhaitez supprimer une branche, d'abord passer à la direction autre que la direction générale d'être supprimé.

git checkout other_than_branch_to_be_deleted

suppression de la branche locale:

git branch -D branch_to_be_deleted

suppression de la branche distante:

git push origin --delete branch_to_be_deleted

Conseil: lorsque vous supprimez des branches en utilisant

git branch -d <branchname>    # deletes local branch

ou

git push origin :<branchname> # deletes remote branch

seules les références sont supprimés. Même si la branche est effectivement retirée sur la télécommande, les références à celle-ci existent toujours dans les dépôts locaux des membres de votre équipe. Cela signifie que pour les autres membres de l'équipe, les branches supprimées sont toujours visibles lorsqu'elles font un git branch -a .

pour résoudre ce que vos membres de l'équipe peuvent branches avec

git remote prune <repository>

c'est typiquement git remote prune origin .

git branch -D <name-of-branch>
git branch -D -r origin/<name-of-branch>
git push origin :<name-of-branch>

C'est simple: il suffit d'exécuter la commande suivante:

pour supprimer une branche Git à la fois localement et à distance, supprimez d'abord la branche locale en utilisant la commande:

git branch -d example

(ici example est le nom de la succursale)

et après cela supprimer la branche distante en utilisant la commande:

git push origin :example

une autre approche est

git push --prune origin

avertissement: cela supprimera toutes les branches distantes qui n'existent pas localement. ou plus globalement,

git push --mirror

fera en sorte que le dépôt distant ressemble effectivement à la copie locale du dépôt (têtes locales, remotes et tags sont reflétés à distance).

j'utilise ce qui suit dans mon Bash paramètres:

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

alors vous pouvez appeler:

git-shoot branchname

depuis janvier 2013, GitHub a inclus un bouton supprimer la branche à côté de chaque branche dans votre page "Branches".

article de blog pertinent: créer et supprimer des branches

si vous voulez accomplir ces deux étapes avec une seule commande, vous pouvez créer un alias pour elle en ajoutant ce qui suit à votre ~/.gitconfig :

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

alternativement, vous pouvez ajouter ceci à votre configuration globale à partir de la ligne de commande en utilisant

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

NOTE : si vous utilisez -d (minuscule d), la branche ne sera supprimée que si elle a été fusionnée. Pour forcer la suppression à se produire, vous aurez besoin d'utiliser -D (majuscule D).

pour supprimer votre branche localement et à distance

• Caisse à la branche principale - git checkout master

• supprimer votre branche distante - git push origin --delete <branch-name>

• supprimer votre succursale locale - git branch --delete <branch-name>

Supprimer localement:

Pour supprimer une branche locale, vous pouvez utiliser:

git branch -d branch_name 

pour supprimer de force une branche, utilisez -D au lieu de -d .

git branch -D branch_name

supprimer à distance:

il y a deux options:

git push origin :branchname  

git push origin --delete branchname 

je vous suggère d'utiliser la 2ème méthode, car elle est plus intuitive.

vous pouvez également le faire en utilisant git remote prune origin :

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

il taille et supprime les branches de télémesure d'une liste git branch -r .

en plus des autres réponses, j'utilise souvent l'outil git_remote_branch . C'est une installation supplémentaire, mais cela vous procure un moyen pratique d'interagir avec les branches distantes. Dans ce cas, supprimer:

grb delete branch

je trouve que j'utilise aussi assez souvent les commandes publish et track .

Suppression De Branches

supposons que notre travail sur la branche " contact-form "est fait et que nous l'avons déjà intégré dans"master". Puisque nous n'en avons plus besoin, nous pouvons l'effacer (localement):

$ git branch -d contact-form

et pour supprimer la branche distante:

git push origin --delete contact-form

One liner commande Supprimer à la fois locale et à distance :

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

ou ajoutez l'alias ci-dessous à votre ~/.gitconfig ; utilisation: git kill branch-name

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

supprimer la branche distante

git push origin :<branchname>

Supprimer branche locale

git branch -D <branchname>

supprimer les étapes locales de la branche:

1. caisse d'une autre succursale
2. supprimer branche locale

simplement dire:

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

Maintenant, vous pouvez le faire avec le GitHub Bureau app.

après le lancement de l'application

1. Cliquez sur le projet contenant la branche
2. passez à la branche que vous souhaitez supprimer
3. dans le menu" Branch", sélectionnez " Unpublish...", pour faire supprimer la branche des serveurs GitHub.
4. dans le menu" Branch", sélectionnez "Delete" branch_name "...', pour faire supprimer la branche de votre machine locale (alias la machine sur laquelle vous travaillez actuellement))

Supprimer localement - (Normal),

git branch -d my_branch

si votre branche en rebasant/fusionnant la progression et que cela n'a pas été fait correctement signifie, Vous obtiendrez une erreur Rebase/Merge in progress donc dans ce cas, vous ne pourrez pas supprimer votre branche.

donc soit votre besoin de résoudre rebasing / merging autrement vous pouvez faire la suppression de force en utilisant,

git branch -D my_branch

supprimer dans Remote:

git push --delete origin my_branch

peut faire la même chose à l'aide de

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

Représentation Graphique,

git push origin --delete branchName

est plus facile à retenir que

git push origin :branchName

cela ne fonctionnera pas si vous avez une étiquette avec le même nom que la branche sur la télécommande:

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

dans ce cas, vous devez spécifier que vous voulez supprimer la branche, pas l'étiquette:

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

de même, pour supprimer l'étiquette à la place de la branche que vous utiliseriez:

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

j'en ai eu marre de googler pour cette réponse, donc j'ai pris une approche similaire à la réponse que crizCraig a posté plus tôt.

a ajouté ce qui suit à mon profil Bash:

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

puis à chaque fois que j'en ai fini avec une branche (fusionnée dans master , par exemple) j'exécute ce qui suit dans mon terminal:

gitdelete my-branch-name

...qui supprime ensuite my-branch-name de origin ainsi que localement.

beaucoup d'autres réponses conduiront à des erreurs/avertissements. Cette approche est relativement stupide bien que vous pouvez encore avoir besoin de git branch -D branch_to_delete si elle n'est pas entièrement fusionnée dans some_other_branch , par exemple.

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

élagage à distance n'est pas nécessaire si vous avez supprimé la branche distante. Il est seulement utilisé pour obtenir les télécommandes les plus à jour disponibles sur une pension que vous traquez. J'ai observé que git fetch ajoutera des télécommandes, pas les supprimera. Voici un exemple de quand git remote prune origin sera effectivement faire quelque chose:

L'Utilisateur a effectue les étapes ci-dessus. L'utilisateur B exécuterait les commandes suivantes pour voir les branches distantes les plus à jour

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

si vous êtes sûr de vouloir le supprimer, Lancez

git branch -D bugfix

maintenant pour nettoyer les branches distantes supprimées, Lancez

git remote prune origin

avant l'exécution

git branch --delete <branch>

assurez-vous de déterminer d'abord le nom EXACT de la branche distante en exécutant:

git ls-remote

cela vous dira quoi inscrire exactement pour la valeur <branch> . ( branch est sensible à la casse!)

Mashup de toutes les autres réponses. Exige Ruby 1.9.3+, testé seulement sur OS X.

appelez ce fichier git-remove , rendez-le exécutable, et mettez-le dans votre chemin. Puis utilisez, par exemple, git remove temp .

#!/usr/bin/env ruby
require 'io/console'

if __FILE__ == "151900920"
      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