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

Mise à JOUR:

Vous pouvez ajouter d'autres branches d'exclure comme maître et dev si votre flux de travail a ceux comme un possible ancêtre. Habituellement, je branche en dehors d'un "sprint-start" et la balise de maître, de développement et d'assurance qualité ne sont pas les ancêtres.

D'abord, la liste de toutes les branches qui ont été fusionnées dans la distance.

git branch --merged

Vous pouvez voir quelques branches que vous ne souhaitez pas supprimer. nous pouvons ajouter quelques arguments pour ignorer les branches importantes que nous ne voulons pas supprimer comme maître ou à développer. La commande suivante permet de sauter la branche master et tout ce qui est dev en elle.

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

Si vous voulez sauter, vous pouvez l'ajouter à la commande egrep comme suit. La direction de la skip_branch_name ne seront pas supprimés.

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

Pour supprimer toutes les branches locales qui sont déjà fusionné dans l'extrait de la direction de la

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

Vous pouvez voir que le maître et les dev sont exclus dans le cas où ils sont un ancêtre.

---

Vous pouvez supprimer une fusion de la branche locale avec:

git branch -d branchname

Si ce n'est pas fusionné, utilisez:

git branch -D branchname

Pour le supprimer de la distance dans les anciennes versions de Git utilisation:

git push origin :branchname

Dans les versions plus récentes de Git utilisation:

git push --delete origin branchname

Une fois que vous supprimez la branche à partir de la télécommande, vous pouvez le tailler pour se débarrasser de suivi à distance des branches avec:

git remote prune origin

ou d'élaguer individuelle de suivi à distance des branches, comme l'autre réponse suggère, avec:

git branch -dr branchname

Espère que cette aide.

Juste s'étendant Adam répondre un peu:

Ajouter à votre configuration Git en cours d'exécution git config -e --global

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

Et puis vous pouvez supprimer tous les locaux fusionné les branches faisant un simple git cleanup.

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

Git Local clair:

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

Distant git clair:

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

De synchronisation de registre local des branches distantes:

git fetch -p

J'ai utilisé Adam de réponse depuis plusieurs années maintenant. Cela dit, qu'il y a certains cas où il n'était pas de se comporter comme je m'y attendais:

1. branches qui contenues le mot "maître" a été ignoré, par exemple, "notmaster" ou "maître", plutôt que seulement la branche master
2. branches qui contenues le mot "dev" ont été ignorés, par exemple, les "dev-test", plutôt que seulement la branche dev
3. de supprimer les branches qui sont accessibles à partir de la TÊTE de la actuel branche (c'est pas forcément maître)
4. dans décollement de la TÊTE de l'état, la suppression de chaque branche accessible depuis le commit courant

1 & 2 ont été faciles à gérer, avec juste un changement de l'expression rationnelle.
3 dépend du contexte de ce que vous voulez (c'est à dire seulement supprimer les branches qui n'ont pas été fusionnés en master ou contre votre branche courante).
4 a le potentiel d'être catastrophique (même si recouvrable avec git reflog), si vous involontairement couru ce dans décollement de la TÊTE de l'état.

Enfin, je voulais que ce à tous dans un one-liner qui n'a pas besoin d'un (Bash|Ruby|Python) script.

TL;DR

Créer un alias git "balayage" qui accepte une option -f drapeau:

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

et à l'appeler avec:

git sweep

ou:

git sweep -f

La longue réponse détaillée

Il était plus facile pour moi de créer un exemple de repo git avec quelques branches et s'engage à tester le comportement correct:

Créer un nouveau repo 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 tous fusionné les branches à l'exception de: maître, de développer ou d' actuel

L'original regex manque les branches "magistral" et "notmaster" :

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

  bar

Avec la mise à jour de regex (ce qui exclut désormais les "développer" plutôt que de "dev"):

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

bar
masterful
notmaster

Passer à la branche foo, faire un nouveau commit, puis commander une nouvelle branche, foobar, basé 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 courante est foobar, et si je ré-exécuter la commande ci-dessus pour la liste des branches, je veux supprimer, la branche "foo" est inclus, même s'il n'a pas été fusionnés en master:

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

  bar
  foo
  masterful
  notmaster

Cependant, si je lance la même commande sur le master, la branche "toto" n'est pas inclus:

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

  bar
  masterful
  notmaster

Et c'est tout simplement parce git branch --merged par défaut à la TÊTE de la branche courante, sauf indication contraire. Au moins pour moi, je ne veux pas supprimer les branches locales, sauf s'ils ont été fusionnés à maîtriser, donc je préfère la variante suivante:

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

  bar
  masterful
  notmaster

Détaché de la TÊTE de l'état

En s'appuyant sur le comportement par défaut de git branch --merged a même plus des conséquences importantes dans décollement de la TÊTE de l'état:

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, j'étais juste sur, "foobar" avec "toto", qui est presque certainement pas le résultat souhaité.
Avec la version révisée de notre 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

Tout enveloppé dans un git alias "balayage":

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

L'alias accepte une option -f drapeau. Le comportement par défaut est de seulement supprimer les branches qui ont été fusionnées en maître, mais le -f drapeau de supprimer les branches qui ont été fusionnées dans la branche courante.

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).

À l'aide de Git version 2.5.0:

git branch -d `git branch --merged`

J'utilise la suite Ruby script pour supprimer mon déjà fusionné local et à distance des branches. Si je fais ça pour un espace de stockage avec plusieurs télécommandes et ne souhaitez supprimer à partir de l'un, je viens d'ajouter une instruction select pour les télécommandes de la liste pour obtenir uniquement les télécommandes que je veux.

#!/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

kuboon la réponse de manquer de supprimer les branches qui ont le mot de maître dans le nom de la branche.
La suite s'améliore sur sa réponse:

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

Bien sûr, il ne supprime pas le "maître" de la branche elle-même 🙂

git branch --merged | grep -Ev '^(. master|\*)' | xargs -n 1 git branch -d va supprimer toutes les branches, sauf le courant extrait de la branche et/ou master.

Voici un article utile pour ceux qui cherchent à comprendre ces commandes: Git Clean: Supprime Déjà Fusionné les Branches, par Steven Harman.

Alias version de Adam de la mise à jour de réponse:

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

Aussi, voir cette réponse pour des conseils pratiques sur la fuite des complexes alias.

Essayez la commande suivante:

git branch -d $(git branch --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

En utilisant git rev-parse obtiendrez l'actuel nom de la branche afin de les exclure. Si vous avez l'erreur, cela signifie qu'il y a pas de branches à supprimer.

À faire de même avec les branches distantes (changement origin avec votre nom à distance), essayez:

git push origin -vd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD) | cut -d/-f2)

^{Dans le cas ou vous avez plusieurs télécommandes, ajouter grep origin | avant cut pour filtrer uniquement les origin.}

Si la commande échoue, essayez de supprimer la fusion de distance de suivi des rameaux d'abord:

git branch -rd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

Puis git fetch de la télécommande et utilisez les précédentes git push -vdcommande de nouveau.

Si vous l'utilisez souvent, envisager l'ajout d'un alias dans votre ~/.gitconfig fichier.

Dans le cas où vous avez supprimé certaines branches par erreur, utilisez git reflog à trouver le lost s'engage.

- Je utiliser un git-flow esque schéma d'affectation de noms, de sorte que cela fonctionne très sûre pour moi:

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

Il semble fondamentalement de fusion s'engage à ce que commencent avec une chaîne de fix/ ou feature/.

Écrire un script dans lequel Git vérifie toutes les branches qui ont été fusionnées à maîtriser.

Puis faire git checkout master.

Enfin, supprimer la fusion de branches.

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

Sur Windows avec git bash installé egrep -v ne fonctionnera pas

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

où grep -E -v est l'équivalent de egrep -v

Utilisation -d pour supprimer déjà fusionné branches ou
-D pour supprimer dissociées branches

Pour éviter accidentellement l'exécution de la commande à partir de n'importe quelle autre branche de master que j'ai utiliser le script bash suivant. Sinon, l'exécution de git branch --merged | grep -v "\*" | xargs -n 1 git branch -d à partir d'une branche qui a été fusionnée de master pourrait supprimer la branche master.

#!/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

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

Windoze-friendly script Python (parce que git-sweep étouffé sur Wesnoth référentiel):

#!/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

Si vous souhaitez supprimer des branches locales qui ont été fusionnées ainsi que de supprimer leurs télécommandes voici le one-liner que je préfère:

git branch --merged | xargs -I_br -- sh -c 'git branch -d _br; git push origin --delete _br'

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

Je ne veux pas supprimer TOUTES les maîtres, de la TÊTE, ou quoi que ce soit à partir de l'amont. Aussi, je ne veux pas supprimer la développer de la branche qui est notre branche nous créer PRs de.

La liste de toutes les branches distantes, filtrée par ceux qui ont été fusionnées:

git branch -r

Supprimer des lignes de la liste qui contiennent des mots que je connais sont dans les noms de branche je ne veux pas supprimer:

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

Supprimer le nom distant à partir du nom de la référence (origine/somebranch devient somebranch):

sed 's/.*\///'

Utilisation xargs pour appeler un one-liner:

xargs git push --delete origin

Tube tous ensemble, vous obtenez:

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

Cela va me laisser avec seulement quelques branches que j'ai travaillé, mais n'ont pas fusionné. Vous pouvez ensuite les supprimer un par un, comme il ne devrait pas être trop nombreux.

Trouver des branches que vous ne voulez plus:

git branch -ar

Disons que vous avez trouvé branch1, (sesc) 2, et branch3 que vous souhaitez supprimer:

git push --delete origin branch1 branch2 branch3

J'ai été en utilisant la méthode suivante pour supprimer fusionné local ET à distance branches dans un cmd.

J'ai la suite dans ma bashrc fichier:

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

Ce n'est pas de supprimer la branche master, mais supprime fusionné local ET à distance branches. Une fois que vous avez ce dans vous fichier rc, il suffit d'exécuter rmb, vous êtes montré une perte de fusion des branches qui doit être nettoyé et a demandé pour la confirmation de l'action. Vous pouvez modifier le code pour ne pas demander de confirmation, mais c'est probablement une bonne chose pour le garder dans le.

Si vous êtes sur Windows, vous pouvez utiliser Windows Powershell avec Hors-GridView (malheureusement, il est parti en Powershell de Base pour l'instant) d'avoir une belle liste de branches et sélectionnez avec la souris la partie que vous voulez supprimer:

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

après avoir cliqué sur OK Powershell va passer cet branches noms de git branch -d de commande et supprimer