Как получить все ветки Git
Я клонировал Git-репозиторий, который содержит около пяти веток. Тем не менее, когда я делаю git branch Я вижу только один из них:
$ git branch
* master
Я знаю, что я могу сделать git branch -a чтобы увидеть все ветви, но как бы я потянул все ветви локально, чтобы, когда я делаю git branch, это показывает следующее?
$ git branch
* master
* staging
* etc...
35 ответов
Вы можете получить одну ветку со всех пультов, как это:
git fetch --all
fetch обновляет локальные копии удаленных филиалов, так что это всегда безопасно для локальных филиалов, НО:
fetchне будет обновлять локальные ветви (которые отслеживают удаленные ветви); Если вы хотите обновить свои локальные ветки, вам все равно нужно потянуть каждую ветку.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 эквивалентны.
Комментарий Камиля Сзота, который 74 (по крайней мере) люди сочли полезным.
Я должен был использовать:
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 обновит ваши локальные ветви отслеживания, но в зависимости от ваших локальных коммитов и от того, как настроен параметр конфигурации 'merge', он может создать коммит слияния, перемотка вперед или сбой.
Если вы делаете:
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 loop не работал для меня, но это было именно то, что я хотел. Все ветви моего происхождения зеркально отображались как одноименные локально.
git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'
Отредактировано: см. Комментарий Mike DuPont ниже. Я думаю, что я пытался сделать это на сервере Jenkins, который оставляет его в режиме отсоединенной головы.
Использование git fetch && git checkout RemoteBranchName,
Это работает очень хорошо для меня...
Когда вы клонируете репозиторий, вся информация о ветвях фактически загружается, но ветви скрыты. С помощью команды
$ git branch -a
Вы можете показать все ветви хранилища, и с помощью команды
$ git checkout -b branchname origin/branchname
затем вы можете "загрузить" их вручную по одному.
Тем не менее, есть гораздо более чистый и быстрый способ, хотя он немного сложнее. Вам нужно три шага, чтобы сделать это:
Первый шаг
создайте новую пустую папку на своем компьютере и клонируйте зеркальную копию папки.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" из терминала.
Второй шаг
переключите этот репозиторий из пустого (пустого) репозитория в обычный репозиторий, переключив логическое значение "bare" конфигурации git на false:
$ git config --bool core.bare falseТретий шаг
Возьмите все, что находится внутри текущей папки, и создайте все ветви на локальном компьютере, поэтому сделайте это обычным репо.
$ 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 push --all
в конце концов --mirror чтобы отразить все ссылки.
Если ваша цель состоит в том, чтобы продублировать репозиторий, см.: Дублирование статьи о репозитории на GitHub.
Я обычно не использую ничего, кроме таких команд:
git fetch origin
git checkout --track origin/remote-branch
Немного более короткая версия:
git fetch origin
git checkout -t origin/remote-branch
Если вы ищете решение, чтобы получить все ветви и затем перенести все на другой 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>
Почему никто не отвечает на вопрос ребят и не объясняет происходящее?
- Убедитесь, что вы отслеживаете все удаленные ветки (или те, которые вы хотите отслеживать).
- Обновите свои локальные ветки, чтобы отразить удаленные ветки.
Отслеживайте все удаленные ветки:
Отслеживайте все ветки, существующие в удаленном репо.
Сделайте это вручную:
Вы бы заменили <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
Я полагаю, что вы клонировали хранилище
git clone https://github.com/pathOfrepository
Теперь перейдите в эту папку с помощью компакт-диска
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/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 fetch && git checkout <branchname>
Только эти 3 команды получат все ветви
git clone --mirror repo.git .git (gets just .git - bare repository)
git config --bool core.bare false
git reset --hard
Как получить все отслеживания веток 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
Цикл не работал для меня, и я хотел игнорировать происхождение / мастер. Вот что сработало для меня.
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
Для пользователей 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,
Отдайте должное этому ответу.
Будьте осторожны, играя с git, идите шаг за шагом.
$ git remote update //This will update your local
$ git branch -a //This will list all the branches(After updating you can now
see the new branch in the list)
$ git checkout your_branch_name
вы можете получить все ответвления с помощью этой однострочной команды следующим образом:
git fetch —all && git pull —all && git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
|‾‾‾‾‾‾‾‾‾‾‾‾‾fetch/clone‾‾‾‾‾‾‾‾‾‾‾‾↓ |‾‾‾‾‾‾‾‾‾‾‾‾checkout‾‾‾‾‾‾‾‾‾‾↓
|‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾pull‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾↓
Remote repository (`origin`) <=> Local repository <=> Index <=> Workspace
↑_________________push_______________| ↑____commit____| ↑____add_____|
# 拉取远程仓库所有分支信息 → 本地仓库
# fetch all remote repository branch meta → local repository
git remote set-branches origin '*'
git fetch -v
# 把所有远程分支数据搞到本地
# fetch all remote repository branch data → local repository
git branch -r | grep -v '\->' | while read remote; do git branch "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all
Установить псевдоним: (на основе верхнего ответа)
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
TLDR Создавать локальную ветку для каждой удаленной ветки отслеживания, скорее всего, плохая идея. Эти разные типы филиалов служат разным целям, и локальные филиалы обычно создаются в зависимости от их потребностей. показывает локальные ветки показывает ветки удаленного отслеживания. показывает оба. Вы можете обновить все ветки удаленного отслеживания с помощью соответствующей команды fetch. Обычно это все, что вам нужно.
Пролистав существующие ответы, я вижу два типа: те, которые просто отвечают на заданный вопрос, а не предлагают другой подход. И те, кто предлагает другой подход, не объясняя почему. Вот моя попытка объяснить немного больше.
На самом деле есть три типа ветвей, с которыми должен иметь дело обычный репозиторий git. Эти три вида ветвей служат разным целям. Короче говоря:
удаленные ветки: это ветки, существующие в удаленном репозитории. Вы никогда не будете читать из удаленных веток напрямую. Все чтение удаленных веток происходит через gits, так называемые «ветки удаленного отслеживания».
ветки удаленного отслеживания: git хранит локальные снимки удаленных ветвей, которые точнее всего называются «ветками удаленного отслеживания». Они обновляются, когда вы звоните или
Например:
git merge origin/masterобъединит ветку удаленного отслеживания с текущей локальной веткой, не требуя от вас предварительного создания ее локальной копии. Это означает: есть ветка удаленного отслеживания, называемая
локальные ветки: это созданные вручную снэпшоты определенных точек в истории (часто на основе удаленных веток слежения, по крайней мере поначалу). Они гораздо более статичны, чем другие виды, и действительно изменятся только тогда, когда вы измените их вручную . По одному. Скорее всего, вам понадобится локальная ветка, если вы хотите просмотреть ее содержимое в своем рабочем дереве (каталоге проекта) или когда вы хотите добавить в нее коммиты.
После того, как вы закончите с локальной веткой (и опубликуете ее содержимое), вы можете рассмотреть возможность ее удаления. Таким образом, вам не нужно поддерживать его в актуальном состоянии. В конце концов, выборка не обновит текущую локальную ветку, а извлечение обновит только текущую проверенную локальную ветку. Другими словами: вы должны создавать локальные ветки только тогда, когда они вам нужны, и вам, вероятно, следует удалять их, когда они вам больше не нужны.
Вероятно, не совсем правильно говорить, что «некоторые ветки скрыты по умолчанию». Скорее
Также обратите внимание, что, как правило, плохая идея создавать локальные ветки, имена которых начинаются с имени удаленного компьютера, за которым следует косая черта (например, создание локальной ветки с именем «origin/master», как правило, является плохой идеей, поскольку ее имя конфликтует с название ветки удаленного отслеживания).
В контексте обновления веток имеет смысл обсудить различные разновидности команд fetch:
я особенно люблю
git fetch -tf --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 checkout - отслеживание происхождения /%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
Вот 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
и мы вернулись в бизнес.
Пробовал много способов, только этот простой и работает у меня.
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