Comment tailler les branches de suivi locales qui n'existent plus sur la télécommande

Avec git remote prune originje peux supprimer les branches locales qui ne sont plus sur la télécommande.

Mais je veux également supprimer les branches locales qui ont été créées à partir de ces branches distantes (une vérification si elles ne sont pas fusionnées serait bien).

Comment puis-je faire ceci?

Après l'élagage, vous pouvez obtenir la liste des branches distantes avec git branch -r. La liste des branches avec leur branche de suivi à distance peut être récupérée avec git branch -vv. Donc, en utilisant ces deux listes, vous pouvez trouver les branches de suivi à distance qui ne figurent pas dans la liste des télécommandes.

Cette ligne devrait faire l'affaire (nécessite bashou zshne fonctionnera pas avec le shell Bourne standard):

git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 <(git branch -vv | grep origin) | awk '{print $1}' | xargs git branch -d

Cette chaîne obtient la liste des branches distantes et la transmet egrepvia l'entrée standard. Et filtre les branches qui ont une branche de suivi à distance (en utilisant git branch -vvet filtrant pour celles qui en ont origin) puis en obtenant la première colonne de cette sortie qui sera le nom de la branche. Enfin, en passant tous les noms de branche dans la commande delete branch.

Puisqu'il utilise l' -doption, il ne supprimera pas les branches qui n'ont pas été fusionnées dans la branche sur laquelle vous vous trouvez lorsque vous exécutez cette commande.

Souvenez-vous également que vous devrez d' git fetch --prune abord exécuter , sinon vous git branch -rverrez toujours les branches distantes.

Si vous souhaitez supprimer toutes les branches locales déjà fusionnées dans master, vous pouvez utiliser la commande suivante:

git branch --merged master | grep -v '^[ *]*master$' | xargs git branch -d

Plus d'infos .

Au milieu des informations présentées par git help fetch, il y a ce petit article:

 -p, --prune
        After fetching, remove any remote-tracking branches which no longer exist on the remote.

Alors, peut-être, git fetch -pc'est ce que vous cherchez?

EDIT: Ok, pour ceux qui débattent encore de cette réponse 3 ans après les faits, voici un peu plus d'informations sur les raisons pour lesquelles j'ai présenté cette réponse ...

Premièrement, le PO dit vouloir "supprimer également les succursales locales créées à partir de ces succursales distantes [qui ne sont plus sur la télécommande]". Ce n'est pas sans ambiguïté possible en git. Voici un exemple.

Disons que j'ai un dépôt sur un serveur central et qu'il a deux branches, appelées Aet B. Si je clone ce dépôt sur mon système local, mon clone aura des références locales (pas encore des branches réelles) appelées origin/Aet origin/B. Maintenant, disons que je fais ce qui suit:

git checkout -b A origin/A
git checkout -b Z origin/B
git checkout -b C <some hash>

Les faits pertinents ici sont que pour une raison quelconque, j'ai choisi de créer une branche sur mon référentiel local qui a un nom différent de son origine, et j'ai également une branche locale qui n'existe pas (encore) sur le référentiel d'origine.

Maintenant , disons que je supprimer à la fois les Aet les Bbranches sur la prise en pension à distance et mettre à jour mon repo local ( git fetchd' une certaine forme), ce qui provoque mes refs locales origin/Aet origin/Bà disparaître. Maintenant, mon a repo locale trois branches encore, A, Z, et C. Aucun d'entre eux n'a de branche correspondante sur le référentiel distant. Deux d'entre eux ont été "créés à partir de ... branches distantes", mais même si je sais qu'il y avait une branche appelée Bà l'origine, je n'ai aucun moyen de savoir qu'elle a Zété créée à partir deB, car il a été renommé dans le processus, probablement pour une bonne raison. Donc, vraiment, sans un processus externe d'enregistrement des métadonnées d'origine de la branche, ou un humain qui connaît l'histoire, il est impossible de dire laquelle des trois branches, le cas échéant, l'OP vise à supprimer. Sans certaines informations externes qui gitne sont pas automatiquement conservées pour vous, git fetch -psont à peu près aussi proches que possible, et toute méthode automatique pour tenter littéralement ce que l'OP a demandé risque de supprimer trop de branches ou de manquer certaines que l'OP aurait autrement veulent supprimer.

Il existe également d'autres scénarios, comme si je crée trois branches distinctes origin/Apour tester trois approches différentes de quelque chose, puis origin/Adisparaît. Maintenant, j'ai trois branches, qui ne peuvent évidemment pas toutes correspondre au nom, mais elles ont été créées à partir de origin/A, et donc une interprétation littérale de la question des PO nécessiterait de supprimer les trois. Cependant, cela peut ne pas être souhaitable, si vous pouviez même trouver un moyen fiable de les faire correspondre ...

Cela supprimera les branches locales pour lesquelles les branches de suivi à distance ont été élaguées. (Assurez-vous que vous êtes en mastersuccursale!)

git checkout master
git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -d

Détails:

• git branch -vv affiche "disparu" pour les succursales locales que la télécommande a été élaguée.

  mybranch abc1234 [origin/mybranch: gone] commit comments
  

• -dvérifiera s'il a été fusionné ( -Dle supprimera malgré tout)

  error: The branch 'mybranch' is not fully merged.
  

On peut configurer Git pour supprimer automatiquement les références aux branches distantes supprimées lors de la récupération:

git config --global fetch.prune true

Lors de l'appel git fetchou git pullaprès, les références aux branches distantes supprimées sont supprimées automatiquement.

Il existe un package NPM soigné qui le fait pour vous (et il devrait fonctionner sur plusieurs plates-formes).

Installez-le avec: npm install -g git-removed-branches

Et puis git removed-branchesvous montrera toutes les branches locales périmées et les git removed-branches --prunesupprimera.

Plus d'infos ici.

Solution Windows

Pour Microsoft Windows Powershell:

git checkout master; git remote update origin --prune; git branch -vv | Select-String -Pattern ": gone]" | % { $_.toString().Trim().Split(" ")[0]} | % {git branch -d $_}

Explication

git checkout master passe à la branche principale

git remote update origin --prune élagage des branches éloignées

git branch -vvobtient une sortie détaillée de toutes les branches ( référence git )

Select-String -Pattern ": gone]" obtient uniquement les enregistrements où ils ont été supprimés de la télécommande.

% { $_.toString().Split(" ")[0]} obtenir le nom de la succursale

% {git branch -d $_} supprime la branche

Il répertorie les branches locales dont la branche de suivi à distance est supprimée de la télécommande

$ git remote prune origin --dry-run

Si vous souhaitez déréférencer ces branches locales de locales qui ne sont pas suivies

$ git remote prune origin

Comme le note @tzacks ... il existe un package npm qui est pratique pour cela. Faites juste:

npx git-removed-branches --prune

(J'aurais commenté mais pas assez de réputation)

Si vous utilisez Windows et Powershell, vous pouvez utiliser ce qui suit pour supprimer toutes les branches locales qui ont été fusionnées dans la branche actuellement extraite:

git branch --merged | ? {$_[0] -ne '*'} | % {$_.trim()} | % {git branch -d $_}

Explication

• Répertorie la branche actuelle et les branches qui y ont été fusionnées
• Filtre la branche actuelle
• Nettoie tous les espaces de début ou de fin de la gitsortie pour chaque nom de branche restant
• Supprime les succursales locales fusionnées

Cela vaut la peine de s'exécuter git branch --mergedtout d'abord pour vous assurer qu'il ne supprimera que ce que vous attendez.

(Porté / automatisé depuis http://railsware.com/blog/2014/08/11/git-housekeeping-tutorial-clean-up-outdated-branches-in-local-and-remote-repositories/ .)

Une doublure encore plus courte et plus sûre:

git branch -d $(git branch --merged | cut -c 3- | grep -v master)

Assurez-vous de passer à la succursale qui n'est pas encore fusionnée, avant de l'exécuter. Parce que vous ne pouvez pas supprimer la branche sur laquelle vous êtes actuellement enregistré.

Je voulais quelque chose qui purgerait toutes les branches locales qui suivaient une branche distante, sur origin, où la branche distante a été supprimée ( gone). Je ne voulais pas supprimer les branches locales qui n'avaient jamais été configurées pour suivre une branche distante (c'est-à-dire mes branches de développement locales). En outre, je voulais un simple one-liner qui utilise simplement git, ou d'autres outils CLI simples, plutôt que d'écrire des scripts personnalisés. J'ai fini par utiliser un peu de grepet awkpour faire cette commande simple, puis je l'ai ajoutée comme alias dans mon ~/.gitconfig.

[alias]
  prune-branches = !git remote prune origin && git branch -vv | grep ': gone]' | awk '{print $1}' | xargs -r git branch -D

Voici une git config --global ...commande pour ajouter facilement ceci comme git prune-branches:

git config --global alias.prune-branches '!git remote prune origin && git branch -vv | grep '"'"': gone]'"'"' | awk '"'"'{print $1}'"'"' | xargs -r git branch -d'

REMARQUE: L'utilisation du -Ddrapeau git branchpeut être très dangereuse. Donc, dans la commande config ci-dessus, j'utilise l' -doption git branchplutôt que -D; J'utilise -Ddans ma config actuelle. J'utilise -Dparce que je ne veux pas entendre Git se plaindre des succursales non fusionnées, je veux juste qu'elles s'en aillent. Vous pouvez également souhaiter cette fonctionnalité. Si c'est le cas, utilisez simplement -Dplutôt -dqu'à la fin de cette commande de configuration.

Pour supprimer des branches distantes:

$git remote prune origin

Pour supprimer des branches locales déjà fusionnées:

$git branch -D $(git branch --merged)

Il ne semble pas y avoir de one-liner sûr, trop de cas de bord (comme une branche ayant "master" dans son nom, etc.). La plus sûre est ces étapes:

1. git branch -vv | grep 'gone]' > stale_branches.txt
2. afficher le fichier et supprimer les lignes des branches que vous souhaitez conserver (comme la branche principale!); vous n'avez pas besoin de modifier le contenu d'une ligne
3. awk '{print $1}' stale_branches.txt | xargs git branch -d

Sur la base des réponses ci-dessus, j'utilise cette doublure plus courte:

git remote prune origin | awk 'BEGIN{FS="origin/"};/pruned/{print $2}' | xargs -r git branch -d

De plus, si vous avez déjà taillé et avez des branches pendantes locales, cela les nettoiera:

git branch -vv | awk '/^ .*gone/{print $1}' | xargs -r git branch -d

Je ne sais pas comment faire tout cela en même temps, mais git git branch -d <branchname>supprimera une branche locale UNIQUEMENT si elle est complètement fusionnée. Notez le d minuscule.

git branch -D <branchname> (notez le D majuscule) supprimera une succursale locale quel que soit son statut fusionné.

Vous pouvez utiliser cette commande:

git branch --merged master | grep -v "\* master" | xargs -n 1 git branch -d

Git Clean: supprimer les branches déjà fusionnées, y compris la rupture de commande

Sur la base des réponses ci-dessus, je suis venu avec cette solution à une ligne:

git remote prune origin; git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 <(git branch -vv | grep origin) | awk '{print $1}' | xargs git branch -d

En utilisant une variante de la réponse de @ wisbucky, j'ai ajouté ce qui suit comme alias à mon ~/.gitconfigfichier:

pruneitgood = "!f() { \
    git remote prune origin; \
    git branch -vv | perl -nae 'system(qw(git branch -d), $F[0]) if $F[3] eq q{gone]}'; \
}; f"

Avec cela, un simple git pruneitgoodnettoiera les branches locales et distantes qui ne sont plus nécessaires après les fusions.

La version Powershell de git branch --merged master | grep -v '^[ *]*master$' | xargs git branch -d

git branch --merged master | %{ if($_ -notmatch '\*.*master'){ git branch -d "$($_.Trim())" }}

Cela supprimera toutes les branches locales qui ont été fusionnées dans master, pendant que vous êtes sur la branche master .

git checkout master commuter.

La variante de Schleis ne fonctionne pas pour moi (Ubuntu 12.04), alors laissez-moi vous proposer mes variantes (claires et brillantes :):

Variante 1 (je préférerais cette option):

git for-each-ref --format='%(refname:short) %(upstream)' refs/heads/ | awk '$2 !~/^refs\/remotes/' | xargs git branch -D 

Variante 2:

une. Essai à sec:

comm -23 <( git branch | grep -v "/" | grep -v "*" | sort ) <( git br -r | awk -F '/' '{print $2}' | sort ) | awk '{print "git branch -D " $1}'

b. Supprimer les branches:

comm -23 <( git branch | grep -v "/" | grep -v "*" | sort ) <( git br -r | awk -F '/' '{print $2}' | sort ) | xargs git branch -D

Voici une adaptation de la réponse de @ wisbucky pour les utilisateurs de Windows:

for /f "tokens=1" %i in ('git branch -vv ^| findstr ": gone]"') DO git branch %i -d

J'utilise posh-git et malheureusement PS n'aime pas le nu for, j'ai donc créé un script de commande plain 'ol nommé PruneOrphanBranches.cmd:

@ECHO OFF
for /f "tokens=1" %%i in ('git branch -vv ^| findstr ": gone]"') DO CALL :ProcessBranch %%i %1

GOTO :EOF

:ProcessBranch
IF /I "%2%"=="-d" (
    git branch %1 %2
) ELSE (
    CALL :OutputMessage %1
)
GOTO :EOF

:OutputMessage
ECHO Will delete branch [%1] 
GOTO :EOF

:EOF

Appelez-le sans paramètres pour afficher une liste, puis appelez-le avec "-d" pour effectuer la suppression réelle ou "-D" pour toutes les branches qui ne sont pas complètement fusionnées mais que vous souhaitez supprimer de toute façon.

Essayez ceci dans git bash, pour récupérer et tailler les références aux branches supprimées, puis tailler les branches locales qui suivaient les branches supprimées:

git fetch -p && git branch -d `git branch -vv | grep ': gone]' | awk '{print $1}' | xargs`

N'oubliez pas de retirer d'abord une branche qui ne sera pas supprimée, afin que cela ne bloque pas la suppression de la branche.

J'ai transformé la réponse acceptée en un script robuste. Vous le trouverez dans mon dépôt git-extensions .

$ git-prune --help
Remove old local branches that do not exist in <remote> any more.
With --test, only print which local branches would be deleted.
Usage: git-prune [-t|--test|-f|--force] <remote>

J'ai atteint cette page en cherchant la réponse pour "comment supprimer les succursales extraites localement qui n'ont plus de succursale en amont"

Je ne me souciais pas non plus de savoir si la succursale locale avait été fusionnée ou non, car le raccordement à git branch -dwill simplement avertir au lieu de supprimer les succursales locales non fusionnées.

git branch -a | grep origin | tr -s ' ' | cut -d '/' -f3 | egrep -v -f /dev/fd/0 <(git branch -a | grep -v origin) | grep branch_prefix_that_I_care_about | xargs git branch -d

# translation
# git branch -a | grep origin | tr -s ' ' | cut -d '/' -f3
## this finds all remote branch names minus the "remote/origin/" part
#
# <(git branch -a | grep -v origin)
## this finds all local branch names and redirects it into the previous command
#
# egrep -v -f /dev/fd/0 STUFF
## this is doing some weird magic that I'm grokking as "take the set difference from whatever was piped in"
#
#
# overall translation: (STUFF TO CONSIDER) | egrep magic <(STUFF TO REMOVE FROM CONSIDERATION) | do cool things with resulting stuff

À Powershell :

git branch -D (git branch --merged |% { $_.trim() } )

Voici ma solution:

git fetch -p
git branch -vv | grep ": gone" | awk '{print $1}' | xargs git branch -d

• -p consiste à supprimer toutes les références de suivi à distance qui n'existent plus sur la télécommande. La première étape supprimera donc les références aux branches distantes.

• -vv permet d'afficher sha1 et de valider la ligne d'objet pour chaque tête, ainsi que la relation avec la branche amont (le cas échéant). La deuxième étape obtiendra toutes les branches locales et la commande grep filtrera les branches qui ont été supprimées.

Supprimer toute branche qui n'est pas à jour avec le maître

git co master && git branch | sed s/\*/\ / | xargs git branch -d 2> /dev/null

Je suis sûr que git remote prune originc'est ce que vous voulez.

Vous pouvez l'exécuter git remote prune origin --dry-runpour voir ce qu'il ferait sans apporter de modifications.

Vous utilisez l'interface graphique? Procédure manuelle, mais rapide et facile.

$ git gui

Sélectionnez "Branche -> Supprimer". Vous pouvez sélectionner plusieurs branches avec ctrl-clic (fenêtres) et les supprimer toutes.