Jeśli masz wiele zdalnych gałęzi, które chcesz pobrać jednocześnie, wykonaj:

$ git pull --all

Teraz możesz wymeldować dowolną gałąź, bez wchodzenia w zdalne repozytorium.

Ten skrypt Bash pomógł mi:

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

Utworzy gałęzie śledzące dla wszystkich gałęzi zdalnych, z wyjątkiem master (który prawdopodobnie otrzymałeś z oryginalnego polecenia klonowania). I think you might still need to do a

git fetch --all
git pull --all

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 Jak zwykle: przetestuj w swojej konfiguracji przed skopiowaniem rm-rf universe as we know it

podziękowania dla one-liner go to user cfi

Użycie opcji --mirror wydaje się poprawnie kopiować gałęzie śledzące remote. Jednak, ustawia repozytorium jako gołe repozytorium, więc trzeba przekształcić go z powrotem do normalnego repozytorium później.

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

^{Reference: GIT FAQ: Jak sklonować repozytorium ze wszystkimi zdalnie śledzonymi gałęziami?}

Możesz łatwo przełączyć się na gałąź bez użycia wymyślnej składni "Git checkout-B somebranch origin/somebranch". Można po prostu zrobić:

git checkout somebranch

Git automatycznie zrobi dobrze:

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

Git sprawdzi, czy gałąź o tej samej nazwie istnieje dokładnie w jednym zdalnym, a jeśli tak, to śledzi ją w ten sam sposób, jak gdybyś wyraźnie określił, że jest to zdalna gałąź. Ze strony podręcznika Git-checkout Git 1.8.2.1:

Jeśli nie został znaleziony, ale istnieje gałąź śledzenia w dokładnie jeden pilot (nazwij go ) o pasującej nazwie, traktuj jako odpowiednik

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

Odnośnie,

$ git checkout-b experimental origin / experimental

Użycie

$ git checkout -t origin/experimental

Lub bardziej gadatliwy, ale łatwiejszy do zapamiętania

$ git checkout --track origin/experimental

Może być lepiej, jeśli chodzi o śledzenie zdalnego repozytorium.

Fetch, który robisz, powinien pobrać wszystkie zdalne gałęzie, ale nie utworzy dla nich lokalnych gałęzi. Jeśli używasz gitk, powinieneś zobaczyć zdalne gałęzie opisane jako "remotes / origin/dev" lub coś podobnego.

Aby utworzyć lokalną gałąź opartą na gałęzi zdalnej, wykonaj coś w stylu:

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

Który powinien zwrócić coś w stylu:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

Teraz, gdy jesteś na gałęzi dev ," git pull " zaktualizuje lokalny dev do tego samego punktu co zdalna gałąź dev. Zauważ, że pobierze wszystkie gałęzie, ale pociągnie tylko tę, na której jesteś na szczycie drzewa.

Kiedy wykonasz "git clone git: / / location", wszystkie gałęzie i Tagi są pobierane.

W celu pracy nad określoną odległą gałęzią, zakładając, że jest to origin remote:

git checkout -b branch origin/branchname

Użyj aliasów. Chociaż nie ma żadnych natywnych jednowierszowych Gita, możesz zdefiniować swoje własne jako

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

A następnie użyj go jako

git clone-branches

To nie jest zbyt skomplikowane, bardzo proste i proste kroki do przodu są następujące;

git fetch origin spowoduje to przeniesienie wszystkich odległych oddziałów do lokalnego.

git branch -a to pokaże Ci wszystkie odległe gałęzie.

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

Sprawdź, czy jesteś w żądanej gałęzi za pomocą następującego polecenia;

git branch

Wynik będzie taki;

*your current branch 
some branch2
some branch3 

Zwróć uwagę na znak * oznaczający bieżącą gałąź.

Dlaczego widzisz tylko "mistrza"

git clone pobiera wszystkie zdalne zdalne gałęzie, ale nadal uważa je za "zdalne", mimo że pliki znajdują się w nowym repozytorium. Jest jeden wyjątek od tego, że proces klonowania tworzy lokalną gałąź o nazwie "master "ze zdalnej gałęzi o nazwie"master". Domyślnie git branch pokazuje tylko lokalne gałęzie, dlatego widzisz tylko "master".

git branch -a pokazuje wszystkie gałęzie, w tym zdalne gałęzie .

Jak zdobyć lokalne oddziały

Jeśli chcesz pracować nad gałęzią, prawdopodobnie będziesz potrzebował jej "lokalnej" wersji. Aby po prostu utworzyć lokalne gałęzie ze zdalnych gałęzi (bez sprawdzania ich i zmieniania zawartości katalogu roboczego) , możesz to zrobić w następujący sposób:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

W tym przykładzie, branchone jest nazwą lokalnej gałęzi, którą tworzysz na podstawie origin/branchone. różne nazwy, można to zrobić:

git branch localbranchname origin/branchone

Po utworzeniu lokalnej gałęzi możesz ją zobaczyć za pomocą git branch (pamiętaj, że nie potrzebujesz -a, aby zobaczyć lokalne gałęzie).

Lepiej późno niż wcale, ale tutaj jest najlepszy sposób, aby to zrobić:

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

W tym momencie masz kompletną kopię zdalnego repo ze wszystkimi jego gałęziami(zweryfikuj za pomocą git branch). Możesz użyć --mirror zamiast --bare, Jeśli twój zdalny repo ma własne piloty.

Po prostu zrób to:

$ 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

Widzisz, 'git clone git: / / example. com / myprojectt' pobiera wszystko, nawet gałęzie, po prostu musisz je sprawdzić, wtedy zostanie utworzona Twoja lokalna gałąź.

Wystarczy użyć "git clone", aby uzyskać wszystkie gałęzie.

git clone <your_http_url>

Nawet jeśli widzisz tylko gałąź master, możesz użyć "git branch-a", aby zobaczyć wszystkie gałęzie.

git branch -a

I możesz przełączyć się na dowolną gałąź, którą już posiadasz.

git checkout <your_branch_name>

Nie martw się, że po "git clone", nie musisz łączyć się ze zdalnym repo, "Git branch-A" i "GIT checkout" mogą być uruchomione pomyślnie po zamknięciu wifi. Udowodniono więc, że kiedy robisz "git clone", to już skopiowałem wszystkie gałęzie ze zdalnego repo. Po tym nie potrzebujesz zdalnego repo, twój lokalny ma już kody wszystkich oddziałów.

A git clone mA kopiować całe repozytorium. Spróbuj go sklonować, a następnie uruchom git branch -a. Powinna zawierać listę wszystkich gałęzi. Jeśli chcesz przełączyć się na gałąź " foo "zamiast " master", użyj git checkout foo.

Użyj mojego narzędzia git_remote_branch (potrzebujesz Rubiego zainstalowanego na twoim komputerze). Został zbudowany specjalnie po to, aby zdalne manipulacje gałęziami były łatwe.

Za każdym razem, gdy wykonuje operację w Twoim imieniu, drukuje ją na czerwono na konsoli. Z czasem w końcu wbijają się w twój mózg: -)

Jeśli nie chcesz, aby grb uruchamiał polecenia w Twoim imieniu, po prostu użyj funkcji "explain". Polecenia będą drukowane na konsoli, a nie wykonywane za Ciebie.

Wreszcie, wszystkie polecenia mają aliasy, aby ułatwić zapamiętywanie.

Zauważ, że jest to alpha software ;-)

Oto pomoc przy uruchomieniu grb help:

git_remote_branch version 0.2.6

  Usage:

  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Notes:
  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

  Example: 
    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

Wszystkie odpowiedzi, które tu widziałem są poprawne, ale istnieje znacznie czystszy sposób na sklonowanie repozytorium i wyciągnięcie wszystkich gałęzi na raz.

Po sklonowaniu repozytorium wszystkie informacje o gałęziach są faktycznie pobierane, ale gałęzie są ukryte. Za pomocą polecenia

$ git branch -a

Możesz wyświetlić wszystkie gałęzie repozytorium, a za pomocą polecenia

$ git checkout -b branchname origin/branchname

Możesz następnie" pobrać " je ręcznie pojedynczo.

Jednak, gdy chcesz sklonować repo z wieloma gałęziami wszystkie sposoby zilustrowane powyżej są długie i żmudne w odniesieniu do znacznie czystszego i szybszego sposobu, który zamierzam pokazać, choć jest to nieco skomplikowane. Aby to osiągnąć, potrzebne są trzy kroki:

1. pierwszy krok

Utwórz nowy pusty folder na swoim komputerze i Sklonuj kopię lustrzaną .folder git z repozytorium:

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

Lokalne repozytorium wewnątrz folderu my_repo_folder jest nadal puste, jest tylko Ukryty .git folder, który możesz teraz zobaczyć poleceniem "ls-alt" z terminala.

1. drugi krok

Przełącz to repozytorium z pustego (gołego) repozytorium na zwykłe, zmieniając wartość logiczną "bare" konfiguracji Gita na false:

$ git config --bool core.bare false

1. Trzeci Krok

Chwyć wszystko, co znajduje się w bieżącym folderze i utwórz wszystkie gałęzie na lokalnej maszynie, czyniąc to normalnym repo.

$ git reset --hard

Więc teraz możesz po prostu wpisz polecenie "Git branch" i zobaczysz, że wszystkie gałęzie są pobrane.

Jest to szybki sposób, w jaki możesz sklonować repozytorium git ze wszystkimi gałęziami naraz, ale nie jest to coś, co chcesz zrobić dla każdego projektu w ten sposób.

Patrząc na jedną z odpowiedzi na pytanie zauważyłem, że można je skrócić:

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

Ale uważaj, jeśli jedna ze zdalnych gałęzi zostanie nazwana np. admin_master, nie zostanie pobrana!

Podziękowania dla bigfish za oryginalny pomysł

OK, kiedy sklonujesz repo, masz tam wszystkie gałęzie...

Jeśli tylko to zrobisz git branch, są one jakby Ukryte...

Więc jeśli chcesz zobaczyć nazwę wszystkich gałęzi, po prostu dodaj --all flagę w ten sposób:

git branch --all lub git branch -a

Ale co jeśli gałąź stworzona przez kogoś innego po sklonowaniu?

W tym przypadku po prostu zrób:

git fetch

I sprawdź wszystkie gałęzie jeszcze raz...

Jeśli lubisz pobierać i kasować w tym samym czasie, możesz zrobić:

git fetch && git checkout your_branch_name

Również stworzył poniższy obrazek, aby uprościć to, co powiedziałem:

Do kopiowania i wklejania w wierszu poleceń:

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

Dla większej czytelności:

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. sprawdź master (abyśmy mogli usunąć gałąź, na której jesteśmy)
2. Wybierz zdalny do kasy (zmień go na dowolny pilot, który posiadasz)
3. Pętla przez wszystkie gałęzie pilota z wyjątkiem master i HEAD
   1. Usuń lokalny oddział (abyśmy mogli sprawdzić zaktualizowane oddziały)
   2. sprawdź out branch from the remote
4. check out master (for the sake of it)

na podstawie odpowiedzi Z VonC.

#!/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

Ten kod spowoduje pobranie kodu wszystkich zdalnych gałęzi do lokalnego repo.

Klonowanie z lokalnego repo nie będzie działać z git clone & git fetch: wiele gałęzi / tagów pozostanie niezabezpieczonych.

Aby uzyskać klon ze wszystkimi gałęziami i tagami.

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

Aby uzyskać klon ze wszystkimi gałęziami i tagami, ale także z roboczą kopią:

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

Musiałem zrobić dokładnie to samo. Oto mój skrypt Ruby .

#!/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]

Napisałem tę małą funkcję Powershell, aby móc sprawdzić wszystkie moje gałęzie git, które są na origin remote.

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>' #>
}

Więcej funkcji git można znaleźć na Moje ustawienia git repo

Używaj poleceń, które możesz zapamiętać

Najpierw Sklonuj swoje repozytorium, a następnie przejdź do folderu docelowego. I wreszcie aport i kasa:

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

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

Znajdziesz szczegóły informacje o poleceniach w dokumentach: Polecenie Klon, Polecenie Fetch, Polecenie Checkout

Git zazwyczaj (jeśli nie jest określony) pobiera wszystkie gałęzie i / lub znaczniki (refs, zobacz: git ls-refs) z jednego lub więcej repozytoriów wraz z obiektami niezbędnymi do uzupełnienia ich historii. Innymi słowy pobiera obiekty, które są dostępne dla obiektów, które zostały już pobrane. Zobacz: co naprawdę robi git fetch?

Czasami możesz mieć gałęzie/tagi, które nie są bezpośrednio połączone z bieżącym, więc git pull --all/git fetch --all nie pomoże w tym przypadku, ale można wymienić them by:

git ls-remote -h -t origin

I pobrać je ręcznie, znając nazwy ref.

Więc aby pobrać je wszystkie, spróbuj:

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

^{parametr --depth=10000 może pomóc, jeśli masz spłycone repozytorium.}

Następnie sprawdź ponownie wszystkie gałęzie:

git branch -avv

Jeśli powyższe nie pomoże, musisz ręcznie dodać brakujące gałęzie do śledzonej listy (ponieważ jakoś się zgubiły): {]}

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

By git remote set-branches like:

git remote set-branches --add origin missing_branch

Więc może pojawić się pod remotes/origin po pobraniu:

$ 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

Rozwiązywanie problemów

Jeśli nadal nie możesz uzyskać niczego innego niż gałąź master, sprawdź następujące czynności:

• dwukrotnie Sprawdź swoje piloty (git remote -v), np.
  • potwierdź, że git config branch.master.remote jest origin.
  • sprawdź, czy origin wskazuje na właściwy adres URL poprzez: git remote show origin (zobacz ten post).

Od początku 2017 roku odpowiedź w tym komentarzu działa:

git fetch <origin-name> <branch-name> / align = "left" / Chociaż nie powoduje to ściągnięcia wszystkich gałęzi naraz, możesz wykonać to pojedynczo dla każdej gałęzi.

Żadna z tych odpowiedzi go nie przecięła, z wyjątkiem user nobody is on the right track.

Metoda 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

Metoda 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

Oto kolejna krótka Komenda jednotorowa, która tworzy lokalne gałęzie dla wszystkich gałęzi zdalnych:

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

Działa również poprawnie, jeśli śledzenie lokalnych gałęzi jest już utworzone. Możesz go nazwać po pierwszym git clone lub w dowolnym momencie później.

Jeśli nie musisz sprawdzać gałęzi master po klonowaniu, użyj

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

Dodam tu swoje 2 centy, bo znalazłem się tutaj, próbując dowiedzieć się, jak ściągnąć zdalną gałąź, którą usunąłem lokalnie. Pochodzenie nie było moje i nie chciałem przechodzić przez kłopoty z ponownym klonowaniem wszystkiego

To mi pomogło:

Zakładając, że musisz odtworzyć gałąź lokalnie:

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

Więc gdybym rozwidlił z gituser / master do SJP, a następnie rozgałęził go do sjp / mynewbranch, wyglądałby tak:

$ 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