Verfolgen Sie alle Remote-Git-Zweige als lokale Zweige

Das Verfolgen eines einzelnen Remote-Zweigs als lokaler Zweig ist recht einfach.

$ git checkout --track -b ${branch_name} origin/${branch_name}

Es ist auch einfach, alle lokalen Zweige auf die Fernbedienung zu verschieben und bei Bedarf neue Fernzweige zu erstellen.

$ git push --all origin

Ich möchte das Gegenteil tun. Wenn ich X Anzahl von Remote-Zweigen an einer einzigen Quelle habe:

$ git branch -r 
branch1
branch2
branch3
.
.
.

Kann ich lokale Tracking-Zweige für alle diese Remote-Zweige erstellen, ohne dass jeder manuell erstellt werden muss? Sagen Sie etwas wie:

$ git checkout --track -b --all origin

Ich habe gegoogelt und RTMs, bin aber bisher in die Koje gekommen.

Bash verwenden:

for i in `git branch -a | grep remote | grep -v HEAD | grep -v master`; do git branch --track ${i#remotes/origin/} $i; done

Credits: Val Blant, Elias und Hugo

Hinweis: Der folgende Code verursacht, wenn er in späteren Versionen von git (> v1.9.1) verwendet wird

1. (Fehler) Alle erstellten Zweige, um den Master zu verfolgen
2. (Ärger) Alle erstellten lokalen Filialnamen, denen ein Präfix vorangestellt werden soll origin/

for remote in `git branch -r `; do git branch --track $remote; done

Aktualisieren Sie die Zweige, vorausgesetzt, es gibt keine Änderungen an Ihren lokalen Tracking-Zweigen:

for remote in `git branch -r `; do git checkout $remote ; git pull; done

Ignorieren Sie die mehrdeutigen Refname-Warnungen. Git scheint den lokalen Zweig so zu bevorzugen, wie er sollte.

Die Antwort von Otto ist gut, aber alle erstellten Zweige haben "Ursprung /" als Anfang des Namens. Wenn Sie nur möchten, dass der letzte Teil (nach dem letzten /) Ihre resultierenden Zweignamen sind, verwenden Sie Folgendes:

for remote in `git branch -r | grep -v /HEAD`; do git checkout --track $remote ; done

Es hat auch den Vorteil, dass Sie keine Warnungen vor mehrdeutigen Verweisen erhalten.

Die meisten Antworten hier erschweren das Parsen der Ausgabe von git branch -r. Sie können Folgendes verwendenfor Schleife die Tracking-Zweige wie für alle Zweige auf der Fernbedienung erstellen.

Beispiel

Angenommen, ich habe diese entfernten Zweige.

$ git branch -r
  origin/HEAD -> origin/master
  origin/development
  origin/integration
  origin/master
  origin/production
  origin/staging

Stellen Sie sicher, dass wir lokal noch nichts anderes als den Master verfolgen:

$ git branch -l    # or using just git branch
* master

Mit diesem einen Liner können Sie die Tracking-Zweige erstellen:

$ for i in $(git branch -r | grep -vE "HEAD|master"); do 
    git branch --track ${i#*/} $i; done
Branch development set up to track remote branch development from origin.
Branch integration set up to track remote branch integration from origin.
Branch production set up to track remote branch production from origin.
Branch staging set up to track remote branch staging from origin.

Bestätigen Sie nun:

$ git branch
  development
  integration
* master
  production
  staging

So löschen Sie sie:

$ git br -D production development integration staging 
Deleted branch production (was xxxxx).
Deleted branch development (was xxxxx).
Deleted branch integration (was xxxxx).
Deleted branch staging (was xxxxx).

Wenn Sie den -vvSchalter verwenden, können git branchSie Folgendes bestätigen:

$ git br -vv
  development xxxxx [origin/development] commit log msg ....
  integration xxxxx [origin/integration] commit log msg ....
* master      xxxxx [origin/master] commit log msg ....
  production  xxxxx [origin/production] commit log msg ....
  staging     xxxxx [origin/staging] commit log msg ....

Aufschlüsselung der for-Schleife

Die Schleife ruft im Grunde den Befehl auf git branch -rund filtert mit HEAD oder Master-Zweigen in der Ausgabe heraus grep -vE "HEAD|master". Um nur die Namen der Zweige abzüglich der origin/Teilzeichenfolge zu erhalten, verwenden wir die String-Manipulation von Bash ${var#stringtoremove}. Dadurch wird die Zeichenfolge "stringtoremove" aus der Variablen entfernt $var. In unserem Fall entfernen wir die Zeichenfolge origin/aus der Variablen $i.

HINWEIS: Alternativ können git checkout --track ...Sie dies auch verwenden:

$ for i in $(git branch -r | grep -vE "HEAD|master" | sed 's/^[ ]\+//'); do 
    git checkout --track $i; done

Diese Methode interessiert mich jedoch nicht besonders, da sie Sie beim Auschecken zwischen den Zweigen wechselt. Wenn Sie fertig sind, bleiben Sie auf dem letzten Zweig, den es erstellt hat.

Verweise

• 10.1. Bearbeiten von Zeichenfolgen - Advanced Bash Scripting Guide
• 3.5 Git Branching - Remote Branches

Update Q1 2020: Mohsen Abasi schlägt in den Kommentaren auf der Grundlage der Antwort des slm 2014 die einfachere Alternative vor:

for i in $(git branch -r | grep -vE "HEAD|master" | sed 's/^[ ]\+//'); 

Und es werden $()anstelle veralteter Backticks verwendet .

Wie ich in erwähnen eine andere alte Antwort , mit git for-each-refist wahrscheinlich schneller .
Und ich würde den neuen git switchBefehl (Git 2.23+) verwenden , der die Verwirrung ersetztgit checkout .

for i in $(git for-each-ref --format=%(refname:short) \
  --no-merged=origin/HEAD refs/remotes/origin); do \
    git switch --track $i; \
done

Auf diese Weise nicht grepbenötigt.

Alte (2011) ursprüngliche Antwort:

Hier ist mein Einzeiler, den ich benutze (in einer Bash-Shell, getestet mit msysgit1.7.4):

Zum Kopieren und Einfügen:

remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch --set-upstream-to $remote/$brname $brname; done

Für mehr Lesbarkeit:

remote=origin ; // put here the name of the remote you want
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do 
    git branch --set-upstream-to $remote/$brname $brname; 
done

• Es werden nur Upstream-Zweige von der Fernbedienung ausgewählt, die Sie in der remoteVariablen angegeben haben (es kann 'origin ' sein oder ein beliebiger Name, den Sie für eine der Fernbedienungen Ihres aktuellen Git-Repos festgelegt haben).
• Es wird den Namen des Zweigs extrahieren: origin/a/Branch/Name => a/Branch/Namedurch den awkAusdruck.

• Der Upstream-Zweig wird durch --set-upstream-to(oder -u) gesetzt , nicht --track:
  Der Vorteil ist, dass der Zweig, wenn er bereits vorhanden ist, nicht fehlschlägt und den Ursprung des Zweigs nicht ändert, sondern nur die branch.xxx.(remote|merge)Einstellung konfiguriert .

  branch.aBranchName.remote=origin
  branch.aBranchName.merge=refs/heads/a/Branch/Name
  

Dieser Befehl erstellt lokale Zweige für alle Remote-Upstream-Zweige und setzt deren Remote- und Zusammenführungseinstellung auf diesen Remote-Zweig.

Sie könnten das leicht genug schreiben, aber ich weiß nicht, wann es wertvoll sein würde. Diese Zweige würden ziemlich schnell zurückfallen, und Sie müssten sie ständig aktualisieren.

Die Remote-Zweige werden automatisch auf dem neuesten Stand gehalten. Daher ist es am einfachsten, den lokalen Zweig an der Stelle zu erstellen, an der Sie tatsächlich daran arbeiten möchten.

for i in `git branch -a | grep remote`; do git branch --track ${i#remotes/origin/} $i; done

ohne Scripting (in einem leeren Verzeichnis):

$ git clone --bare repo_url .git
$ git config core.bare false
$ git checkout

Danach werden alle Remote-Zweige als lokal angesehen.

Original (auf Russisch) .

Wenn Sie Powershell verwenden möchten und Ihre Fernbedienung als Ursprung bezeichnet wird. Dann funktioniert das.

git fetch    
git branch -r  | %{$_ -replace "  origin/"} | %{git branch --track $_ "origin/$_"}

for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do  git branch --track ${branch##*/} $branch; done

Verwenden Sie diese Option, und Sie erhalten keine Warnung wie: refname 'origin / dev' ist nicht eindeutig

Hier ist meine Lösung des BASH-Befehls, auf den @tjmcewan verweist:

for remote in `git branch -r | grep -v /HEAD `; do git branch --track ${remote/"origin/"/""}; done

Mein Ziel ist es, das Problem zu lösen, dass alle erstellten Zweige "origin /" als Anfang des Namens haben, da ich getestet habe, dass $ remote-Variablen immer noch "origin /" enthalten:

for remote in `git branch -r | grep -v /HEAD`; do echo $remote ; done

Rufen Sie dies aus einer Batch-Datei auf, um dasselbe wie die Antwort von tjmcewan unter Windows zu tun :

for /f "delims=" %%r in ('git branch -r ^| grep -v master') do git checkout --track %%r

Oder dies über die Kommandozeile :

for /f "delims=" %r in ('git branch -r ^| grep -v master') do git checkout --track %r

Ab Git 2.23:

for branch in `git branch -r | grep origin/`; do git switch -t -C ${branch#origin/} $branch; git pull; done

Das -CFlag zum git switchErstellen oder Zurücksetzen, falls es bereits vorhanden ist.

Git Switch Dokumentation

Falls Sie bereits einige Filialen ausgecheckt haben und möchten

• Überprüfen Sie alle verbleibenden Zweige von der Fernbedienung
• Stellen Sie sicher, dass alle lokalen Zweige die entfernten Zweige verfolgen

Sie können das folgende bash- und zsh-kompatible Skript verwenden:

git branch -r | while read b; do if git branch | grep -q " ${b##*/}$"; then git branch --set-upstream ${b##*/} $b; else git branch --track ${b##*/} $b; fi; done

for rembranch in `git remote update 2>&1 > /dev/null ; git branch -r|egrep -wv "HEAD|master"`
do 
    git checkout --track -b `echo $rembranch|awk -F\/ '{print $2}'` $rembranch; 
done

Erläuterung:

Zeile 1: 'git branch -r' (gefolgt von 'git remote update', um die Informationen zu Änderungen an remote zu aktualisieren) listet alle Remote-Zweige auf; 'egrep -vw' wird verwendet, um Einträge mit HEAD und Master im Ergebnis anzuklopfen.

Zeile 3: Verfolgen Sie den benannten Remote-Zweig, während Sie ihn lokal auschecken. Ein einfaches awk wird verwendet, um zu vermeiden, dass 'origin /' das Suffix für lokale Zweige ist.

Wenn Sie mit bash alle Zweige auschecken möchten:

for remote in `git branch -r`; do git checkout $(echo $remote | cut -d'/' -f 2); done

Es ist wichtig zu beachten, dass Sie beim Abrufen, bei dem neue Remote-Tracking-Zweige heruntergefahren werden, nicht automatisch über lokale, bearbeitbare Kopien davon verfügen.