Jak pobrać wszystkie gałęzie Git

Sklonowałem repozytorium Git, które zawiera około pięciu gałęzi. Jednak kiedy to git branchwidzę, widzę tylko jedną z nich:

$ git branch
* master

Wiem, że mogę zrobić, git branch -aaby zobaczyć wszystkie gałęzie, ale jak miałbym wyciągnąć wszystkie gałęzie lokalnie, więc kiedy to zrobię git branch, pokazuje to?

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

Możesz pobrać wszystkie gałęzie ze wszystkich pilotów w ten sposób:

git fetch --all

Zasadniczo jest to ruch siłowy .

fetchaktualizuje lokalne kopie zdalnych oddziałów, więc jest to zawsze bezpieczne dla lokalnych oddziałów, ALE :

1. fetchnie aktualizuje oddziałów lokalnych (które śledzą oddziały zdalne); jeśli chcesz zaktualizować swoje lokalne oddziały, nadal musisz pobrać każdy oddział.

2. fetchnie utworzy oddziałów lokalnych (które śledzą oddziały zdalne), musisz to zrobić ręcznie. Jeśli chcesz wyświetlić listę wszystkich zdalnych gałęzi: git branch -a

Aby zaktualizować lokalne oddziały, które śledzą oddziały zdalne:

git pull --all

Może to jednak nadal być niewystarczające. Będzie działać tylko dla lokalnych oddziałów, które śledzą oddziały zdalne. Aby śledzić wszystkie odległe gałęzie, uruchom ten oneliner PRZED git pull --all :

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

Wersja TL; DR

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

(Wygląda na to, że pull pobiera wszystkie gałęzie ze wszystkich pilotów, ale zawsze pobieram najpierw, aby się upewnić).

Uruchom pierwszą komendę tylko wtedy, gdy na serwerze znajdują się zdalne gałęzie, które nie są śledzone przez lokalne oddziały.

PS AFAIK git fetch --alli git remote updatesą równoważne.

Komentarz Kamila Szota , który uznał za użyteczny.

Musiałem użyć:

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

ponieważ twój kod utworzył lokalne oddziały o nazwie, origin/branchnamea ja otrzymywałem „refname 'origin / branchname” jest dwuznaczny za każdym razem, gdy o nim mówiłem.

Aby wyświetlić listę zdalnych oddziałów:
git branch -r

Możesz je sprawdzić jako lokalne oddziały za pomocą:
git checkout -b LocalName origin/remotebranchname

Konieczne będzie utworzenie oddziałów lokalnych śledzących oddziały zdalne.

Zakładając, że masz tylko jednego pilota o nazwie origin, ten fragment utworzy lokalne oddziały dla wszystkich zdalnych śledzenia:

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

Następnie git fetch --allzaktualizuje wszystkie lokalne kopie zdalnych oddziałów.

Ponadto git pull --allzaktualizuje lokalne gałęzie śledzenia, ale w zależności od lokalnych zatwierdzeń i tego, jak ustawiona jest opcja konfiguracji „scalania”, może utworzyć zatwierdzenie scalania, szybkie przewijanie do przodu lub niepowodzenie.

Jeśli zrobisz:

git fetch origin

wtedy będą wszyscy lokalnie. Jeśli następnie wykonasz:

git branch -a

zobaczysz je na liście jako piloty / pochodzenie / nazwa oddziału. Ponieważ są tam lokalnie, możesz robić z nimi, co tylko chcesz. Na przykład:

git diff origin/branch-name 

lub

git merge origin/branch-name

lub

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

$ git remote update
$ git pull --all

Zakłada się, że wszystkie gałęzie są śledzone.

Jeśli nie są, możesz wystrzelić to w Bash:

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

Następnie uruchom polecenie.

forPętla Bash nie działała dla mnie, ale działało dokładnie tak, jak chciałem. Wszystkie gałęzie z mojego pochodzenia odzwierciedlone lokalnie jako ta sama nazwa.

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

Zobacz komentarz Mike'a DuPont poniżej. Myślę, że próbowałem to zrobić na serwerze Jenkins, który pozostawia go w trybie odłączonej głowy.

Zastosowanie git fetch && git checkout RemoteBranchName.

Działa dla mnie bardzo dobrze ...

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 i za pomocą polecenia

$ git checkout -b branchname origin/branchname

możesz następnie „ręcznie” pobrać je pojedynczo.

Jest jednak dużo czystszy i szybszy sposób, choć jest to nieco skomplikowane. Aby to osiągnąć, musisz wykonać trzy kroki:

1. Pierwszy krok

   utwórz nowy pusty folder na swoim komputerze i klonuj kopię lustrzaną folderu .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 w folderze my_repo_folder jest nadal puste, jest teraz tylko ukryty folder .git, który można zobaczyć za pomocą polecenia „ls -alt” z terminala.

2. Drugi krok

   przełącz to repozytorium z pustego (pustego) do zwykłego, zmieniając wartość logiczną „gołą” konfiguracji git na false:

   $ git config --bool core.bare false
   

3. Trzeci krok

   Chwyć wszystko, co znajduje się w bieżącym folderze i utwórz wszystkie gałęzie na komputerze lokalnym, dzięki czemu jest to normalne repo.

   $ git reset --hard
   

Teraz możesz po prostu wpisać polecenie git branch i możesz zobaczyć, że wszystkie gałęzie zostały pobrane.

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

Możesz pobrać wszystkie gałęzie, wykonując:

git fetch --all

lub:

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

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

Aby wyciągnąć wszystkie gałęzie, użyj:

git pull --all

Jeśli powyższe nie zadziała, poprzedź powyższe polecenie:

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

jak remote.origin.fetch może obsługiwać tylko konkretną gałąź podczas pobierania, szczególnie gdy klonujesz swoje repozytorium --single-branch. Sprawdź to: git config remote.origin.fetch.

Następnie powinieneś mieć możliwość kasy dowolnego oddziału.

Zobacz też:

• Jak pobrać wszystkie odległe gałęzie?
• Jak sklonować wszystkie odległe gałęzie w Git?

Aby wypchnąć wszystkie gałęzie do pilota, użyj:

git push --all

ostatecznie --mirror do odzwierciedlenia wszystkich referencji.

Jeśli Twoim celem jest zduplikowanie repozytorium, zobacz: Duplikowanie artykułu z repozytorium w witrynie GitHub.

Zwykle używam tylko takich poleceń:

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

Trochę krótsza wersja:

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

Wierzę, że sklonowałeś repozytorium poprzez:

git clone https://github.com/pathOfrepository

Teraz przejdź do tego folderu za pomocą cd:

cd pathOfrepository

Jeśli wpiszesz git status, zobaczysz wszystkie:

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

Aby wyświetlić wszystkie ukryte typy oddziałów:

 git branch -a

Wyświetli listę wszystkich zdalnych gałęzi.

Teraz, jeśli chcesz dokonać transakcji w dowolnym oddziale, po prostu wpisz:

git checkout -b localBranchName origin/RemteBranchName

Jeśli szukasz rozwiązania, które pozwoli uzyskać wszystkie gałęzie, a następnie przeprowadzisz migrację wszystkiego na inny serwer Git, przygotuję poniższy proces. Jeśli chcesz tylko zaktualizować wszystkie gałęzie lokalnie, zatrzymaj się przy pierwszej pustej linii.

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>

Po sklonowaniu głównego repozytorium wystarczy uruchomić

git fetch && git checkout <branchname>

Upewnij się, że wszystkie zdalne gałęzie można pobrać z .git/configpliku.

W tym przykładzie origin/productionmożna pobrać tylko gałąź, nawet jeśli spróbujesz git fetch --allnic nie zrobić , oprócz pobierania productiongałęzi:

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

Ten wiersz należy zastąpić:

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

Następnie uruchom git fetchitp ...

Pętla wydawała mi się nie działać i chciałem zignorować origin / master. Oto, co dla mnie zadziałało.

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

Po tym:

git fetch --all
git pull --all

Tylko te trzy polecenia otrzymają wszystkie gałęzie:

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

git config --bool core.bare false

git reset --hard

Dlaczego nikt nie odpowiada chłopcom na pytania i nie wyjaśnia, co się dzieje?

1. Upewnij się, że śledzisz wszystkie zdalne gałęzie (lub te, które chcesz śledzić) .
2. Zaktualizuj lokalne oddziały, aby odzwierciedlały zdalne oddziały.

Śledź wszystkie zdalne oddziały:

Śledź wszystkie gałęzie, które istnieją w zdalnym repozytorium.

Zrób to ręcznie:

Zastąpiłbyś <branch>gałąź wyświetlaną z wyjścia git branch -r.

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

Zrób to za pomocą skryptu bash

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

Zaktualizuj informacje o zdalnych oddziałach na komputerze lokalnym:

Spowoduje to pobranie aktualizacji oddziałów ze zdalnego repozytorium, które śledzisz w lokalnym repozytorium. Nie zmienia to lokalnych oddziałów. Twoje lokalne repozytorium git jest teraz świadome rzeczy, które wydarzyły się w gałęziach zdalnego repo. Przykładem może być przekazanie nowego zatwierdzenia do zdalnego wzorca, wykonanie pobierania poinformuje cię teraz, że twój lokalny opóźnienie jest opóźniony o 1 zatwierdzenie.

git fetch --all

Zaktualizuj informacje o zdalnych oddziałach na komputerze lokalnym i zaktualizuj oddziały lokalne:

Czy pobieranie, a następnie scalanie wszystkich gałęzi ze zdalnego do lokalnego oddziału. Przykładem może być przekazanie nowego zatwierdzenia do zdalnego wzorca, wykonanie ściągnięcia zaktualizuje lokalne repo o zmianach w zdalnym oddziale, a następnie scali te zmiany w oddziale lokalnym. Może to stworzyć dość bałagan z powodu konfliktów scalania.

git pull --all

Napisałem mały skrypt do zarządzania klonowaniem nowego repozytorium i tworzeniem lokalnych gałęzi dla wszystkich zdalnych gałęzi.

Najnowszą wersję można znaleźć tutaj :

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

Aby go użyć, po prostu skopiuj go do katalogu git bin (dla mnie to jest C:\Program Files (x86)\Git\bin\git-cloneall), a następnie w wierszu polecenia:

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

Klonuje jak zwykle, ale tworzy lokalne gałęzie śledzące dla wszystkich zdalnych gałęzi.

Jak pobrać wszystkie gałęzie Git Śledzenie pojedynczego pilota.

Zostało to przetestowane i działa w systemach Red Hat i Git Bash w systemie Windows 10.

TLDR:

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

Wyjaśnienie:

Jedna wkładka sprawdza, a następnie pobiera wszystkie gałęzie oprócz HEAD.

Wymień gałęzie zdalnego śledzenia.

git branch -r

Zignoruj ​​HEAD.

grep -v ' -> '

Zdejmij nazwę oddziału z pilotów.

cut -d"/" -f2

Kasa wszystkich oddziałów śledzących jednego pilota.

git checkout $branch

Pobierz dla wyewidencjonowanego oddziału.

git fetch

Technicznie rzecz biorąc, pobieranie nie jest potrzebne dla nowych lokalnych oddziałów.

Może to być wykorzystane do jednego fetchlub obu pullgałęzi, które są zarówno nowe, jak i mają zmiany w pilotach.

Tylko upewnij się, że ciągniesz tylko wtedy, gdy jesteś gotowy do połączenia.

Konfiguracja testowa

Sprawdź repozytorium z adresem URL SSH.

git clone git@repository.git

Przed

Sprawdź oddziały lokalnie.

$ git branch
* master

Wykonywać polecenia

Wykonaj jedną linijkę.

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

Po

Sprawdź, czy lokalne oddziały obejmują oddziały zdalne.

$ git branch
  cicd
  master
* preprod

Użytkownicy systemu Windows korzystający z programu PowerShell:

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

Oto coś, co uważam za solidne:

• Nie aktualizuje zdalnego śledzenia dla istniejących oddziałów
• Nie próbuje zaktualizować w HEADcelu śledzeniaorigin/HEAD
• Pozwala na piloty o nazwie innej niż origin
• Prawidłowo cytowany shell

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

Nie jest konieczne, aby git fetch --alljak przechodząc -alldo git pullpodań tej opcji do wewnętrznej fetch.

Podziękowania dla tej odpowiedzi .

Oto wersja jednowierszowa Perla podana w zaakceptowanej odpowiedzi:

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

Możesz uruchomić plik wyjściowy jako skrypt powłoki, jeśli chcesz.

Przez przypadek usunęliśmy nasze repozytorium projektu Stash. Na szczęście ktoś stworzył widelec tuż przed przypadkową utratą. Sklonowałem widelec do mojego lokalnego (pominę szczegóły, jak to zrobiłem). Kiedy już miałem widelec w pełni w mojej okolicy, prowadziłem jedną linijkę. Zmodyfikowałem adres URL pilota (w moim przypadku początek), aby wskazywał docelowe repozytorium, do którego odzyskujemy:

git remote set-url origin <remote-url>

I w końcu pchnął wszystkie gałęzie do pochodzenia w taki sposób:

git push --all origin

i wróciliśmy do pracy.

Możemy umieścić wszystkie nazwy gałęzi lub tagów w pliku tymczasowym, a następnie wykonać polecenie git pull dla każdej nazwy / tagu:

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

Jeśli masz problemy, a fetch --allnastępnie śledź swój zdalny oddział:

git checkout --track origin/%branchname%

Aby uniknąć komunikatu o błędzie „krytyczny: gałąź o nazwie„ origin / master ”już istnieje.”, Potrzebujesz:

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

Na podstawie odpowiedzi Learath2, oto co zrobiłem po zrobieniu git clone [...]i cdprzejściu do utworzonego katalogu:

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

Pracowałem dla mnie, ale nie wiem, czy to zadziała dla ciebie. Bądź ostrożny.

git remote add origin https://yourBitbucketLink

git fetch origin

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

Teraz lokalnie twój yourNewLocalBranchNamejest twój requiredRemoteBranch.

Dla użytkowników programu Visual Studio w konsoli Menedżera pakietów:

oddział git | % {git fetch w górę; git merge upstream / master}

Próbowałem na wiele sposobów, tylko ten jest prosty i działa dla mnie.

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

Ustaw alias: (na podstawie najwyższej odpowiedzi)

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'

Teraz, aby śledzić wszystkie gałęzie:

git track-all-branches