web-dev-qa-db-fra.com

Comment puis-je supprimer toutes les branches Git qui ont été fusionnées?

J'ai beaucoup de branches Git. Comment supprimer des branches déjà fusionnées? Existe-t-il un moyen simple de tous les supprimer au lieu de les supprimer un par un?

gitgithubversion-controlbranchfeature-branch
1499
Nyambaa

METTRE À JOUR:

Vous pouvez ajouter d'autres branches à exclure, telles que master et dev, si votre flux de travail les a comme ancêtre possible. D'habitude, je me sépare d'une balise "sprint-start" et maître, dev et qa ne sont pas des ancêtres.

Commencez par répertorier toutes les branches fusionnées dans Remote.

git branch --merged

Vous pouvez voir quelques branches que vous ne voulez pas supprimer. nous pouvons ajouter quelques arguments pour ignorer des branches importantes que nous ne souhaitons pas supprimer comme master ou develop. La commande suivante va ignorer la branche master et tout ce qui contient dev.

git branch --merged| egrep -v "(^\*|master|dev)"

Si vous voulez ignorer, vous pouvez l'ajouter à la commande egrep comme suit. La branche skip_branch_name ne sera pas supprimée. 

git branch --merged| egrep -v "(^\*|master|dev|skip_branch_name)"

Pour supprimer toutes les branches locales déjà fusionnées dans la branche extraite:

git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d

Vous pouvez voir que master et dev sont exclus s'ils sont des ancêtres.

Vous pouvez supprimer une branche locale fusionnée avec:

git branch -d branchname

Si ce n'est pas fusionné, utilisez:

git branch -D branchname

Pour le supprimer de la télécommande dans les anciennes versions de Git, utilisez:

git Push Origin :branchname

Dans les versions les plus récentes de Git, utilisez:

git Push --delete Origin branchname

Une fois que vous avez supprimé la branche de la télécommande, vous pouvez ajuster pour supprimer les branches de suivi à distance avec:

git remote Prune Origin

ou Taillez les branches individuelles de suivi à distance, comme le suggère l'autre réponse, avec:

git branch -dr branchname

J'espère que cela t'aides.

2523
Adam Dymitruk

Pour supprimer toutes les branches de la télécommande déjà fusionnées:

git branch -r --merged | grep -v master | sed 's/Origin\//:/' | xargs -n 1 git Push Origin

Dans les versions les plus récentes de Git

git branch -r --merged | grep -v master | sed 's/Origin\///' | xargs -n 1 git Push --delete Origin
365
kuboon

Prolongeant un peu la réponse d'Adam:

Ajoutez ceci à votre configuration Git en exécutant git config -e --global

[alias]
    cleanup = "!git branch --merged | grep  -v '\\*\\|master\\|develop' | xargs -n 1 git branch -d"

Et vous pouvez ensuite supprimer toutes les branches fusionnées locales en effectuant un simple git cleanup.

150
real_ate

Cela fonctionne également pour supprimer toutes les branches fusionnées sauf la branche principale.

git branch --merged | grep -v '^* master$' | grep -v '^  master$' | xargs git branch -d
74
Ismael Abreu

Vous voudrez exclure les branches master & develop de ces commandes.

Local git clair: 

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

Git clair à distance: 

git branch -r --merged | grep -v '\*\|master\|develop' | sed 's/Origin\///' | xargs -n 1 git Push --delete Origin

Synchronisez le registre local des branches distantes: 

git fetch -p
66
Guido Bouman

Pour ceux d'entre vous qui travaillent sous Windows et préfèrent les scripts PowerShell, en voici un qui supprime les branches fusionnées locales:

function Remove-MergedBranches
{
  git branch --merged |
    ForEach-Object { $_.Trim() } |
    Where-Object {$_ -NotMatch "^\*"} |
    Where-Object {-not ( $_ -Like "*master" )} |
    ForEach-Object { git branch -d $_ }
}
42
Klas Mellbourn

Git Sweep fait un excellent travail dans ce domaine.

20
paul

Avec Git version 2.5.0:

git branch -d `git branch --merged`
14
drautb

J'ai utilisé la réponse d'Adam pendant des années maintenant. Cela dit, il y a des cas où cela ne s'est pas passé comme prévu:

  1. les branches qui contenaient le mot "maître" ont été ignorées, par ex. "notmaster" ou "masterful", plutôt que seulement la branche master
  2. les branches qui contenaient le mot "dev" ont été ignorées, par ex. "dev-test", plutôt que seulement la branche dev
  3. suppression des branches accessibles depuis le HEAD de la branche current / (c'est-à-dire, pas nécessairement master)
  4. à l'état détaché HEAD, en supprimant tous les branches accessibles depuis le commit en cours

1 & 2 étaient simples à aborder, avec juste un changement de regex. 3 dépend du contexte de ce que vous voulez (c’est-à-dire que supprimer uniquement les branches qui n’ont pas été fusionnées dans le maître ou contre votre branche actuelle) . 4 a le potentiel d’être désastreux (bien que récupérable avec git reflog), si vous l'avez involontairement exécuté dans l'état HEAD détaché.

Enfin, je voulais que tout cela soit dans une ligne qui ne nécessite pas de script séparé (Bash | Ruby | Python).

TL; DR

Créez un "pseudo" git qui accepte un drapeau -f optionnel:

git config --global alias.sweep '!f(){ git branch --merged $([[ $1 != "-f" ]] \
&& git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" \
| xargs git branch -d; }; f'

et l'invoquer avec:

git sweep

ou:

git sweep -f

La réponse longue et détaillée

Il était plus facile pour moi de créer un exemple de dépôt Git avec quelques branches et de nous engager à tester le comportement correct:

Créer un nouveau dépôt Git avec un seul commit

mkdir sweep-test && cd sweep-test && git init
echo "hello" > hello
git add . && git commit -am "initial commit"

Créer de nouvelles branches

git branch foo && git branch bar && git branch develop && git branch notmaster && git branch masterful
git branch --list

  bar
  develop
  foo
* master
  masterful
  notmaster

Comportement souhaité: sélectionnez toutes les branches fusionnées à l'exception de: master, develop ou current

La regex originale manque les branches "masterful" et "notmaster":

git checkout foo
git branch --merged | egrep -v "(^\*|master|dev)"

  bar

Avec la regex mise à jour (qui exclut maintenant "develop" plutôt que "dev"):

git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

bar
masterful
notmaster

Basculez sur la branche foo, faites un nouveau commit, puis vérifiez une nouvelle branche, foobar, basée sur foo:

echo "foo" > foo
git add . && git commit -am "foo"
git checkout -b foobar
echo "foobar" > foobar
git add . && git commit -am "foobar"

Ma branche actuelle est foobar, et si je relance la commande ci-dessus pour répertorier les branches que je veux supprimer, la branche "foo" est incluse même si elle n'a pas été fusionnée dans le maître:

git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  foo
  masterful
  notmaster

Cependant, si j'exécute la même commande sur le maître, la branche "foo" n'est pas incluse:

git checkout master && git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

Et ceci est simplement dû au fait que git branch --merged est par défaut le HEAD de la branche actuelle, sauf indication contraire. Du moins pour mon flux de travail, je ne souhaite pas supprimer les branches locales à moins qu'elles aient été fusionnées avec le maître. Je préfère donc la variante suivante:

git checkout foobar
git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

Détaché HEAD état

S'appuyer sur le comportement par défaut de git branch --merged a des conséquences encore plus importantes dans l'état HEAD détaché:

git checkout foobar
git checkout HEAD~0
git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  foo
  foobar
  masterful
  notmaster

Cela aurait supprimé la branche sur laquelle je venais juste de parler, "foobar" avec "foo", ce qui n'est certainement pas le résultat souhaité . Avec notre nouvelle commande, cependant:

git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

Une ligne, y compris la suppression réelle

git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" | xargs git branch -d

Tous enveloppés dans un alias git "sweep":

git config --global alias.sweep '!f(){ git branch --merged $([[ $1 != "-f" ]] \
&& git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" \
| xargs git branch -d; }; f'

L'alias accepte un indicateur optionnel -f. Le comportement par défaut consiste à ne supprimer que les branches fusionnées dans le maître, mais l'indicateur -f supprime les branches fusionnées dans la branche actuelle.

git sweep

Deleted branch bar (was 9a56952).
Deleted branch masterful (was 9a56952).
Deleted branch notmaster (was 9a56952).

git sweep -f

Deleted branch foo (was 2cea1ab).
13
eddies

Vous pouvez ajouter le commit à l’option --merged . Ainsi, vous ne pourrez supprimer que les branches fusionnées dans l’origine/maître

La commande suivante supprimera les branches fusionnées de votre origine.

git branch -r --merged Origin/master | grep -v "^.*master" | sed s:Origin/:: |xargs -n 1 git Push Origin --delete

Vous pouvez tester quelles branches seront supprimées en remplaçant le git Push Origin --delete par echo

git branch -r --merged Origin/master | grep -v "^.*master" | sed s:Origin/:: |xargs -n 1 echo
13
Jörn Reimerdes

J'utilise le script Ruby suivant pour supprimer mes branches locales et distantes déjà fusionnées. Si je le fais pour un référentiel avec plusieurs télécommandes et que je souhaite uniquement en supprimer, j'ajoute simplement une instruction select à la liste des télécommandes pour obtenir uniquement les télécommandes que je souhaite.

#!/usr/bin/env Ruby

current_branch = `git symbolic-ref --short HEAD`.chomp
if current_branch != "master"
  if $?.exitstatus == 0
    puts "WARNING: You are on branch #{current_branch}, NOT master."
  else
    puts "WARNING: You are not on a branch"
  end
  puts
end

puts "Fetching merged branches..."
remote_branches= `git branch -r --merged`.
  split("\n").
  map(&:strip).
  reject {|b| b =~ /\/(#{current_branch}|master)/}

local_branches= `git branch --merged`.
  gsub(/^\* /, '').
  split("\n").
  map(&:strip).
  reject {|b| b =~ /(#{current_branch}|master)/}

if remote_branches.empty? && local_branches.empty?
  puts "No existing branches have been merged into #{current_branch}."
else
  puts "This will remove the following branches:"
  puts remote_branches.join("\n")
  puts local_branches.join("\n")
  puts "Proceed?"
  if gets =~ /^y/i
    remote_branches.each do |b|
      remote, branch = b.split(/\//)
      `git Push #{remote} :#{branch}`
    end

    # Remove local branches
    `git branch -d #{local_branches.join(' ')}`
  else
    puts "No branches removed."
  end
end
11
mmrobins

Comment supprimer des branches fusionnées dans la console PowerShell

git branch --merged | %{git branch -d $_.Trim()}

Voir GitHub pour Windows

8
Konstantin Tarkus

Aucune commande dans Git ne le fera automatiquement pour vous. Mais vous pouvez écrire un script qui utilise les commandes Git pour vous donner ce dont vous avez besoin. Cela peut être fait de différentes manières en fonction du modèle de branchement que vous utilisez. 

Si vous avez besoin de savoir si une branche a été fusionnée dans le maître, la commande suivante ne produira aucun résultat si myTopicBranch a été fusionné (c'est-à-dire que vous pouvez le supprimer).

$ git rev-list master | grep $(git rev-parse myTopicBranch)

Vous pouvez utiliser la commande Git branch et analyser toutes les branches de Bash et effectuer une boucle for sur toutes les branches. Dans cette boucle, vous vérifiez avec la commande ci-dessus si vous pouvez supprimer la branche ou non.

8
ralphtheninja

la réponse de kuboon n'a pas été supprimée lors de la suppression des branches dont le nom principal est le mot maître .

git branch -r --merged | grep -v "Origin/master$" | sed 's/\s*Origin\///' | xargs -n 1 git Push --delete Origin

Bien sûr, cela ne supprime pas la branche "maître" elle-même :)

8
Paras

git branch --merged | grep -Ev '^(. master|\*)' | xargs -n 1 git branch -d supprimera toutes les branches locales, à l'exception de la branche extraite actuelle et/ou de master.

Voici un article utile pour ceux qui cherchent à comprendre ces commandes: Git Clean: Supprimer les branches déjà fusionnées, par Steven Harman .

6
styger

Vous pouvez utiliser git-del-brtool .

git-del-br -a

Vous pouvez l'installer via pip en utilisant

pip install git-del-br

P.S: Je suis l'auteur de l'outil. Toutes les suggestions/commentaires sont les bienvenus. 

5
tusharmakkar08

Version alias de Réponse actualisée d'Adam :

[alias]
    branch-cleanup = "!git branch --merged | egrep -v \"(^\\*|master|dev)\" | xargs git branch -d #"

Voir aussi cette réponse pour obtenir des conseils utiles sur la manière d’échapper aux alias complexes.

5
Eliot

Si vous souhaitez supprimer toutes les branches locales déjà fusionnées dans la branche sur laquelle vous vous trouvez, j'ai créé une commande sûre pour le faire, basée sur les réponses précédentes:

git branch --merged | grep -v \* | grep -v '^\s*master$' | xargs -t -n 1 git branch -d

Cette commande n'affectera pas votre branche actuelle ni votre branche principale. Il vous dira également ce qu'il fait avant de le faire, en utilisant le drapeau -t de xargs.

4
chrismendis

La requête ci-dessous fonctionne pour moi 

for branch in  `git branch -r --merged | grep -v '\*\|master\|develop'|awk 'NR > 0 {print$1}'|awk '{gsub(/Origin\//, "")}1'`;do git Push Origin --delete $branch; done

et cela filtrera toute branche donnée du tuyau grep.

Fonctionne bien sur le clone http, mais pas très bien pour la connexion SSH.

4
user1460965

Sur la base de certaines de ces réponses, j'ai créé mon propre script Bash pour le faire aussi !

Il utilise git branch --merged et git branch -d pour supprimer les branches qui ont été fusionnées et vous invite à chacune d’entre elles avant de les supprimer.

merged_branches(){
  local current_branch=$(git rev-parse --abbrev-ref HEAD)
  for branch in $(git branch --merged | cut -c3-)
    do
      echo "Branch $branch is already merged into $current_branch."
      echo "Would you like to delete it? [Y]es/[N]o "
      read REPLY
      if [[ $REPLY =~ ^[Yy] ]]; then
        git branch -d $branch
      fi
  done
}
4
earlonrails

J'utilise un système de nommage git-flow esque, donc cela fonctionne très bien pour moi:

git branch --merged | grep -e "^\s\+\(fix\|feature\)/" | xargs git branch -d

Fondamentalement, il recherche les validations fusionnées commençant par la chaîne fix/ ou feature/.

4
Chad M

Ecrivez un script dans lequel Git vérifie toutes les branches fusionnées pour être maîtrisées.

Alors faites git checkout master.

Enfin, supprimez les branches fusionnées.

for k in $(git branch -ra --merged | egrep -v "(^\*|master)"); do
  branchnew=$(echo $k | sed -e "s/Origin\///" | sed -e "s/remotes\///")
  echo branch-name: $branchnew
  git checkout $branchnew
done

git checkout master

for k in $(git branch -ra --merged | egrep -v "(^\*|master)"); do
  branchnew=$(echo $k | sed -e "s/Origin\///" | sed -e "s/remotes\///")
  echo branch-name: $branchnew
  git Push Origin --delete $branchnew
done
3
Komu

La solution acceptée est plutôt bonne, mais le seul problème est qu'elle supprime également les branches locales non encore fusionnées dans une télécommande.

Si vous regardez la sortie de vous verrez quelque chose comme 

$ git branch --merged master -v
  api_doc                  3a05427 [gone] Start of describing the Java API
  bla                      52e080a Update wording.
  branch-1.0               32f1a72 [maven-release-plugin] prepare release 1.0.1
  initial_proposal         6e59fb0 [gone] Original proposal, converted to AsciiDoc.
  issue_248                be2ba3c Skip unit-for-type checking. This needs more work. (#254)
  master                   be2ba3c Skip unit-for-type checking. This needs more work. (#254)

Les branches bla et issue_248 sont des branches locales qui seraient supprimées en mode silencieux.

Mais vous pouvez également voir le Word [gone], qui indique les branches qui ont été poussées vers une télécommande (qui a maintenant disparu) et indique donc que les branches peuvent être supprimées.

La réponse originale peut donc être changée en (divisée en multiligne pour une longueur de ligne plus courte)

git branch --merged master -v | \
     grep  "\\[gone\\]" | \
     sed -e 's/^..//' -e 's/\S* .*//' | \
      xargs git branch -d

pour protéger les branches non encore fusionnées . De plus, le grepping pour que le maître le protège n'est pas nécessaire, car il possède une télécommande à l'origine et ne s'affiche pas.

2
Heiko Rupp

Pour Windows, vous pouvez installer Cygwin et supprimer toutes les branches distantes à l'aide de la commande suivante:

git branch -r --merged | "C:\cygwin64\bin\grep.exe" -v master | "C:\cygwin64\bin\sed.exe" 's/Origin\///' | "C:\cygwin64\bin\xargs.exe" -n 1 git Push --delete Origin
1
Seyed Morteza Mousavi

Pour moi, git branch --merged ne montre pas les branches qui ont été fusionnées via GitHub PR. Je ne suis pas sûr des raisons, mais j'utilise la ligne suivante pour supprimer toutes les branches locales qui n'ont pas de branche de suivi à distance:

diff <(git branch --format "%(refname:short)") <(git branch -r | grep -v HEAD | cut -d/ -f2-) | grep '<' | cut -c 3- | xargs git branch -D

Explication:

  • git branch --format "%(refname:short)" donne une liste des branches locales
  • git branch -r | grep -v HEAD | cut -d/ -f2- donne une liste des branches distantes, en filtrant HEAD
  • diff <(...) <(...) donne un diff de sortie de deux commandes entre parenthèses
  • grep '<' filtre les branches présentes dans la première liste, mais pas dans la seconde
  • cut -c 3- donne une ligne à partir du 3ème caractère, supprimant ainsi le préfixe <
  • xargs git branch -D exécute git branch -D pour chaque nom de branche

Vous pouvez également éviter grep -v '<' comme ceci:

diff --old-line-format="%L" --new-line-format="" --unchanged-line-format="" <(git branch --format "%(refname:short)") <(git branch -r | grep -v HEAD | cut -d/ -f2-) | xargs git branch -D
1
folex

Sous Windows avec git bash installed, egrep -v ne fonctionnera pas

git branch --merged | grep -E -v "(master|test|dev)" | xargs git branch -d

où grep -E -v est équivalent à egrep -v

Utilisez -d pour supprimer déjà des branches merged ou -D pour supprimer unmerged branches

1
DevWL

Pour éviter d'exécuter accidentellement la commande depuis une autre branche que master, j'utilise le script bash suivant. Sinon, exécuter git branch --merged | grep -v "\*" | xargs -n 1 git branch -d à partir d'une branche qui a été fusionnée hors maître pourrait supprimer la branche principale.

#!/bin/bash

branch_name="$(git symbolic-ref HEAD 2>/dev/null)" ||
branch_name="(unnamed branch)"     # detached HEAD
branch_name=${branch_name##refs/heads/}

if [[ $branch_name == 'master' ]]; then
   read -r -p "Are you sure? [y/N] " response
   if [[ $response =~ ^([yY][eE][sS]|[yY])$ ]]; then
       git branch --merged | grep -v "\*" | xargs -n 1 git branch -d
   fi
else
   echo "Refusing to delete branches that are not merged into '$branch_name'. Checkout master first."
fi
1
Robert Kajic

À partir de 2018.07

Ajoutez ceci à la section [alias] de votre ~/.gitconfig:

sweep = !"f() { git branch --merged | egrep -v \"(^\\*|master|dev)\" || true | xargs git branch -d; }; f"

Maintenant, vous pouvez simplement appeler git sweep pour effectuer le nettoyage nécessaire.

1
sorin

Pour supprimer les branches locales fusionnées dans la branche principale, j'utilise l'alias suivant (git config -e --global):

cleanup = "!git branch --merged master | grep -v '^*\\|master' | xargs -n 1 git branch -D"

J'utilise git branch -D pour éviter les messages error: The branch 'some-branch' is not fully merged. alors que mon paiement actuel est différent de celui de la branche principale.

0
dgt

Script Python compatible avec Windoze (car git-sweep est étouffé dans le référentiel Wesnoth):

#!/usr/bin/env python
# Remove merged git branches. Cross-platform way to execute:
#
#   git branch --merged | grep -v master | xargs git branch -d
#
# Requires gitapi - https://bitbucket.org/haard/gitapi
# License: Public Domain

import gitapi

repo = gitapi.Repo('.')
output = repo.git_command('branch', '--merged').strip()
for branch in output.split('\n'):
  branch = branch.strip()
  if branch.strip(' *') != 'master':
    print(repo.git_command('branch', '-d', branch).strip())

https://Gist.github.com/techtonik/b3f0d4b9a56dbacb3afc ​​

0
anatoly techtonik

Si vous utilisez un modèle de branche tel que HubFlow ou GitFlow, vous pouvez utiliser cette commande pour supprimer les branches de fonctionnalité fusionnées:

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

0
bedrin

Voici le moyen de supprimer la branche git

git branch -D BranchName
0
Hasib Kamal

Ma contribution au script Bash est basée approximativement sur la réponse de mmrobin .

Il faut quelques paramètres utiles pour spécifier les inclus et les exclure, ou pour examiner/supprimer uniquement les branches locales ou distantes au lieu des deux.

#!/bin/bash

# exclude branches regex, configure as "(branch1|branch2|etc)$"
excludes_default="(master|next|ag/doc-updates)$"
excludes="__NOTHING__"
includes=
merged="--merged"
local=1
remote=1

while [ $# -gt 0 ]; do
  case "$1" in
  -i) shift; includes="$includes $1" ;;
  -e) shift; excludes="$1" ;;
  --no-local) local=0 ;;
  --no-remote) remote=0 ;;
  --all) merged= ;;
  *) echo "Unknown argument $1"; exit 1 ;;
  esac
  shift   # next option
done

if [ "$includes" == "" ]; then
  includes=".*"
else
  includes="($(echo $includes | sed -e 's/ /|/g'))"
fi

current_branch=$(git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\1/')
if [ "$current_branch" != "master" ]; then
  echo "WARNING: You are on branch $current_branch, NOT master."
fi
echo -e "Fetching branches...\n"

git remote update --Prune
remote_branches=$(git branch -r $merged | grep -v "/$current_branch$" | grep -v -E "$excludes" | grep -v -E "$excludes_default" | grep -E "$includes")
local_branches=$(git branch $merged | grep -v "$current_branch$" | grep -v -E "$excludes" | grep -v -E "$excludes_default" | grep -E "$includes")
if [ -z "$remote_branches" ] && [ -z "$local_branches" ]; then
  echo "No existing branches have been merged into $current_branch."
else
  echo "This will remove the following branches:"
  if [ "$remote" == 1 -a -n "$remote_branches" ]; then
    echo "$remote_branches"
  fi
  if [ "$local" == 1 -a -n "$local_branches" ]; then
    echo "$local_branches"
  fi
  read -p "Continue? (y/n): " -n 1 choice
  echo
  if [ "$choice" == "y" ] || [ "$choice" == "Y" ]; then
    if [ "$remote" == 1 ]; then
      remotes=$(git remote)
      # Remove remote branches
      for remote in $remotes
      do
        branches=$(echo "$remote_branches" | grep "$remote/" | sed "s/$remote\/\(.*\)/:\1 /g" | tr -d '\n')
        git Push $remote $branches
      done
    fi

    if [ "$local" == 1 ]; then
      # Remove local branches
      locals=$(echo "$local_branches" | sed 's/Origin\///g' | tr -d '\n')
      if [ -z "$locals" ]; then
        echo "No branches removed."
      else
        git branch -d $(echo "$locals" | tr -d '\n')
      fi
    fi
  fi
fi
0
Raman

Si vous êtes sous Windows, vous pouvez utiliser Windows Powershell avec Out-GridView (malheureusement, il est déjà parti dans Powershell Core pour le moment) pour obtenir une belle liste de branches et sélectionner avec la souris celle que vous souhaitez supprimer:

git branch --merged | Out-GridView -PassThru | % { git branch -d $_.Trim() }

 enter image description here après avoir cliqué sur OK, Powershell passera ces noms de branches à la commande git branch -d et les supprimera  enter image description here

0
Mariusz Pawelski
for b in $(git branch -a | grep -v "\(master\|remotes\)"); do \ 
git branch -D $b; done && git fetch -p
0
030

git-delete-merged-branches du git-extras repo.

https://github.com/tj/git-extras/blob/master/Commands.md#git-delete-merged-branches

0
holys

Disons que j'ai une télécommande nommée en amont et une origine (style GitHub, ma fourchette est Origine, en amont est en amont).

Je ne veux supprimer AUCUN maître, HEAD ou quoi que ce soit de l'amont. Je ne veux pas non plus supprimer la branche develop, car c’est notre branche commune à partir de laquelle nous créons des PR.

Répertorie toutes les branches distantes, filtrées par celles qui ont été fusionnées:

git branch -r

Supprimez de cette liste les lignes contenant des mots que je sais être dans les noms de branche que je ne souhaite pas supprimer:

sed '/develop\|master\|HEAD\|upstream/d'

Supprimez le nom distant du nom de référence (Origin/une branche devient une branche):

sed 's/.*\///'

Utilisez xargs pour appeler un one-liner:

xargs git Push --delete Origin

Pipe le tout ensemble vous obtenez:

git branch -r --merged | sed '/develop\|master\|HEAD\|upstream/d' |  sed 's/.*\///' | xargs git Push --delete Origin

Cela ne me laissera que quelques branches sur lesquelles j'ai travaillé, mais qui n'ont pas été fusionnées. Vous pouvez ensuite les supprimer un par un car il ne devrait pas y en avoir trop.

Trouvez les branches que vous ne voulez plus:

git branch -ar

Supposons que vous trouviez branche1, branche2 et branche3 que vous souhaitez supprimer:

git Push --delete Origin branch1 branch2 branch3
0
miigotu
$ git config --global alias.cleanup
'!git branch --merged Origin/master | egrep -v "(^\*|master|staging|dev)" | xargs git branch -d'

(divisé en plusieurs lignes pour plus de lisibilité)

L'appel à "git cleanup" supprimera les branches locales déjà fusionnées dans Origin/master. Il ignore master, staging et dev parce que nous ne voulons pas les supprimer dans des circonstances normales.

Pour résumer, voici ce qu'il fait:

  1. git config --global alias.cleanup
    • Cela crée un alias global appelé "nettoyage" (sur tous vos dépôts).
  2. Le ! au début de la commande indique que nous utiliserons des commandes non git dans le cadre de cet alias. Nous devons donc exécuter les commandes bash ici.
  3. git branch --merged Origin/master
    • Cette commande retourne la liste des noms de branches déjà fusionnés dans Origin/master
  4. egrep -v "(^\*|master|staging|dev)"
    • Cela supprime les branches master, staging et dev de la liste des branches déjà fusionnées. Nous ne voulons pas supprimer ces branches car elles ne sont pas des fonctionnalités.
  5. xargs git branch -d
    • Cela exécutera la commande git branch -d xxxxx pour chacune des branches non fusionnées. Cela supprime les branches locales une par une.
0
Joe Phillips

J'utilise la méthode suivante pour supprimer les branches locales et distantes fusionnées dans un cmd. 

J'ai les éléments suivants dans mon fichier bashrc:

function rmb {
  current_branch=$(git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\1/')
  if [ "$current_branch" != "master" ]; then
    echo "WARNING: You are on branch $current_branch, NOT master."
  fi
  echo "Fetching merged branches..."
  git remote Prune Origin
  remote_branches=$(git branch -r --merged | grep -v '/master$' | grep -v "/$current_branch$")
  local_branches=$(git branch --merged | grep -v 'master$' | grep -v "$current_branch$")
  if [ -z "$remote_branches" ] && [ -z "$local_branches" ]; then
    echo "No existing branches have been merged into $current_branch."
  else
    echo "This will remove the following branches:"
    if [ -n "$remote_branches" ]; then
      echo "$remote_branches"
    fi
    if [ -n "$local_branches" ]; then
      echo "$local_branches"
    fi
    read -p "Continue? (y/n): " -n 1 choice
    echo
    if [ "$choice" == "y" ] || [ "$choice" == "Y" ]; then
      # Remove remote branches
      git Push Origin `git branch -r --merged | grep -v '/master$' | grep -v "/$current_branch$" | sed 's/Origin\//:/g' | tr -d '\n'`
      # Remove local branches
      git branch -d `git branch --merged | grep -v 'master$' | grep -v "$current_branch$" | sed 's/Origin\///g' | tr -d '\n'`
    else
      echo "No branches removed."
    fi
  fi
}

original source

Cela ne supprime pas la branche principale, mais supprime les branches locales et distantes fusionnées. Une fois que vous avez ceci dans votre fichier rc, exécutez simplement rmb, vous verrez une perte de branches fusionnées qui seront nettoyées et une confirmation de l’action sera demandée. Vous pouvez modifier le code pour ne pas demander de confirmation également, mais il est probablement bon de le conserver.

0
Prashant

Si vous souhaitez supprimer les branches locales qui ont été fusionnées ainsi que leurs télécommandes, voici le modèle que je préfère:

git branch --merged | xargs -I_br -- sh -c 'git branch -d _br; git Push Origin --delete _br'
0
Ikar Pohorský