Ich habe viele Git-Filialen. Wie lösche ich bereits zusammengeführte Zweige? Gibt es eine einfache Möglichkeit, sie alle zu löschen, anstatt sie einzeln zu löschen?
AKTUALISIEREN:
Sie können andere Zweige hinzufügen, um sie wie master und dev auszuschließen, wenn Ihr Workflow diese als möglichen Vorfahren hat. Normalerweise verzweige ich von einem "sprint-start" -Tag und master, dev und qa sind keine Vorfahren.
Listen Sie zunächst alle Zweige auf, die in Remote zusammengeführt wurden.
git branch --merged
Möglicherweise sehen Sie einige Zweige, die Sie nicht entfernen möchten. Wir können einige Argumente hinzufügen, um wichtige Verzweigungen zu überspringen, die nicht gelöscht werden sollen, wie etwa Master oder eine Entwicklung. Der folgende Befehl überspringt den Master-Zweig und alles, was dev enthält.
git branch --merged| egrep -v "(^\*|master|dev)"
Wenn Sie überspringen möchten, können Sie es wie folgt zum Befehl egrep hinzufügen. Der Zweig skip_branch_name
wird nicht gelöscht.
git branch --merged| egrep -v "(^\*|master|dev|skip_branch_name)"
So löschen Sie alle lokalen Zweigstellen, die bereits mit der aktuell ausgecheckten Zweigstelle zusammengeführt wurden:
git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d
Sie können sehen, dass master und dev ausgeschlossen sind, falls sie Vorfahren sind.
Sie können eine zusammengeführte lokale Zweigstelle löschen mit:
git branch -d branchname
Wenn es nicht zusammengeführt wird, verwenden Sie:
git branch -D branchname
Um es aus der Ferne in alten Versionen von Git zu löschen, verwenden Sie:
git Push Origin :branchname
In neueren Versionen von Git verwenden Sie:
git Push --delete Origin branchname
Wenn Sie den Zweig aus der Ferne gelöscht haben, können Sie die Fernverfolgungszweige mit Prune entfernen:
git remote Prune Origin
oder Beschneiden Sie einzelne Fernverfolgungszweige mit der folgenden Antwort:
git branch -dr branchname
Hoffe das hilft.
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 & 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.
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
Für mich war es am einfachsten, ein Beispiel-Git-Repo mit einigen Zweigen und Commits zu erstellen, um das korrekte Verhalten zu testen:
mkdir sweep-test && cd sweep-test && git init
echo "hello" > hello
git add . && git commit -am "initial commit"
git branch foo && git branch bar && git branch develop && git branch notmaster && git branch masterful
git branch --list
bar develop foo * master masterful notmaster
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
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
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
git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" | xargs git branch -d
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
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-br
tool 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 angit 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 ausgrep '<'
filtert Zweige, die in der ersten Liste vorhanden sind, aber nicht in der zweitencut -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 ausAlternativ 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
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:
git config --global alias.cleanup
!
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ührengit branch --merged Origin/master
Origin/master
Zusammengeführt wurden.egrep -v "(^\*|master|staging|dev)"
xargs git branch -d
git branch -d xxxxx
Für jeden nicht zusammengeführten Zweig ausgeführt. Dies löscht die lokalen Zweige nacheinander.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())
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'