Как получить все ветки Git

Я клонировал Git-репозиторий, который содержит около пяти веток. Однако, когда я делаю, git branchя вижу только один из них:

$ git branch
* master

Я знаю, что могу сделать, git branch -aчтобы увидеть все ветви, но как бы я вытянул все ветви локально, чтобы, когда я это сделал git branch, это показало следующее?

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

Вы можете получить все ветви со всех пультов, как это:

git fetch --all

Это в основном силовой ход .

fetchобновляет локальные копии удаленных филиалов, так что это всегда безопасно для локальных филиалов, НО :

1. fetchне будет обновлять локальные ветви (которые отслеживают удаленные ветви); если вы хотите обновить свои локальные ветки, вам все равно нужно тянуть каждую ветку.

2. fetchне будет создавать локальные ветви (которые отслеживают удаленные ветви), вы должны сделать это вручную. Если вы хотите перечислить все удаленные ветви: git branch -a

Чтобы обновить локальные филиалы, которые отслеживают удаленные филиалы:

git pull --all

Однако этого может быть недостаточно. Это будет работать только для ваших локальных филиалов, которые отслеживают удаленные филиалы. Для отслеживания всех удаленных веток выполните этот oneliner ДО git pull --all :

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

TL; DR версия

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

(Кажется, что pull извлекает все ветки со всех пультов, но я всегда выбираю сначала, чтобы быть уверенным.)

Выполните первую команду, только если на сервере есть удаленные ветви, которые не отслеживаются вашими локальными филиалами.

PS AFAIK git fetch --allи git remote updateэквивалентны.

Комментарий Камиля Шота , который люди сочли полезным.

Я должен был использовать:

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

потому что ваш код создал локальные ветви с именем, origin/branchnameа я получал "refname 'origin / branchname" неоднозначно всякий раз, когда я ссылался на него.

Для просмотра удаленных филиалов:
git branch -r

Вы можете проверить их как местные филиалы с:
git checkout -b LocalName origin/remotebranchname

Вам нужно будет создавать локальные филиалы, отслеживающие удаленные филиалы.

Предполагая, что у вас есть только один удаленный вызов origin, этот фрагмент создаст локальные ветви для всех удаленных отслеживающих:

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

После этого git fetch --allбудут обновлены все локальные копии удаленных филиалов.

Кроме того, git pull --allбудут обновляться ваши локальные ветви отслеживания, но в зависимости от ваших локальных коммитов и от того, как настроен параметр конфигурации «слияние», это может создать коммит слияния, ускоренную перемотку вперед или сбой.

Если вы делаете:

git fetch origin

тогда они будут все там локально. Если вы затем выполните:

git branch -a

вы увидите их в списке как remotes / origin / branch-name. Так как они есть на месте, вы можете делать с ними все, что угодно. Например:

git diff origin/branch-name 

или

git merge origin/branch-name

или

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

$ git remote update
$ git pull --all

Это предполагает, что все ветви отслеживаются.

Если это не так, вы можете запустить это в Bash:

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

Затем запустите команду.

Цикл Bash forне работал для меня, но он сделал именно то, что я хотел. Все ветви моего происхождения зеркально отображались как одноименные локально.

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

См. Комментарий Майка Дюпона ниже. Я думаю, что пытался сделать это на сервере Jenkins, который оставляет его в режиме отсоединенной головы.

Использование git fetch && git checkout RemoteBranchName.

Это работает очень хорошо для меня ...

Когда вы клонируете репозиторий, вся информация о ветвях фактически загружается, но ветви скрыты. С помощью команды

$ git branch -a

Вы можете показать все ветви хранилища, и с помощью команды

$ git checkout -b branchname origin/branchname

затем вы можете «загрузить» их вручную по одному.

Тем не менее, есть гораздо более чистый и быстрый способ, хотя он немного сложнее. Вам нужно три шага для этого:

1. Первый шаг

   создайте новую пустую папку на своем компьютере и клонируйте зеркальную копию папки .git из репозитория:

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

   Локальный репозиторий внутри папки my_repo_folder по-прежнему пуст, теперь есть только скрытая папка .git, которую вы можете увидеть с помощью команды «ls -alt» из терминала.

2. Второй шаг

   переключите этот репозиторий из пустого (пустого) репозитория в обычный репозиторий, переключив логическое значение «bare» конфигурации git на false:

   $ git config --bool core.bare false
   

3. Третий шаг

   Возьмите все, что находится внутри текущей папки, и создайте все ветви на локальном компьютере, поэтому сделайте это обычным репо.

   $ git reset --hard
   

Теперь вы можете просто ввести команду git branchи увидеть, что все ветви загружены.

Это быстрый способ, которым вы можете клонировать git-репозиторий со всеми ветками одновременно, но это не то, что вы хотите сделать для каждого отдельного проекта таким образом.

Вы можете получить все ветви:

git fetch --all

или:

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

^{--depth=10000Параметр может помочь , если вы обмелевшее хранилищу.}

Чтобы вытащить все ветви, используйте:

git pull --all

Если вышеприведенное не сработает, то перед этой командой введите:

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

так как он remote.origin.fetchможет поддерживать только определенную ветку во время извлечения, особенно когда вы клонировали свое хранилище с --single-branch. Проверьте это: git config remote.origin.fetch.

После этого вы сможете оформить заказ в любом отделении.

Смотрите также:

• Как получить все удаленные ветки?
• Как клонировать все удаленные ветки в Git?

Чтобы передать все ветви на удаленный доступ, используйте:

git push --all

в конце концов, --mirrorчтобы отразить все ссылки.

Если ваша цель - дублировать репозиторий, см .: Дублирование статьи о репозитории на GitHub.

Я обычно не использую ничего, кроме таких команд:

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

Немного короче версия:

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

Я полагаю, что вы клонировали хранилище:

git clone https://github.com/pathOfrepository

Теперь перейдите в эту папку с помощью CD:

cd pathOfrepository

Если вы напечатаете, git statusвы можете увидеть все:

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

Чтобы увидеть все скрытые типы веток:

 git branch -a

В нем будут перечислены все удаленные ветви.

Теперь, если вы хотите оформить заказ на какую-либо конкретную ветку, просто наберите:

git checkout -b localBranchName origin/RemteBranchName

Если вы ищете решение, чтобы получить все ветви и затем перенести все на другой Git-сервер, я соберу следующий процесс. Если вы просто хотите обновить все ветви локально, остановитесь на первой пустой строке.

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>

После того, как вы клонируете главный репозиторий, вы можете просто выполнить

git fetch && git checkout <branchname>

Убедитесь, что все удаленные ветви извлекаются из .git/configфайла.

В этом примере origin/productionизвлекается только ветвь, даже если вы попытаетесь сделать git fetch --allничего, ничего не произойдет, кроме извлечения productionветки:

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

Эта строка должна быть заменена на:

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

Тогда беги и git fetchт.д ...

Цикл не работал для меня, и я хотел игнорировать происхождение / мастер. Вот что сработало для меня.

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

После того:

git fetch --all
git pull --all

Именно эти три команды получат все ветви:

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

git config --bool core.bare false

git reset --hard

Почему никто не отвечает на вопрос ребят и не объясняет, что происходит?

1. Убедитесь, что вы отслеживаете все удаленные ветви (или те, которые вы хотите отслеживать) .
2. Обновите ваши локальные ветви, чтобы отразить удаленные ветви.

Отслеживание всех удаленных веток:

Отслеживайте все филиалы, которые существуют в удаленном репо.

Сделайте это вручную:

Вы бы заменили <branch>ветку, которая отображается на выходе git branch -r.

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

Сделайте это с помощью bash-скрипта

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

Обновите информацию об удаленных филиалах на вашем локальном компьютере:

При этом обновляются ветки удаленного репо, которые вы отслеживаете в своем локальном репо. Это не меняет ваши местные филиалы. Ваше локальное git-репо теперь знает о том, что произошло в ветках удаленного репо. Примером может быть то, что новый коммит был передан на удаленный мастер, выполнение выборки теперь предупредит вас, что ваш локальный мастер отстает на 1 коммит.

git fetch --all

Обновите информацию об удаленных филиалах на вашем локальном компьютере и обновите локальные филиалы:

Выполняет выборку с последующим объединением всех веток от удаленного к локальному. Примером может служить то, что новый коммит был передан на удаленный мастер, выполнение извлечения обновит ваше локальное хранилище об изменениях в удаленной ветви, а затем объединит эти изменения с вашей локальной веткой. Это может создать беспорядок из-за конфликтов слияния.

git pull --all

Я написал небольшой скрипт для управления клонированием нового репо и создания локальных веток для всех удаленных веток.

Вы можете найти последнюю версию здесь :

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

Чтобы использовать его, просто скопируйте его в каталог git bin (для меня это так C:\Program Files (x86)\Git\bin\git-cloneall), а затем в командной строке:

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

Он клонируется как обычно, но создает локальные ветви отслеживания для всех удаленных ветвей.

Как получить все отслеживания веток Git Single Remote.

Это было проверено и работает в Red Hat и Git Bash в Windows 10.

TLDR:

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

Объяснение:

Один лайнер проверяет и затем выбирает все ветви, кроме HEAD.

Перечислите ветки удаленного слежения.

git branch -r

Игнорировать ГОЛОВУ.

grep -v ' -> '

Снимите название ветки с пульта (ов).

cut -d"/" -f2

Оформить заказ на все филиалы, отслеживая один пульт.

git checkout $branch

Выбрать для проверенной ветки.

git fetch

Технически выборка не нужна для новых локальных филиалов.

Это может быть использовано как для одной, так fetchи для pullветок, которые являются как новыми, так и имеют изменения в удаленных подразделениях.

Просто убедитесь, что вы тянете, только если вы готовы к слиянию.

Испытательная установка

Проверьте хранилище с SSH URL.

git clone git@repository.git

Перед

Проверьте филиалы в местном.

$ git branch
* master

Выполнить команды

Выполните один лайнер.

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

После

Проверьте, что локальные филиалы включают удаленные филиалы.

$ git branch
  cicd
  master
* preprod

Для пользователей Windows, использующих 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

Вот что я считаю надежным:

• Не обновляет удаленное отслеживание для существующих филиалов
• Не пытается обновить, HEADчтобы отслеживатьorigin/HEAD
• Позволяет пультам с именами, отличными от origin
• Правильно оформленная оболочка

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

Это не нужно , git fetch --allкак проходит -allв git pullпроходах эту опцию внутренний fetch.

Отдайте этому ответу .

Вот Perl-версия однострочника, приведенная в принятом ответе:

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

Вы можете запустить выходной файл как сценарий оболочки, если хотите.

Мы случайно удалили наш репозиторий проекта Stash. К счастью, кто-то создал вилку прямо перед случайной потерей. Я клонировал вилку на свой местный (опущу детали того, как я это сделал). После того, как я полностью освоил вилку, я запустил одну однострочную. Я изменил URL-адрес пульта (источник в моем случае), чтобы он указывал на целевой репозиторий, в который мы восстанавливали:

git remote set-url origin <remote-url>

И, наконец, подтолкнул все ветви к происхождению так:

git push --all origin

и мы вернулись в бизнес.

Мы можем поместить все имена веток или тегов во временный файл, а затем выполнить git pull для каждого имени / тега:

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

Если у вас есть проблемы, fetch --allто отследите вашу удаленную ветку:

git checkout --track origin/%branchname%

Чтобы избежать сообщения об ошибке 'fatal: ветвь с именем' origin / master 'уже существует.', Вам нужно это:

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

Основываясь на ответе Learath2, вот что я сделал после того, как сделал git clone [...]и cd-ing в созданный каталог:

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

Сработало для меня, но я не знаю, сработает ли это для вас. Быть осторожен.

git remote add origin https://yourBitbucketLink

git fetch origin

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

Теперь локально ваш yourNewLocalBranchNameтвой requiredRemoteBranch.

Для пользователей Visual Studio: на консоли диспетчера пакетов:

мерзавец ветка | % {git fetch upstream; git merge upstream / master}

Перепробовал много способов, только этот прост и работает для меня.

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

Установить псевдоним: (на основе верхнего ответа)

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'

Теперь для отслеживания всех веток:

git track-all-branches