So rufen Sie alle Git-Zweige ab

Ich habe ein Git-Repository geklont, das ungefähr fünf Zweige enthält. Wenn ich das tue, sehe git branchich jedoch nur einen von ihnen:

$ git branch
* master

Ich weiß , dass ich tun kann , git branch -aum zu sehen , alle die Zweige, aber wie würde ich alle die Zweige vor Ort so ziehen , wenn ich tun git branch, es zeigt die folgende?

$ git branch
* master
* staging
* etc...

Sie können alle Zweige von allen Fernbedienungen wie folgt abrufen:

git fetch --all

Es ist im Grunde eine Kraftbewegung .

fetchaktualisiert lokale Kopien von Remote-Filialen, sodass dies für Ihre lokalen Filialen immer sicher ist, ABER :

1. fetchaktualisiert keine lokalen Zweige (die entfernte Zweige verfolgen ); Wenn Sie Ihre lokalen Zweige aktualisieren möchten, müssen Sie dennoch jeden Zweig abrufen.

2. fetchnicht schaffen lokale Niederlassungen (die Spur entfernte Niederlassungen), müssen Sie dies manuell tun. Wenn Sie alle Remote-Zweige auflisten möchten: git branch -a

So aktualisieren Sie lokale Zweige, die entfernte Zweige verfolgen:

git pull --all

Dies kann jedoch immer noch unzureichend sein. Es funktioniert nur für Ihre lokalen Niederlassungen, die entfernte Niederlassungen verfolgen. So verfolgen Sie alle entfernten Niederlassungen dieses oneliner ausführen VOR git pull --all :

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done

TL; DR-Version

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all

(Es scheint, dass Pull alle Zweige von allen Fernbedienungen abruft, aber ich hole immer zuerst, nur um sicherzugehen.)

Führen Sie den ersten Befehl nur aus, wenn sich auf dem Server Remote-Zweige befinden, die von Ihren lokalen Zweigen nicht verfolgt werden.

PS AFAIK git fetch --allund git remote updatesind gleichwertig.

Kamil Szots Kommentar , den die Leute nützlich fanden.

Ich musste verwenden:

for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done

weil Ihr Code lokale Zweige mit dem Namen erstellt hat origin/branchnameund ich "refname 'origin / branchname' erhalten habe, ist dies nicht eindeutig, wenn ich darauf verwiesen habe.

So listen Sie entfernte Zweige auf:
git branch -r

Sie können sie als lokale Niederlassungen auschecken mit:
git checkout -b LocalName origin/remotebranchname

Sie müssen lokale Zweige erstellen, die entfernte Zweige verfolgen.

Angenommen, Sie haben nur eine Fernbedienung aufgerufen origin, erstellt dieses Snippet lokale Zweige für alle Fernverfolgungszweige:

for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done

Danach git fetch --allwerden alle lokalen Kopien der Remote-Zweige aktualisiert.

Außerdem git pull --allwird Ihren lokalen Tracking - Zweig aktualisieren, aber abhängig von Ihrem lokalen Commits und wie die ‚merge‘ configure Option gesetzt ist , es könnte eine Zusammenführung schaffen begehen, Vorspulen oder scheitern.

Wenn Sie tun:

git fetch origin

dann werden sie alle vor Ort sein. Wenn Sie dann ausführen:

git branch -a

Sie sehen sie als Fernbedienungen / Ursprung / Filialname. Da sie vor Ort sind, können Sie mit ihnen machen, was Sie wollen. Zum Beispiel:

git diff origin/branch-name 

oder

git merge origin/branch-name

oder

git checkout -b some-branch origin/branch-name

$ git remote update
$ git pull --all

Dies setzt voraus, dass alle Zweige verfolgt werden.

Wenn dies nicht der Fall ist, können Sie dies in Bash abfeuern:

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

Führen Sie dann den Befehl aus.

Die Bash- forSchleife funktionierte bei mir nicht, aber das tat genau das, was ich wollte. Alle Zweige meiner Herkunft wurden lokal als gleichnamig gespiegelt.

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

Siehe Mike DuPonts Kommentar unten. Ich glaube, ich habe versucht, dies auf einem Jenkins-Server zu tun, der ihn im Modus mit getrenntem Kopf belässt.

Verwenden Sie git fetch && git checkout RemoteBranchName.

Es funktioniert sehr gut für mich ...

Wenn Sie ein Repository klonen, werden alle Informationen der Zweige tatsächlich heruntergeladen, aber die Zweige werden ausgeblendet. Mit dem Befehl

$ git branch -a

Sie können alle Zweige des Repositorys und mit dem Befehl anzeigen

$ git checkout -b branchname origin/branchname

Sie können sie dann einzeln manuell "herunterladen".

Es gibt jedoch einen viel saubereren und schnelleren Weg, obwohl er etwas kompliziert ist. Sie benötigen drei Schritte, um dies zu erreichen:

1. Erster Schritt

   Erstellen Sie einen neuen leeren Ordner auf Ihrem Computer und klonen Sie eine Spiegelkopie des .git-Ordners aus dem Repository:

   $ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
   $ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git
   

   Das lokale Repository im Ordner my_repo_folder ist noch leer. Es gibt nur noch einen versteckten .git-Ordner, den Sie mit einem "ls -alt" -Befehl vom Terminal aus sehen können.

2. Zweiter Schritt

   Wechseln Sie dieses Repository von einem leeren (nackten) Repository zu einem regulären Repository, indem Sie den booleschen Wert "bare" der Git-Konfigurationen auf false setzen:

   $ git config --bool core.bare false
   

3. Dritter Schritt

   Holen Sie sich alles, was sich im aktuellen Ordner befindet, und erstellen Sie alle Zweige auf dem lokalen Computer. Dies macht dies zu einem normalen Repo.

   $ git reset --hard
   

Jetzt können Sie einfach den Befehl eingeben git branchund sehen, dass alle Zweige heruntergeladen wurden.

Dies ist die schnelle Methode, mit der Sie ein Git-Repository mit allen Zweigen gleichzeitig klonen können. Dies möchten Sie jedoch nicht für jedes einzelne Projekt auf diese Weise tun.

Sie können alle Zweige abrufen, indem Sie:

git fetch --all

oder:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

^{Der --depth=10000Parameter kann hilfreich sein, wenn Sie ein flaches Repository haben.}

Verwenden Sie zum Ziehen aller Zweige:

git pull --all

Wenn dies nicht funktioniert, stellen Sie dem obigen Befehl Folgendes voran:

git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

da das remote.origin.fetchbeim Abrufen nur einen bestimmten Zweig unterstützen könnte, insbesondere wenn Sie Ihr Repo mit geklont haben --single-branch. Überprüfen Sie dies durch : git config remote.origin.fetch.

Danach sollten Sie in der Lage sein, jeden Zweig auszuchecken.

Siehe auch:

• Wie rufe ich alle entfernten Zweige ab?
• Wie klone ich alle Remote-Zweige in Git?

Verwenden Sie Folgendes, um alle Zweige auf die Fernbedienung zu übertragen:

git push --all

schließlich --mirroralle refs spiegeln.

Wenn Sie ein Repository duplizieren möchten, lesen Sie: Duplizieren eines Repository- Artikels bei GitHub.

Normalerweise benutze ich nichts anderes als Befehle wie diesen:

git fetch origin
git checkout --track origin/remote-branch

Eine etwas kürzere Version:

git fetch origin
git checkout -t origin/remote-branch

Ich glaube, Sie haben das Repository geklont durch:

git clone https://github.com/pathOfrepository

Gehen Sie nun mit cd in diesen Ordner:

cd pathOfrepository

Wenn Sie tippen git status, können Sie alle sehen:

   On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean

So zeigen Sie alle versteckten Verzweigungstypen an:

 git branch -a

Es werden alle Remote-Zweige aufgelistet.

Wenn Sie nun in einem bestimmten Zweig auschecken möchten, geben Sie einfach Folgendes ein:

git checkout -b localBranchName origin/RemteBranchName

Wenn Sie hier nach einer Lösung suchen, um alle Zweige abzurufen und dann alles auf einen anderen Git-Server zu migrieren, habe ich den folgenden Prozess zusammengestellt. Wenn Sie nur alle Zweige lokal aktualisieren möchten, halten Sie an der ersten leeren Zeile an.

git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track 
git fetch --all --prune --tags
git pull --all

git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>

Nachdem Sie das Master-Repository geklont haben, können Sie es einfach ausführen

git fetch && git checkout <branchname>

Stellen Sie sicher, dass alle Remote-Zweige in einer .git/configDatei abgerufen werden können.

In diesem Beispiel kann nur der origin/productionZweig abgerufen werden, auch wenn Sie versuchen, nichts git fetch --allanderes zu tun , als den Zweig abzurufen production:

[origin]
fetch = +refs/heads/production:refs/remotes/origin/production

Diese Zeile sollte ersetzt werden durch:

[origin]
fetch = +refs/heads/*:refs/remotes/origin/*

Dann laufen git fetchetc ...

Looping schien für mich nicht zu funktionieren und ich wollte Origin / Master ignorieren. Folgendes hat bei mir funktioniert.

git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track

Nachdem:

git fetch --all
git pull --all

Nur diese drei Befehle erhalten alle Zweige:

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false

git reset --hard

Warum beantwortet niemand die Frage der Jungs und erklärt, was passiert?

1. Stellen Sie sicher, dass Sie alle Remote-Zweige verfolgen (oder welche auch immer Sie verfolgen möchten) .
2. Aktualisieren Sie Ihre lokalen Niederlassungen, um die Remote-Niederlassungen widerzuspiegeln.

Verfolgen Sie alle entfernten Zweige:

Verfolgen Sie alle Zweige, die im Remote-Repo vorhanden sind.

Manuell tun:

Sie würden durch <branch>einen Zweig ersetzen , der in der Ausgabe von angezeigt wird git branch -r.

git branch -r
git branch --track <branch>

Mach es mit einem Bash-Skript

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

Aktualisieren Sie Informationen zu den Remote-Zweigen auf Ihrem lokalen Computer:

Dadurch werden Aktualisierungen von Zweigen aus dem Remote-Repo abgerufen, die Sie in Ihrem lokalen Repo verfolgen. Dies ändert nichts an Ihren lokalen Niederlassungen. Ihr lokales Git-Repo ist jetzt über die Ereignisse in den Remote-Repo-Filialen informiert. Ein Beispiel wäre, dass ein neues Commit an den Remote-Master gesendet wurde. Wenn Sie einen Abruf durchführen, werden Sie jetzt darauf hingewiesen, dass Ihr lokaler Master um 1 Commit zurückliegt.

git fetch --all

Aktualisieren Sie Informationen zu den Remote-Zweigen auf Ihrem lokalen Computer und aktualisieren Sie die lokalen Zweige:

Führt einen Abruf durch, gefolgt von einer Zusammenführung aller Zweige vom Remote-Zweig zum lokalen Zweig. Ein Beispiel wäre, dass ein neues Commit an den Remote-Master gesendet wurde. Wenn Sie einen Pull ausführen, wird Ihr lokales Repo über die Änderungen in der Remote-Verzweigung aktualisiert und diese Änderungen werden dann in Ihrer lokalen Verzweigung zusammengeführt. Dies kann aufgrund von Zusammenführungskonflikten zu einem ziemlichen Durcheinander führen.

git pull --all

Ich habe ein kleines Skript geschrieben, um das Klonen eines neuen Repos und das Erstellen lokaler Zweige für alle entfernten Zweige zu verwalten.

Die neueste Version finden Sie hier :

#!/bin/bash

# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)

clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
  branch=$(echo $i | perl -pe 's/^.*?\///')
  # this doesn't have to be done for each branch, but that's how I did it.
  remote=$(echo $i | sed 's/\/.*//')
  if [[ "$this_branch" != "$branch" ]]; then
      git branch -t $branch $remote/$branch
  fi
done
popd > /dev/null 2>&1

Um es zu verwenden, kopieren Sie es einfach in Ihr Git Bin-Verzeichnis (für mich ist das C:\Program Files (x86)\Git\bin\git-cloneall) und dann in die Befehlszeile:

git cloneall [standard-clone-options] <url>

Es klont wie gewohnt, erstellt jedoch lokale Tracking-Zweige für alle Remote-Zweige.

So rufen Sie alle Git-Zweige ab, die eine einzelne Fernbedienung verfolgen.

Dies wurde getestet und funktioniert unter Red Hat und Git Bash unter Windows 10.

TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Erläuterung:

Der Einzeiler checkt aus und holt dann alle Zweige außer HEAD.

Listen Sie die Remote-Tracking-Zweige auf.

git branch -r

KOPF ignorieren.

grep -v ' -> '

Nehmen Sie den Filialnamen von den Fernbedienungen ab.

cut -d"/" -f2

Kasse aller Filialen, die eine einzelne Fernbedienung verfolgen.

git checkout $branch

Für ausgecheckten Zweig abrufen.

git fetch

Technisch wird der Abruf für neue lokale Niederlassungen nicht benötigt.

Dies kann entweder für fetchoder für pullZweige verwendet werden, die beide neu sind und Änderungen an Remote (s) aufweisen.

Stellen Sie einfach sicher, dass Sie nur ziehen, wenn Sie zum Zusammenführen bereit sind.

Versuchsaufbau

Überprüfen Sie ein Repository mit SSH-URL.

git clone git@repository.git

Vor

Überprüfen Sie die Filialen vor Ort.

$ git branch
* master

Befehle ausführen

Führen Sie den einen Liner aus.

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Nach

Überprüfen Sie, ob lokale Zweige Remote-Zweige enthalten.

$ git branch
  cicd
  master
* preprod

Für Windows-Benutzer, die PowerShell verwenden:

git branch -r | ForEach-Object {
    # Skip default branch, this script assumes
    # you already checked-out that branch when cloned the repo
    if (-not ($_ -match " -> ")) {
        $localBranch = ($_ -replace "^.*?/", "")
        $remoteBranch = $_.Trim()
        git branch --track "$localBranch" "$remoteBranch"
    }
}
git fetch --all
git pull --all

Folgendes würde ich als robust betrachten:

• Aktualisiert die Fernverfolgung für vorhandene Zweige nicht
• Versucht nicht zu aktualisieren, um HEADzu verfolgenorigin/HEAD
• Ermöglicht andere Fernbedienungen als origin
• Richtig Shell zitiert

for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

Es ist nicht notwendig , um git fetch --alldie Weitergabe -allan git pullPässen diese Option , um die internen fetch.

Gutschrift auf diese Antwort .

Hier ist eine Perl-Version des Einzeilers in der akzeptierten Antwort:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

Sie können die Ausgabedatei als Shell-Skript ausführen, wenn Sie möchten.

Wir haben versehentlich unser Stash-Projekt-Repository gelöscht. Glücklicherweise hatte jemand kurz vor dem versehentlichen Verlust eine Gabel geschaffen. Ich habe die Gabel an meinen Einheimischen geklont (ich werde die Details darüber, wie ich das gemacht habe, weglassen). Sobald ich die Gabel vollständig in meinem Lokal hatte, fuhr ich einen Einzeiler. Ich habe die URL der Fernbedienung (Ursprung in meinem Fall) so geändert, dass sie auf das Ziel-Repository verweist, in das wir wiederhergestellt haben:

git remote set-url origin <remote-url>

Und schließlich alle Zweige so zum Ursprung gebracht:

git push --all origin

und wir waren wieder im Geschäft.

Wir können alle Zweig- oder Tag-Namen in eine temporäre Datei einfügen und dann für jeden Namen / Tag git pull ausführen:

git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done

Wenn Sie Probleme mit haben, fetch --allverfolgen Sie Ihren Remote-Zweig:

git checkout --track origin/%branchname%

Um die Fehlermeldung 'fatal' zu vermeiden: Ein Zweig mit dem Namen 'origin / master' existiert bereits. 'Benötigen Sie Folgendes:

git branch -r | grep -v '\->'  | grep -v `git branch | awk '/\*/ { print $2; }'`| while read remote; do git branch --track "${remote#origin/}" "$remote"; done

Basierend auf der Antwort von Learath2 habe ich Folgendes getan, nachdem ich es getan git clone [...]und cdin das erstellte Verzeichnis eingegeben habe :

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

Hat für mich gearbeitet, aber ich kann nicht wissen, dass es für Sie funktionieren wird. Achtung.

git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Jetzt vor Ort bist du yourNewLocalBranchNamedein requiredRemoteBranch.

Für Visual Studio-Benutzer in der Package Manager-Konsole:

Git-Zweig | % {git fetch upstream; Git Merge Upstream / Master}

Habe viele Möglichkeiten ausprobiert, nur diese ist einfach und funktioniert für mich.

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done

Alias ​​festlegen: (basierend auf der Top-Antwort)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

Um nun alle Zweige zu verfolgen:

git track-all-branches