Wie klone ich alle Remote-Zweige in Git?

Ich habe einen masterund einen developmentZweig, beide auf GitHub geschoben . Ich habe cloned, pulled und fetched, aber ich kann nichts anderes als den masterZweig zurückbekommen.

Ich bin mir sicher, dass mir etwas Offensichtliches fehlt, aber ich habe das Handbuch gelesen und bekomme überhaupt keine Freude.

Klonen Sie zunächst ein entferntes Git- Repository und eine CD darin:

$ git clone git://example.com/myproject
$ cd myproject

Schauen Sie sich als Nächstes die lokalen Zweige in Ihrem Repository an:

$ git branch
* master

Aber es gibt noch andere Zweige, die sich in Ihrem Repository verstecken! Sie können diese mit der -aFlagge sehen:

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

Wenn Sie nur einen kurzen Blick auf eine vorgelagerte Filiale werfen möchten, können Sie dies direkt überprüfen:

$ git checkout origin/experimental

Wenn Sie jedoch an diesem Zweig arbeiten möchten, müssen Sie einen lokalen Tracking-Zweig erstellen, der automatisch durchgeführt wird von:

$ git checkout experimental

und du wirst sehen

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Diese letzte Zeile wirft einige Leute: "Neuer Zweig" - nicht wahr? Was es wirklich bedeutet, ist, dass der Zweig aus dem Index genommen und lokal für Sie erstellt wird. Die vorherige Zeile ist tatsächlich informativer, da sie Ihnen sagt, dass der Zweig so eingerichtet ist, dass er den Remote-Zweig verfolgt, was normalerweise den Zweig origin / branch_name bedeutet

Wenn Sie sich nun Ihre lokalen Niederlassungen ansehen, sehen Sie Folgendes:

$ git branch
* experimental
  master

Sie können tatsächlich mehr als ein Remote-Repository mit verfolgen git remote.

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

An diesem Punkt werden die Dinge ziemlich verrückt, also renn gitklos , um zu sehen, was los ist:

$ gitk --all &

Wenn Sie viele Remote-Zweige haben, die Sie gleichzeitig abrufen möchten, gehen Sie wie folgt vor:

$ git pull --all

Jetzt können Sie jeden Zweig nach Bedarf auschecken, ohne auf das Remote-Repository zuzugreifen.

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 Remote-Zweige erstellt, mit Ausnahme des Masters (den Sie wahrscheinlich vom ursprünglichen Klonbefehl erhalten haben). Ich denke, Sie müssen möglicherweise noch eine tun

git fetch --all
git pull --all

um sicher zu sein.

Ein 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 Ihr Setup, bevor Sie das bekannte rm -rf-Universum kopieren

Credits für Einzeiler gehen an Benutzer cfi

Die Verwendung der --mirrorOption scheint die remoteTracking-Zweige ordnungsgemäß zu kopieren . Das Repository wird jedoch als nacktes 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 klone ich ein Repository mit allen remote verfolgten Zweigen?}

Sie können ganz einfach zu einem Zweig wechseln, ohne die ausgefallene Syntax "git checkout -b somebranch origin / somebranch" 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 Fernbedienung vorhanden ist. Wenn dies der Fall ist, wird er auf dieselbe Weise verfolgt, als hätten Sie ausdrücklich angegeben, dass es sich um eine Fernverzweigung handelt. Aus der Git-Checkout-Manpage von Git 1.8.2.1:

Wenn <branch> nicht gefunden wird, aber in genau einer Fernbedienung ein Tracking-Zweig (nennen Sie ihn <remote>) mit einem übereinstimmenden Namen vorhanden ist, behandeln Sie ihn als äquivalent zu

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

Bezüglich,

$ git checkout -b experimenteller Ursprung / experimentell

mit

$ git checkout -t origin/experimental

oder umso ausführlicher, aber leichter zu merken

$ git checkout --track origin/experimental

könnte besser sein, wenn es darum geht, ein Remote-Repository zu verfolgen.

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

Gehen Sie folgendermaßen vor, um einen lokalen Zweig basierend auf einem Remote-Zweig zu erstellen:

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

Welches sollte etwas zurückgeben wie:

Zweigentwickler eingerichtet, um entfernte Zweigstellenreferenzen / Fernbedienungen / Ursprung / Entwickler zu verfolgen.
Zu einem neuen Zweig "dev" gewechselt

Wenn Sie sich jetzt im Entwicklungszweig befinden, aktualisiert "git pull" Ihren lokalen Entwickler auf den gleichen Punkt wie den Remote-Entwicklungszweig. Beachten Sie, dass alle Zweige abgerufen werden, aber nur der, auf dem Sie sich befinden, an die Spitze des Baums gezogen wird.

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

Um auf einem bestimmten Remote-Zweig zu arbeiten, wird davon ausgegangen, dass es sich um den Ursprungs-Remote handelt:

git checkout -b branch origin/branchname

Verwenden Sie Aliase. Obwohl es keine nativen Git-Einzeiler gibt, können Sie Ihre eigenen als 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 als

git clone-branches

Warum Sie nur "Meister" sehen

git cloneLädt alle Remote-Zweige herunter, betrachtet sie jedoch weiterhin als "Remote", obwohl sich die Dateien in Ihrem neuen Repository befinden. Es gibt eine Ausnahme: Der Klonprozess erstellt einen lokalen Zweig namens "master" aus dem Remote-Zweig namens "master". Standardmäßig werden git branchnur lokale Zweige angezeigt, weshalb nur "master" angezeigt wird .

git branch -azeigt alle Zweige an, einschließlich entfernter Zweige .

So erhalten Sie lokale Niederlassungen

Wenn Sie tatsächlich an einem Zweig arbeiten möchten, benötigen Sie wahrscheinlich eine "lokale" Version davon. Um einfach lokale Zweige aus entfernten Zweigen 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 branchoneist dies der Name eines lokalen Zweigs, auf dessen Grundlage Sie erstellen origin/branchone. Wenn Sie stattdessen lokale Zweige mit unterschiedlichen Namen erstellen möchten, können Sie dies tun:

git branch localbranchname origin/branchone

Sobald Sie einen lokalen Zweig erstellt haben, können Sie ihn mit git branchanzeigen (denken Sie daran, dass Sie keine -alokalen Zweige sehen müssen).

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

git fetch origin Dadurch werden alle Remote-Zweigstellen zu Ihrem lokalen Zweig gebracht.

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 in der gewünschten Verzweigung 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.

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 Zweigen (überprüfen mit git branch). Sie können --mirrorstattdessen verwenden, --barewenn Ihr Remote-Repo über eigene Fernbedienungen verfügt.

Mach das einfach:

$ 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, auch 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 den Hauptzweig sehen, können Sie mit "git branch -a" alle Zweige anzeigen.

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-Klonen" keine Verbindung zum Remote-Repo herstellen müssen. "Git-Zweig -a" und "Git-Checkout" können erfolgreich ausgeführt werden, wenn Sie Ihr WLAN schließen. Es ist also bewiesen, dass beim Ausführen von "git clone" bereits alle Zweige aus dem Remote-Repo kopiert wurden. Danach benötigen Sie das Remote-Repo nicht mehr, Ihr lokaler hat bereits alle Filialcodes.

A git clonesoll das gesamte Repository kopieren. Versuchen Sie es zu klonen und führen Sie es dann aus git branch -a. Es sollte alle Zweige auflisten. Wenn Sie dann zu Zweig "foo" anstelle von "master" 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 entwickelt, um die Manipulation von Fernzweigen zum Kinderspiel 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 Befehle in Ihrem Namen ausführt, verwenden Sie einfach die Funktion "EXPLAIN". Die Befehle werden auf Ihrer Konsole gedruckt und nicht für Sie ausgeführt.

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

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

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

git_remote_branch Version 0.2.6

  Verwendungszweck:

  grb create branch_name [origin_server] 

  grb publiziere branch_name [origin_server] 

  grb umbenennen branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Anmerkungen:
  - Wenn origin_server nicht angegeben ist, wird der Name 'origin' angenommen 
    (gits Standard)
  - Die Umbenennungsfunktion benennt den aktuellen Zweig um

  Der EXPLAIN-Meta-Befehl: Sie können jedem Befehl auch den Befehl voranstellen 
Schlüsselwort 'erklären'. Anstatt den Befehl auszuführen, git_remote_branch
gibt einfach die Liste der Befehle aus, die Sie ausführen müssen, um sie auszuführen 
dieses Ziel.

  Beispiel: 
    grb erklären erstellen
    grb EXPLAIN Erstelle my_branch Github

  Alle Befehle haben auch Aliase:
  erstellen: erstellen, neu
  löschen: löschen, zerstören, töten, entfernen, rm
  veröffentlichen: veröffentlichen, remotisieren
  umbenennen: umbenennen, rn, mv, verschieben
  track: verfolgen, folgen, greifen, holen

Alle Antworten, die ich hier gesehen habe, sind gültig, aber es gibt eine viel sauberere Möglichkeit, ein Repository zu klonen und alle Zweige gleichzeitig abzurufen.

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

Wenn Sie jedoch ein Repo mit vielen Zweigen klonen möchten, sind alle oben dargestellten Methoden langwierig und langwierig in Bezug auf eine viel sauberere und schnellere Methode, die ich zeigen werde, obwohl sie 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 "git branch" eingeben und 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.

Das Klonen von einem lokalen Repo funktioniert nicht mit git clone & git fetch: Viele Zweige / Tags bleiben nicht abgerufen.

So erhalten Sie einen Klon mit allen Zweigen und Tags.

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

So erhalten Sie einen Klon mit allen Zweigen 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

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

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

Wenn Sie also den Namen aller Zweige sehen möchten, fügen Sie einfach ein --allFlag wie das folgende 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 von jemand anderem erstellt wird, nachdem Sie geklont haben?

In diesem Fall machen Sie einfach:

git fetch

und überprüfen Sie alle Zweige erneut ...

Wenn Sie gleichzeitig abrufen und auschecken möchten, haben Sie folgende Möglichkeiten:

git fetch && git checkout your_branch_name

Außerdem haben Sie das folgende Bild erstellt, um das zu vereinfachen, was ich gesagt habe:

Als ich mir eine der Antworten auf die Frage ansah, bemerkte ich, 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 Remote-Zweige zB admin_master heißt, wird er nicht heruntergeladen!

Vielen Dank an Bigfish für die originelle Idee

#!/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 gesamten Code der Remote-Zweige 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. Wählen Sie die Fernbedienung zum Auschecken aus (ändern Sie sie in eine beliebige Fernbedienung).
3. Durchlaufen Sie alle Zweige der Fernbedienung mit Ausnahme von Master und HEAD
   1. lokalen Zweig löschen (damit wir zwangsaktualisierte Zweige auschecken können)
   2. Überprüfen Sie den Zweig von der Fernbedienung
4. check out master (um es zu tun)

Basierend auf der Antwort von VonC .

Ich habe diese kleinen Powershell- Funktionen geschrieben, um alle meine Git-Zweige auschecken zu können, die sich auf der Ursprungsfernbedienung befinden.

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 in meinem Git-Einstellungen-Repo

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 darin deklariert. Es können jedoch Filter hinzugefügt werden, um Konflikte zu vermeiden.

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

Diese Antwort folgt Nikos C. ‚s Idee .

Alternativ können wir stattdessen den Remote-Zweig angeben. Dies basiert auf der Antwort von Murphytalk .

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

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

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

Wenn Sie die Antwort von niemandem als Referenz verwenden, können Sie 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-alloder verwenden track-all-branches.

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]

Keine dieser Antworten hat es geschafft, außer dass Benutzer niemand auf dem richtigen Weg ist.

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

Daher fand ich diese beiden Methoden SEHR nützlich. 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

git clone --mirror auf dem Original-Repo funktioniert das gut.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin

Git ruft normalerweise (wenn nicht angegeben) alle Zweige und / oder Tags (Refs, siehe :) git ls-refsaus einem oder mehreren anderen Repositorys zusammen mit den Objekten ab, die zum Vervollständigen ihrer Historien erforderlich sind. Mit anderen Worten, es werden die Objekte abgerufen, die von den bereits heruntergeladenen Objekten erreichbar sind. Siehe: Was macht das git fetchwirklich?

Manchmal haben Sie möglicherweise Zweige / Tags, die nicht direkt mit dem aktuellen verbunden sind. In diesem Fall hilft git pull --all/ git fetch --allhilft dies nicht, aber Sie können sie auflisten, indem Sie:

git ls-remote -h -t origin

und holen Sie sie manuell, indem Sie die Ref-Namen kennen.

Um sie alle zu holen , versuchen Sie:

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

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

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

git branch -avv

Wenn dies nicht hilft, müssen Sie fehlende Zweige manuell zur nachverfolgten Liste hinzufügen (da sie irgendwie verloren gegangen sind):

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

von git remote set-brancheswie:

git remote set-branches --add origin missing_branch

so kann es unter remotes/originnach dem Abrufen 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 können, überprüfen Sie Folgendes:

• Überprüfen Sie Ihre Fernbedienungen ( git remote -v), z
  • Überprüfen Sie das git config branch.master.remoteist origin.
  • Überprüfen Sie, ob originauf die richtige URL verweist über: git remote show origin(siehe diesen Beitrag ).

Ab Anfang 2017 funktioniert die Antwort in diesem Kommentar :

git fetch <origin-name> <branch-name>bringt den Zweig für Sie herunter. Dies zieht zwar nicht alle Zweige gleichzeitig, Sie können diesen Zweig jedoch einzeln ausführen.

Hier ist ein weiterer kurzer einzeiliger Befehl, der 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 ordnungsgemäß, wenn bereits lokale Zweigstellen erstellt wurden. Sie können es nach dem ersten git cloneoder jederzeit später aufrufen .

Wenn Sie masternach dem Klonen keinen Zweig auschecken müssen, verwenden Sie

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