Wie werden alle Remote-Filialen in Git geklont?

Wenn Sie viele entfernte Zweige gleichzeitig abrufen möchten, führen Sie folgende Schritte aus:

$ git pull --all

Jetzt können Sie jeden Zweig nach Belieben auschecken, ohne das entfernte Repository zu treffen.

Dieses Bash Skript hat mir geholfen:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

Es werden Verfolgungszweige für alle entfernten Zweige erstellt, mit Ausnahme von master (was Sie wahrscheinlich vom ursprünglichen Klonbefehl erhalten haben). Ich denke, Sie müssen vielleicht noch ein 

git fetch --all
git pull --all

um sicher zu sein.

One liner: git branch -a | grep -v HEAD | Perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs Wie üblich: Testen Sie in Ihrem Setup, bevor Sie das rm -rf-Universum so kopieren, wie wir es kennen 

Credits für Einzeiler gehen an Benutzer cfi

Die --mirror-Option scheint die remote-Tracking-Zweige korrekt zu kopieren .__ Das Repository wird jedoch als bloßes Repository eingerichtet, sodass Sie es anschließend wieder in ein normales Repository umwandeln müssen.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

^{Referenz: Git FAQ: Wie kann ich ein Repository mit allen fernverfolgten Zweigen klonen?}

Sie können problemlos zu einem Zweig wechseln, ohne die ausgefallene "git checkout -b somebranch Origin/somebranch" -Syntax zu verwenden. Sie können einfach tun:

git checkout somebranch

Git macht automatisch das Richtige:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from Origin.
Switched to a new branch 'somebranch'

Git prüft, ob ein Zweig mit demselben Namen in genau einer Remote vorhanden ist. Wenn dies der Fall ist, verfolgt es ihn genauso, als hätten Sie explizit angegeben, dass es sich um einen Remote-Zweig handelt. Aus der Git-Checkout-Manpage von Git 1.8.2.1:

Wenn <branch> nicht gefunden wird, aber in .__ ein Tracking-Zweig vorhanden ist. genau eine Fernbedienung (nennen Sie sie <Remote>) mit einem übereinstimmenden Namen, behandeln Sie als gleichwertig

$ git checkout -b <branch> --track <remote>/<branch>

Bezüglich,

$ git checkout -b experimenteller Ursprung/experimentell

mit

$ git checkout -t Origin/experimental

oder die mehr wortreich, aber leichter zu merken

$ git checkout --track Origin/experimental

möglicherweise besser in Bezug auf die Verfolgung eines Remote-Repository. 

Der Abruf, den Sie ausführen, sollte alle entfernten Zweige abrufen, es werden jedoch keine lokalen Zweige für sie erstellt. Wenn Sie gitk verwenden, sollten Sie die Remote-Zweige sehen, die als "Remote/Origin/Dev" oder etwas Ähnliches beschrieben werden.

So erstellen Sie einen lokalen Zweig basierend auf einem entfernten Zweig:

git checkout -b dev refs/remotes/Origin/dev

Was sollte so etwas zurückgeben:

Branch dev eingerichtet, um Remote Branch Refs/Remotes/Origin/dev ..__ zu verfolgen. Zu einem neuen Zweig "dev" gewechselt

Wenn Sie sich nun im dev-Zweig befinden, wird "git pull" Ihren lokalen dev auf denselben Punkt wie den entfernten dev-Zweig aktualisieren. Beachten Sie, dass alle Zweige abgerufen werden. Ziehen Sie jedoch nur den Zweig, auf dem Sie sich gerade befinden, auf den Baum.

Wenn Sie "git clone git: // location" ausführen, werden alle Zweige und Tags abgerufen.

Um auf einem bestimmten Remote-Zweig zu arbeiten, vorausgesetzt, es handelt sich um den Origin-Remote:

git checkout -b branch Origin/branchname

Verwenden Sie Aliase. Obwohl es keine nativen Git-Einzeiler gibt, können Sie Ihre eigenen definieren

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

und dann verwenden Sie es als

git clone-branches

Dies ist nicht zu kompliziert, sehr einfache und direkte Schritte sind wie folgt;

git fetch Origin Dies bringt alle entfernten Zweige zu Ihrem lokalen.

git branch -a Dies zeigt Ihnen alle entfernten Zweige.

git checkout --track Origin/<branch you want to checkout>

Überprüfen Sie mit dem folgenden Befehl, ob Sie sich im gewünschten Zweig befinden.

git branch

Die Ausgabe wird dies mögen;

*your current branch 
some branch2
some branch3 

Beachten Sie das * -Zeichen, das den aktuellen Zweig kennzeichnet.

Warum sehen Sie nur "Meister"

git clone lädt alle entfernten entfernten Zweige herunter, betrachtet sie jedoch weiterhin als "fern", obwohl sich die Dateien in Ihrem neuen Repository befinden. Es gibt eine Ausnahme: Der Klonvorgang erstellt einen lokalen Zweig namens "Master" aus dem Remote-Zweig namens "Master". Standardmäßig zeigt git branch nur lokale Zweigstellen, weshalb Sie nur "master" sehen.

git branch -a zeigt alle Zweige, einschließlich entfernter Zweige .

Wie bekomme ich lokale Filialen?

Wenn Sie tatsächlich an einem Zweig arbeiten möchten, benötigen Sie wahrscheinlich eine "lokale" Version davon. Um einfach lokale Zweigstellen aus entfernten Zweigstellen zu erstellen (ohne sie auszuchecken und dadurch den Inhalt Ihres Arbeitsverzeichnisses zu ändern) , können Sie dies folgendermaßen tun:

git branch branchone Origin/branchone
git branch branchtwo Origin/branchtwo
git branch branchthree Origin/branchthree

In diesem Beispiel ist branchone der Name eines lokalen Zweigs, den Sie basierend auf Origin/branchone erstellen. Wenn Sie stattdessen lokale Zweigstellen mit unterschiedlichen Namen erstellen möchten, können Sie Folgendes tun:

git branch localbranchname Origin/branchone

Nachdem Sie eine lokale Zweigstelle erstellt haben, können Sie diese mit git branch sehen (denken Sie daran, dass Sie -a nicht benötigen, um lokale Zweigstellen anzuzeigen).

Besser spät als nie, aber hier ist der beste Weg, dies zu tun:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

Zu diesem Zeitpunkt haben Sie eine vollständige Kopie des Remote-Repos mit allen Zweigstellen (überprüfen Sie mit git branch). Sie können --mirror anstelle von --bare verwenden, wenn Ihr Remote-Repo über eigene Fernbedienungen verfügt.

Mach einfach das:

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from Origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
  master
$ git branch -a
* branchxyz
  master
  remotes/Origin/HEAD -> Origin/master
  remotes/Origin/branchxyz
  remotes/Origin/branch123

Sie sehen, 'git clone git: //example.com/myprojectt' ruft alles ab, sogar die Zweige, Sie müssen sie nur auschecken, dann wird Ihr lokaler Zweig erstellt.

Sie müssen nur "git clone" verwenden, um alle Zweige zu erhalten.

git clone <your_http_url>

Obwohl Sie nur Hauptzweige sehen, können Sie "git branch -a" verwenden, um alle Zweige anzuzeigen.

git branch -a

Und Sie können zu jedem Zweig wechseln, den Sie bereits haben.

git checkout <your_branch_name>

Machen Sie sich keine Sorgen, dass Sie nach dem "git clone" keine Verbindung zum Remote-Repo herstellen müssen. "Git branch -a" und "git checkout" können erfolgreich ausgeführt werden, wenn Sie Ihr WLAN schließen. Es ist also bewiesen, dass wenn Sie "git clone" ausführen, bereits alle Zweige aus dem Remote-Repo kopiert wurden. Danach brauchen Sie kein Remote-Repo, Ihr Local hat bereits die Codes aller Filialen. 

Ein git clone soll das gesamte Repository kopieren. Versuchen Sie es zu klonen und führen Sie git branch -a aus. Es sollte alle Zweige auflisten. Wenn Sie dann anstelle von "Master" zum Zweig "foo" wechseln möchten, verwenden Sie git checkout foo.

Verwenden Sie mein Tool git_remote_branch (Sie müssen Ruby auf Ihrem Computer installiert haben). Es wurde speziell dafür entwickelt, Remote-Zweigmanipulationen einfach zu machen.

Jedes Mal, wenn eine Operation in Ihrem Namen ausgeführt wird, wird sie an der Konsole rot gedruckt. Mit der Zeit bleiben sie endlich in deinem Gehirn :-)

Wenn Sie nicht möchten, dass grb in Ihrem Namen Befehle ausführt, verwenden Sie einfach die Funktion "Erklären". Die Befehle werden auf Ihre Konsole gedruckt und nicht für Sie ausgeführt.

Schließlich haben alle Befehle Aliase, um das Speichern zu erleichtern.

Beachten Sie, dass dies Alpha-Software ist ;-)

Hier ist die Hilfe, wenn Sie die grb-Hilfe ausführen:

 git_remote_branch version 0.2.6 

 Verwendungszweck:

 grb create branch_name [Ursprungsserver] 

 grb publish Zweigname [Ursprungsserver] 

 grb benennt branch_name [Origin_server] 
.__ um. grb delete Zweigname [Ursprungsserver] 

 grb track branch_name [Origin_server] 



 Anmerkungen:
 - Wenn Origin_server nicht angegeben ist, wird der Name 'Origin' angenommen 
 (gits Standardeinstellung) 
 - Die Umbenennungsfunktion benennt den aktuellen Zweig um 

 Der Erklärungs-Meta-Befehl: Sie können jeden Befehl auch mit dem Schlüsselwort 
 'Erklären' voranstellen. Anstatt den Befehl auszuführen, gibt git_remote_branch 
 Einfach die Liste der Befehle aus, die Sie ausführen müssen, um 
 Dieses Ziel zu erreichen .

 Beispiel: 
 grb erklären erstellen 
 grb explain create my_branch github 

 Alle Befehle haben auch Aliase: 
 create: create, neu 
 löschen: löschen, zerstören, töten, entfernen, rm 
 Publizieren: Publizieren, Remotisieren 
 umbenennen: umbenennen, rn, mv, verschieben 
 track: verfolgen, folgen, greifen, holen 

alle Antworten, die ich hier gesehen habe, sind gültig, aber es gibt einen viel saubereren Weg, ein Repository zu klonen und alle Zweige gleichzeitig zu ziehen. 

Wenn Sie ein Repository klonen, werden zwar alle Informationen der Zweige heruntergeladen, die Zweige jedoch ausgeblendet. Mit dem Befehl

$ git branch -a

sie können alle Verzweigungen des Repositorys und mit dem Befehl anzeigen

$ git checkout -b branchname Origin/branchname

sie können sie dann manuell nacheinander "herunterladen". 

Wenn Sie jedoch ein Repo mit vielen Zweigen klonen möchten, sind alle oben dargestellten Wege langwierig und langweilig in Bezug auf einen viel saubereren und schnelleren Weg, den ich zeigen werde, obwohl dies 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 jetzt nur 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 (leeren) Repository in ein reguläres Repository, indem Sie den booleschen Wert "bare" der Git-Konfigurationen auf "false" setzen:

$ git config --bool core.bare false

3. Dritter Schritt

Besorgen Sie sich alles, was sich im aktuellen Ordner befindet, und erstellen Sie alle Verzweigungen auf dem lokalen Computer. Daher ist dies ein normales Repo. 

$ git reset --hard

Nun können Sie einfach den Befehl "git branch" eingeben und sehen, dass alle Verzweigungen heruntergeladen werden. 

Dies ist der schnelle Weg, auf dem Sie ein Git-Repository mit allen Zweigen gleichzeitig klonen können, aber auf diese Weise möchten Sie nicht jedes einzelne Projekt durchführen. 

Wenn ich mir eine der Antworten auf die Frage ansehe, habe ich festgestellt, dass es möglich ist, sie zu verkürzen:

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

Aber Vorsicht, wenn einer der entfernten Zweige als z. admin_master wird nicht heruntergeladen!

Danke an Bigfish für die originelle Idee

OK, wenn Sie Ihr Repo klonen, haben Sie alle Niederlassungen dort ...

Wenn Sie nur git branch tun, sind sie irgendwie versteckt ...

Wenn Sie also den Namen aller Zweige sehen möchten, fügen Sie einfach das Flag --all wie folgt hinzu:

git branch --all oder git branch -a

Wenn Sie nur zur Filiale auschecken, erhalten Sie alles, was Sie brauchen.

Aber wie wäre es, wenn der Zweig nach dem Klonen von jemand anderem erstellt wurde?

In diesem Fall machen Sie einfach:

git fetch

und überprüfe noch einmal alle Niederlassungen ...

Wenn Sie gleichzeitig abholen und auschecken möchten, können Sie Folgendes tun:

git fetch && git checkout your_branch_name

Außerdem wurde das Bild unten erstellt, um das, was ich gesagt habe, zu vereinfachen:

Klonen aus einem lokalen Repo funktioniert nicht mit git clone & git fetch.

Um einen Klon mit allen Zweigen und Tags zu erhalten.

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

So erhalten Sie einen Klon mit allen Verzweigungen und Tags, aber auch mit einer Arbeitskopie:

git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master

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

Dieser Code zieht den Code aller Remote-Zweigstellen in das lokale Repo.

Zum Kopieren und Einfügen in die Befehlszeile:

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

Für mehr Lesbarkeit:

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

1. check out master (damit wir den Zweig löschen können, in dem wir uns befinden)
2. select remote zum Auschecken (ändern Sie Ihre Remote-Fernbedienung)
3. Schleife durch alle Zweige der Fernbedienung außer Master und HEAD
   1. delete lokale Niederlassung (damit wir erzwungene Zweigstellen überprüfen können)
   2. check out Zweig von der Fernbedienung aus
4. check out master (der Sache zuliebe)

Basierend auf Antwort von VonC .

Ich habe diese kleinen Powershell - Funktionen geschrieben, um alle meine Git-Zweige, die sich auf Origin remote befinden, zu überprüfen.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "Origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>
}


Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>
}

Weitere Git-Funktionen finden Sie unter meine Git-Einstellungen Repo

Ich musste genau das gleiche tun. Hier ist mein Ruby Skript.

#!/usr/bin/env Ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  line.strip!
  if /Origin\//.match(line)
     remote[line.gsub(/Origin\//, '')] = line
   else
     local << line
   end
end
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]

Normalerweise holt Git (wenn nicht anders angegeben) alle Zweige und/oder Tags (refs, siehe: git ls-refs) aus einem oder mehreren anderen Repositories zusammen mit den Objekten, die zur Vervollständigung ihrer Historien erforderlich sind. Sie ruft also die Objekte ab, die von den bereits heruntergeladenen Objekten erreichbar sind. Siehe: Was macht git fetch wirklich?

Manchmal haben Sie möglicherweise Verzweigungen/Tags, die nicht direkt mit dem aktuellen verbunden sind. Daher hilft git pull --allgit fetch --all in diesem Fall nicht. Sie können sie jedoch auflisten:

git ls-remote -h -t Origin

und holen Sie sie manuell ab, indem Sie die Referenznamen kennen.

Um _/alle abholen, versuche:

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

^{Der --depth=10000-Parameter kann hilfreich sein, wenn das Repository flach ist.}

Dann überprüfen Sie noch einmal alle Ihre Niederlassungen:

git branch -avv

Wenn oben nichts hilft, müssen Sie die fehlenden Zweige manuell zur verfolgten Liste hinzufügen (da sie irgendwie verloren gegangen sind):

$ git remote -v show Origin
...
  Remote branches:
    master      tracked

von git remote set-branches wie:

git remote set-branches --add Origin missing_branch

so kann es nach dem Abruf unter remotes/Origin erscheinen:

$ git remote -v show Origin
...
  Remote branches:
    missing_branch new (next fetch will store in remotes/Origin)
$ git fetch
From github.com:Foo/Bar
 * [new branch]      missing_branch -> Origin/missing_branch

Fehlerbehebung

Wenn Sie immer noch nichts anderes als den Hauptzweig erhalten, prüfen Sie Folgendes:

• Überprüfen Sie Ihre Fernbedienungen (git remote -v), z. B.______.
  • Stellen Sie sicher, dass git config branch.master.remoteOrigin ist.
  • Prüfen Sie, ob Origin auf die richtige URL verweist: git remote show Origin (siehe post ).

Ab Anfang 2017 ist die Antwort in diesem Kommentar funktioniert:

git fetch <Origin-name> <branch-name> holt den Zweig für Sie herunter. Während dies nicht alle Zweige gleichzeitig zieht, können Sie diese pro Zweig einzeln ausführen.

Keine dieser Antworten schneidet es ab, außer Benutzer ist niemand auf dem richtigen Weg.

Ich hatte Probleme beim Verschieben eines Repos von einem Server/System auf einen anderen. Wenn ich das Repo geklont habe, wurde nur ein lokaler Zweig für den Master erstellt. Wenn ich also auf die neue Remote schiebe, wurde nur der Master-Zweig verschoben.

Also fand ich diese beiden Methoden sehr nützlich. Ich hoffe, sie helfen jemand anderem.

Methode 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git Push --all newrepo
git Push --tags newrepo

Methode 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git Push --all newrepo
git Push --tags newrepo

Verwenden Sie Befehle, die Sie sich merken können

Ich benutze Bitbucket, einen Repository-Hosting-Service von Atlassian. Also versuche ich, ihren Anweisungen zu folgen. Und das funktioniert perfekt für mich. Mit den folgenden einfachen und kurzen Befehlen können Sie Ihren Remote-Zweig auschecken.

Klonen Sie zunächst Ihr Repository und wechseln Sie dann in den Zielordner. Und nicht zuletzt holen und checkout ab:

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

Das ist es. Hier ein wenig mehr reales Beispiel:

git clone https://[email protected]/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Ausführliche Informationen zu den Befehlen finden Sie in den Dokumenten: Klonbefehl , Abrufbefehl , Checkoutbefehl

Hier ist ein weiterer kurzer Einzeiler-Befehl, mit dem Lokale Zweige für alle entfernten Zweige erstellt:

(git branch -r | sed -n '/->/!s#^  Origin/##p' && echo master) | xargs -L1 git checkout

Es funktioniert auch einwandfrei, wenn bereits lokale Zweigverfolgungsnachweise erstellt wurden. Sie können es nach dem ersten git clone oder zu einem späteren Zeitpunkt aufrufen.

Wenn Sie nach dem Klonen keine master-Verzweigung ausgecheckt haben müssen, verwenden Sie 

git branch -r | sed -n '/->/!s#^  Origin/##p'| xargs -L1 git checkout

Hier ist eine Antwort, die awk verwendet. Diese Methode sollte ausreichen, wenn sie für ein neues Repo verwendet wird.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

Bestehende Zweige werden einfach ausgecheckt oder als bereits enthalten deklariert. Es können jedoch Filter hinzugefügt werden, um Konflikte zu vermeiden.

Sie kann auch so geändert werden, dass ein expliziter Befehl git checkout -b <branch> -t <remote>/<branch> aufgerufen wird.

Diese Antwort folgt Nikos C. 's Idee .

Alternativ können wir stattdessen den entfernten Zweig angeben. Dies basiert auf murphytalk 's answer .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Es wirft schwerwiegende Fehlermeldungen auf Konflikte, aber ich sehe sie als harmlos an.

Beide Befehle können mit einem Alias ​​versehen werden.

Mit nobody 's answer als Referenz können wir die folgenden Befehle zum Erstellen der Aliase verwenden:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Persönlich würde ich track-all oder track-all-branches verwenden.

git clone --mirror auf dem Original-Repo ist dafür gut geeignet.

git clone --mirror /path/to/original.git
git remote set-url Origin /path/to/new-repo.git
git Push -u Origin

Ich werde hier meine 2 Cent hinzufügen, weil ich hierhergekommen bin, um herauszufinden, wie man einen entfernten Zweig herunterzieht, den ich lokal gelöscht habe. Origin gehörte nicht mir, und ich wollte nicht die Mühe machen, alles neu zu klonen 

Das hat für mich funktioniert:

vorausgesetzt, Sie müssen den Zweig lokal neu erstellen:

git checkout -b recreated-branch-name
git branch -a (to list remote branches)
git rebase remotes/remote-Origin/recreated-branch-name

Wenn ich also von gituser/master zu sjp ging und es dann zu sjp/mynewbranch verzweigte, würde es so aussehen:

$ git checkout -b mynewbranch
$ git branch -a
  master
  remotes/sjp/master
  remotes/sjp/mynewbranch
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch

Ein bisschen zu spät zur Party, aber ich denke, das macht den Trick:

mkdir YourRepo
cd YourRepo
git init --bare .git                       # create a bare repo
git remote add Origin REMOTE_URL           # add a remote
git fetch Origin refs/heads/*:refs/heads/* # fetch heads
git fetch Origin refs/tags/*:refs/tags/*   # fetch tags
git init                                   # reinit work tree
git checkout master                        # checkout a branch

Wenn dies etwas unerwünschtes tut, würde ich gerne wissen. Bisher klappt das aber bei mir.

Bei dieser Variante wird ein Remote-Repo mit allen lokal verfügbaren Zweigen geklont, ohne dass Sie jeden Zweig einzeln überprüfen müssen. Es werden keine ausgefallenen Skripte benötigt.

Erstellen Sie einen Ordner mit dem gleichen Namen des Repos, in den Sie kopieren möchten, und cd, zum Beispiel:

mkdir somerepo
cd somerepo

Führen Sie diese Befehle jetzt mit dem tatsächlichen Repo-Benutzernamen/Reponame aus 

git clone --bare [email protected]:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch

Voiala! Sie haben alle Niederlassungen dort!

Hier ist ein Bash-Skript zum Abrufen aller Zweige und Tags eines git-Projekts als Momentaufnahmen in separaten Ordnern. 

https://Gist.github.com/hfossli/7562257

Vielleicht nicht das, was direkt gefragt wurde, aber vielleicht kommen einige Leute hierher, um nach einer Lösung zu suchen.