Wie kann ich alle zusammengeführten Git-Zweige löschen?

So löschen Sie alle bereits zusammengeführten Zweige auf Remote:

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

In neueren Versionen von Git

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

Adams Antwort nur ein wenig erweitern:

Fügen Sie dies zu Ihrer Git-Konfiguration hinzu, indem Sie git config -e --global ausführen.

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

Und dann können Sie alle lokalen zusammengeführten Zweige löschen, indem Sie einen einfachen git cleanup verwenden.

Dies funktioniert auch, um alle zusammengeführten Zweige außer master zu löschen.

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

Sie möchten die Zweige master & develop von diesen Befehlen ausschließen.

Lokaler Git klar: 

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

Remote-Git klar: 

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

Lokale Registrierung entfernter Zweigstellen synchronisieren: 

git fetch -p

Für diejenigen unter Ihnen, die Windows verwenden und PowerShell-Skripts bevorzugen, werden hier lokale zusammengeführte Zweige gelöscht:

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

Ich habe jetzt seit Jahren Adams Antwort verwendet. Das heißt, dass es einige Fälle gibt, in denen es nicht so war, wie ich es erwartet hatte:

1. zweige, die enthalten das Wort "master" wurden ignoriert, z. "notmaster" oder "masterful" statt nur der master branch
2. zweige, in denen enthalten das Wort "dev" ignoriert wurde, z. "dev-test", nicht nur der dev-Zweig
3. löschen von Zweigen, die über den HEAD des aktuellen Zweigs erreichbar sind (dh nicht unbedingt master)
4. im getrennten Zustand HEAD, Löschen von jedem Zweig, der vom aktuellen Commit aus erreichbar ist

1 & 2 waren unkompliziert zu adressieren, mit nur einer Änderung der Regex. 3 hängt vom gewünschten Kontext ab (d. H. Nur Zweige löschen, die nicht mit dem Master oder mit Ihrem aktuellen Zweig zusammengeführt wurden). 4 kann katastrophal sein (obwohl mit git reflog Wiederherstellbar), wenn Sie dies ungewollt in losgelöstem HEAD state ausgeführt haben.

Schließlich wollte ich, dass dies alles in einem Einzeiler geschieht, für den kein separates Skript (Bash | Ruby | Python) erforderlich ist.

TL; DR

Erstelle einen Git-Alias ​​"sweep", der ein optionales -f Flag akzeptiert:

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

und rufe es auf mit:

git sweep

oder:

git sweep -f

Die lange, ausführliche Antwort

Für mich war es am einfachsten, ein Beispiel-Git-Repo mit einigen Zweigen und Commits zu erstellen, um das korrekte Verhalten zu testen:

Erstellen Sie ein neues Git-Repo mit einem einzigen Commit

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

Erstellen Sie einige neue Zweige

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

  bar
  develop
  foo
* master
  masterful
  notmaster

Gewünschtes Verhalten: Wählen Sie alle zusammengeführten Zweige aus, außer: master, develop oder current

Die ursprüngliche Regex vermisst die Zweige "meisterhaft" und "notmaster":

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

  bar

Mit dem aktualisierten regulären Ausdruck (der jetzt "Develop" anstelle von "Dev" ausschließt):

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

bar
masterful
notmaster

Wechseln Sie zum Zweig foo, führen Sie einen neuen Commit durch und checken Sie dann einen neuen Zweig foobar aus, der auf foo basiert:

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

Mein aktueller Zweig ist foobar, und wenn ich den obigen Befehl erneut ausführe, um die zu löschenden Zweige aufzulisten, wird der Zweig "foo" eingeschlossen, obwohl er nicht in master zusammengeführt wurde:

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

  bar
  foo
  masterful
  notmaster

Wenn ich jedoch denselben Befehl auf master ausführe, ist der Zweig "foo" nicht enthalten:

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

  bar
  masterful
  notmaster

Und das liegt einfach daran, dass git branch --merged Standardmäßig HEAD= der aktuellen Verzweigung verwendet wird, wenn nicht anders angegeben. Zumindest für meinen Workflow möchte ich lokale Verzweigungen nur löschen, wenn sie gelöscht werden bin zum master zusammengelegt worden, daher bevorzuge ich folgende variante:

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

  bar
  masterful
  notmaster

Detached HEAD state

Wenn Sie sich auf das Standardverhalten von git branch --merged Verlassen, hat dies noch bedeutendere Konsequenzen für den getrennten HEAD state:

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

  bar
  foo
  foobar
  masterful
  notmaster

Dies hätte den Zweig gelöscht, auf dem ich gerade war, "foobar" zusammen mit "foo", was mit ziemlicher Sicherheit nicht das gewünschte Ergebnis ist. Mit unserem überarbeiteten Befehl jedoch:

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

  bar
  masterful
  notmaster

Eine Zeile, einschließlich des tatsächlichen Löschvorgangs

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

Alles eingewickelt in einen Git-Alias ​​"Sweep":

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

Der Alias ​​akzeptiert ein optionales -f - Flag. Standardmäßig werden nur Zweige gelöscht, die mit dem Master zusammengeführt wurden. Mit dem Flag -f Werden jedoch Zweige gelöscht, die mit dem aktuellen Zweig zusammengeführt wurden.

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

Git Sweep macht das super.

Verwenden von Git Version 2.5.0:

git branch -d `git branch --merged`

Sie können das Festschreiben zur Option --merged hinzufügen . Auf diese Weise können Sie nur die Verzweigungen entfernen, die mit dem Ursprung/Master verbunden sind

Der folgende Befehl entfernt zusammengeführte Zweige aus Ihrem Origin.

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

Sie können testen, welche Äste entfernt werden, indem Sie git Push Origin --delete durch Echo ersetzen

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

Ich verwende das folgende Ruby-Skript, um meine bereits zusammengeführten lokalen und entfernten Zweigstellen zu löschen. Wenn ich es für ein Repository mit mehreren Fernbedienungen mache und nur aus einer löschen möchte, füge ich der Fernbedienungsliste eine Auswahlanweisung hinzu, um nur die gewünschten Fernbedienungen zu erhalten.

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

So löschen Sie zusammengeführte Zweige in der PowerShell-Konsole

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

Siehe GitHub für Windows

Es gibt keinen Befehl in Git, der dies automatisch für Sie erledigt. Sie können jedoch ein Skript schreiben, das Git-Befehle verwendet, um Ihnen das zu geben, was Sie brauchen. Dies kann auf verschiedene Arten geschehen, abhängig davon, welches Verzweigungsmodell Sie verwenden. 

Wenn Sie wissen müssen, ob ein Zweig mit Master zusammengeführt wurde, liefert der folgende Befehl keine Ausgabe, wenn myTopicBranch zusammengeführt wurde (d.

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

Sie können den Git-Zweigbefehl verwenden und alle Zweige in Bash analysieren und eine for-Schleife über alle Zweige ausführen. In dieser Schleife prüfen Sie mit obigem Befehl, ob Sie den Zweig löschen können oder nicht.

die Antwort von kuboon verpasste das Löschen von Zweigen, die den Word-Master im Zweignamen haben.

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

Natürlich wird der "Master" -Zweig selbst nicht gelöscht :)

git branch --merged | grep -Ev '^(. master|\*)' | xargs -n 1 git branch -d löscht alle lokalen Zweige mit Ausnahme des aktuell ausgecheckten Zweigs und/oder der master.

Hier ist ein hilfreicher Artikel für diejenigen, die diese Befehle verstehen möchten: Git Clean: Löschen Sie bereits zusammengeführte Zweige von Steven Harman .

Sie können git-del-brtool verwenden.

git-del-br -a

Sie können es über pip mit installieren

pip install git-del-br

P.S: Ich bin der Autor des Tools. Anregungen/Feedback sind willkommen. 

Alias-Version von Adams aktualisierte Antwort :

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

In diese Antwort finden Sie praktische Tipps zum Vermeiden komplexer Aliase.

Wenn Sie alle lokalen Zweigstellen löschen möchten, die bereits in der Zweigstelle, in der Sie sich gerade befinden, zusammengeführt wurden, habe ich einen sicheren Befehl, der auf früheren Antworten basiert:

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

Dieser Befehl wirkt sich nicht auf Ihren aktuellen Zweig oder Ihren Master-Zweig aus. Es zeigt Ihnen auch, was es tut, bevor es es tut, indem Sie das -t-Flag von xargs verwenden.

Versuchen Sie den folgenden Befehl:

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

Bei Verwendung von git rev-parse Wird der aktuelle Filialname angezeigt, um ihn auszuschließen. Wenn Sie den Fehler erhalten haben, bedeutet dies, dass keine lokalen Zweige entfernt werden müssen.

Um dasselbe mit entfernten Zweigen zu tun (ändern Sie Origin mit Ihrem entfernten Namen), versuchen Sie:

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

^{Wenn Sie mehrere Fernbedienungen haben, fügen Sie grep Origin | Vor cut hinzu, um nur die Origin zu filtern.}

Wenn der obige Befehl fehlschlägt, versuchen Sie zuerst, die zusammengeführten Fernverfolgungszweige zu löschen:

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

Dann git fetch Die Fernbedienung erneut und den vorherigen Befehl git Push -vd Erneut verwenden.

Wenn Sie es häufig verwenden, sollten Sie erwägen, es als Aliase in Ihre ~/.gitconfig - Datei aufzunehmen.

Falls Sie versehentlich einige Zweige entfernt haben, verwenden Sie git reflog, Um die verlorenen Commits zu finden.

Die folgende Abfrage funktioniert für mich 

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

und dies filtert einen beliebigen Zweig in der grep-Leitung.

Funktioniert gut über http clone, aber nicht so gut für die ssh Verbindung.

Basierend auf einigen dieser Antworten habe ich mein eigenes Bash-Skript gemacht, um es auch zu tun !

Es verwendet git branch --merged und git branch -d, um die zusammengeführten Zweige zu löschen, und fordert Sie vor dem Löschen für jeden Zweig auf.

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
}

Ich benutze ein git-flow-artiges Namensschema, daher funktioniert das für mich sehr sicher:

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

Grundsätzlich wird nach zusammengeführten Commits gesucht, die entweder mit der Zeichenfolge fix/ oder feature/ beginnen.

Schreiben Sie ein Skript, in dem Git alle zu master zusammengeführten Zweige überprüft.

Dann git checkout master.

Löschen Sie schließlich die zusammengeführten Zweige.

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

Die akzeptierte Lösung ist ziemlich gut, hat jedoch das eine Problem, dass auch lokale Zweigstellen gelöscht werden, die noch nicht mit einer Remote zusammengeführt wurden.

Wenn Sie sich die Ausgabe von Ihnen ansehen, sehen Sie so etwas 

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

Die Zweige bla und issue_248 sind lokale Zweige, die unbemerkt gelöscht werden.

Sie können jedoch auch das Wort [gone] sehen, das auf Zweige verweist, die an eine entfernte (die jetzt weg ist) verschoben wurden, und daher Zweige löschen können.

Die ursprüngliche Antwort kann daher geändert werden in (für kürzere Zeilenlänge in mehrere Zeilen aufgeteilt).

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

um die noch nicht zusammengeführten Zweige zu schützen, ist auch der Grepping für Master nicht erforderlich, da dieser eine Fernsteuerung bei Origin hat und nicht als verschwunden angezeigt wird.

Für Windows können Sie Cygwin installieren und alle entfernten Zweige mit folgendem Befehl entfernen:

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

Für mich zeigt git branch --merged keine Zweige, die über GitHub PR zusammengeführt wurden. Ich bin mir der Gründe nicht sicher, aber ich verwende die folgende Zeile, um alle lokalen Zweige zu löschen , die keinen Remote-Tracking-Zweig haben :

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

Erklärung:

• git branch --format "%(refname:short)" gibt eine Liste der lokalen Zweige an
• git branch -r | grep -v HEAD | cut -d/ -f2- gibt eine Liste der entfernten Zweige aus und filtert HEAD
• diff <(...) <(...) gibt einen Unterschied der Ausgabe von zwei Befehlen in Klammern aus
• grep '<' filtert Zweige, die in der ersten Liste vorhanden sind, aber nicht in der zweiten
• cut -c 3- gibt eine Zeile ab dem 3. Zeichen aus und entfernt so das Präfix <
• xargs git branch -D führt git branch -D für jeden Zweignamen aus

Alternativ können Sie grep -v '<' wie folgt vermeiden:

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

Unter Windows mit git bash installiert wird egrep -v nicht funktionieren

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

wobei grep -E -v äquivalent zu egrep -v ist

Verwenden Sie -d, um bereits merged - Zweige zu entfernen, oder -D, um unmerged - Zweige zu entfernen

Um zu vermeiden, dass der Befehl versehentlich von einem anderen Zweig als Master ausgeführt wird, verwende ich das folgende Bash-Skript. Wenn Sie git branch --merged | grep -v "\*" | xargs -n 1 git branch -d von einem Zweig ausführen, der mit einem anderen Master zusammengeführt wurde, kann der Master-Zweig gelöscht werden.

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

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

(Zur besseren Lesbarkeit in mehrere Zeilen aufteilen

Durch Aufrufen von "git cleanup" werden lokale Zweige gelöscht, die bereits in Origin/master zusammengeführt wurden. Master, Staging und Dev werden übersprungen, da diese unter normalen Umständen nicht gelöscht werden sollen.

Dies aufzuschlüsseln, ist das, was es tut:

1. git config --global alias.cleanup
   • Dies erstellt einen globalen Alias ​​namens "Aufräumen" (über alle Ihre Repos)
2. Das ! Am Anfang des Befehls besagt, dass wir einige Nicht-Git-Befehle als Teil dieses Alias ​​verwenden werden, daher müssen wir hier tatsächlich bash-Befehle ausführen
3. git branch --merged Origin/master
   • Dieser Befehl gibt die Liste der Zweignamen zurück, die bereits mit Origin/master Zusammengeführt wurden.
4. egrep -v "(^\*|master|staging|dev)"
   • Dadurch werden der Master-, Staging- und Dev-Zweig aus der Liste der bereits zusammengeführten Zweige entfernt. Wir möchten diese Zweige nicht entfernen, da sie keine Features sind.
5. xargs git branch -d
   • Dadurch wird der Befehl git branch -d xxxxx Für jeden nicht zusammengeführten Zweig ausgeführt. Dies löscht die lokalen Zweige nacheinander.

Stand: 2018.07

Fügen Sie dies dem Abschnitt [alias] Ihres ~/.gitconfig hinzu:

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

Jetzt können Sie einfach git sweep aufrufen, um die erforderliche Bereinigung durchzuführen.

Um lokale Zweige zu löschen, die mit dem Hauptzweig zusammengeführt wurden, verwende ich den folgenden Alias ​​(git config -e --global):

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

Ich verwende git branch -D, um error: The branch 'some-branch' is not fully merged.-Meldungen zu vermeiden, während sich meine derzeitige Kasse vom Hauptzweig unterscheidet.

Windoze-freundliches Python-Skript (weil git-sweep im Wesnoth-Repository verschluckt):

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

Wenn Sie ein Verzweigungsmodell wie HubFlow oder GitFlow verwenden, können Sie mit diesem Befehl die zusammengeführten Feature-Verzweigungen entfernen:

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

Hier ist der Weg, um Git-Zweig zu löschen

git branch -D BranchName

Mein Bash-Skript-Beitrag basiert lose auf mmrobins Antwort .

Es sind einige nützliche Parameter erforderlich, die einschließen und ausschließen angeben oder nur lokale oder entfernte Verzweigungen anstelle von beiden untersuchen oder entfernen.

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

Wenn Sie unter Windows arbeiten, können Sie Windows Powershell mit Out-GridView (leider ist es erstmal in Powershell Core weg) verwenden, um eine schöne Liste von Zweigen zu haben und mit der Maus auszuwählen, welche Sie löschen möchten:

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

  Nach dem Klicken auf OK übergibt Powershell die Namen dieser Zweige an den Befehl git branch -d und löscht sie  

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

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

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

Nehmen wir an, ich habe eine Fernbedienung namens Upstream und Origin (GitHub-Stil, meine Abzweigung ist Origin, Upstream ist Upstream).

Ich möchte keine Master, HEAD oder irgendetwas aus dem Upstream löschen. Ich möchte auch nicht den Entwicklungszweig löschen, da dies unser gemeinsamer Zweig ist, aus dem wir PRs erstellen.

Listen Sie alle entfernten Zweige auf, gefiltert nach den zusammengeführten:

git branch -r

Entfernen Sie Zeilen aus dieser Liste, die Wörter enthalten, von denen ich weiß, dass sie in den Namen der Verzweigungen sind, die ich nicht entfernen möchte:

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

Entferne den Remote-Namen aus dem Referenznamen (Origin/Somebranch wird zu Somebranch):

sed 's/.*\///'

Benutze xargs, um einen Einzeiler anzurufen:

xargs git Push --delete Origin

Pipe alles zusammen bekommst du:

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

Dies wird mir nur einige Filialen hinterlassen, an denen ich gearbeitet habe, aber nicht zusammengelegt habe. Sie können sie dann einzeln entfernen, da es nicht zu viele sein sollte.

Finden Sie Filialen, die Sie nicht mehr brauchen:

git branch -ar

Angenommen, Sie finden branch1, branch2 und branch3, die Sie löschen möchten:

git Push --delete Origin branch1 branch2 branch3

Ich habe die folgende Methode verwendet, um kombinierte lokale UND entfernte Zweige entfernen in einem Cmd zu entfernen. 

Ich habe folgendes in meiner bashrc-Datei:

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

Dies löscht nicht den Master-Zweig, sondern entfernt zusammengeführte lokale AND-Zweigstellen. Sobald Sie dies in Ihrer RC-Datei haben, führen Sie einfach rmb aus. Es wird ein Verlust von zusammengeführten Zweigen angezeigt, die bereinigt werden und zur Bestätigung der Aktion aufgefordert werden. Sie können den Code ändern, um nicht ebenfalls nach einer Bestätigung zu fragen, aber es ist wahrscheinlich gut, ihn beizubehalten.

Wenn Sie lokale Zweigstellen löschen möchten, die zusammengeführt wurden, sowie deren Fernbedienungen, so ist der Einzeiler, den ich vorziehen möchte,

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