Сначала клонируйте удаленный Git репозиторий и cd в него:
$ git clone git://example.com/myproject
$ cd myproject
Затем просмотрите локальные ветки в вашем репозитории:
$ git branch
* master
Но в вашем репозитории скрываются другие ветки! Вы можете увидеть их, используя флаг -a
:
$ git branch -a
* master
remotes/origin/HEAD
remotes/origin/master
remotes/origin/v1.0-stable
remotes/origin/experimental
Если вы хотите быстро взглянуть на ветку вверху, вы можете проверить ее прямо:
$ git checkout origin/experimental
Но если вы хотите работать с этой веткой, вам нужно создать локальную ветвь отслеживания, которая будет выполнена автоматически:
$ git checkout experimental
и вы увидите
Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'
Эта последняя строка бросает некоторых людей: "Новая ветка" - да? На самом деле это означает, что ветвь взята из индекса и создана локально для вас. Предыдущая строка на самом деле более информативна, поскольку она сообщает вам, что ветка настраивается для отслеживания удаленной ветки, что обычно означает ветвь origin/branch_name
Теперь, если вы посмотрите на свои локальные ветки, это то, что вы увидите:
$ git branch
* experimental
master
Фактически вы можете отслеживать несколько удаленных репозиториев с помощью 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
В этот момент все становится довольно сумасшедшим, поэтому запустите gitk
, чтобы узнать, что происходит:
$ gitk --all &
Если у вас много удаленных веток, которые вы хотите получить сразу, выполните:
$ git pull --all
Теперь вы можете проверить любую ветку, как вам нужно, без попадания в удаленный репозиторий.
Этот Bash script помог мне:
#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
git branch --track "${branch##*/}" "$branch"
done
Он будет создавать ветки отслеживания для всех удаленных ветвей, кроме master (которые вы, вероятно, получили из исходной команды clone). Я думаю, вам все равно нужно сделать
git fetch --all
git pull --all
чтобы убедиться.
Один вкладыш:
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
Как обычно: тест в настройке перед копированием юниверса rm -rf, как мы его знаемКредиты для одного лайнера перейдите к пользователю cfi
for branch in `git branch -a | sed -n '\=/HEAD$=d; \=/master$=d;s=<SPACE><SPACE>remotes/==p'`; do ...
Использование опции --mirror
, похоже, правильно копирует ветки отслеживания remote
.
Тем не менее, он устанавливает репозиторий в виде открытого хранилища, поэтому впоследствии вы должны вернуть его в обычный репозиторий.
git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch
Ссылка: Git Часто задаваемые вопросы: Как клонировать репозиторий со всеми удаленно отслеживаемыми ветвями?
Вы можете легко переключиться на ветку, не используя причудливый "git checkout -b somebranch origin/somebranch". Вы можете просто:
git checkout somebranch
Git автоматически выполнит правильную работу:
$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'
Git будет проверять, существует ли ветвь с тем же именем точно в одном удаленном устройстве, и если это так, она отслеживает ее так же, как если бы вы явно указали, что это удаленная ветвь. На странице git -checkout man Git 1.8.2.1:
Если <branch> не обнаружено, но существует ветвь отслеживания в точно один удаленный (назовите его <remote> ) с соответствующим именем, рассмотрите как эквивалентно
$ git checkout -b <branch> --track <remote>/<branch>
checkout
совпадает с именем удаленной ветви, все после «/», тогда git создаст ветку с тем же именем, все после «/», «отслеживания», что дистанционный пульт? И, отслеживая, мы имеем в виду: git push
, git pull
и т. Д. Будет сделано на этом пульте? Если это правильно, то добавьте в свой ответ больше информации, потому что я согласен с @Daniel, этот ответ заслуживает большего количества повторений.
git checkout --track origin/somebranch
.
Относительно
$git checkout -b экспериментальное происхождение/экспериментальное
используя
$ git checkout -t origin/experimental
или более подробный, но более простой для запоминания
$ git checkout --track origin/experimental
может быть лучше, с точки зрения отслеживания удаленного репозитория.
Выбранный вами выбор должен получить все удаленные ветки, но для них не создаются локальные ветки. Если вы используете gitk, вы должны увидеть удаленные ветки, описанные как "remotes/origin/dev" или что-то подобное.
Чтобы создать локальную ветвь на основе удаленной ветки, сделайте что-то вроде:
git checkout -b dev refs/remotes/origin/dev
Что должно возвращать что-то вроде:
Branch dev set up to track remote branch refs/remotes/origin/dev. Switched to a new branch "dev"
Теперь, когда вы находитесь в ветке dev, "git pull" обновит локальный разработчик до той же точки, что и ветвь удаленного dev. Обратите внимание, что он будет извлекать все ветки, но только вытащите ту, которая находится на вершине дерева.
git checkout -b newlocaldev --track origin/dev
. Если вы хотите, чтобы локальная ветвь имела то же имя, что и удаленная, а удаленная не имеет хитрого имени, вы можете опустить -b newlocaldev
. С настройкой конфигурации branch.autosetupmerge
по умолчанию и при условии, что у вас нет локальной ветки с именем dev
, эти две команды могут делать одно и то же: git checkout -b dev origin/dev
и просто обычная git checkout dev
. Наконец, git checkout origin/dev
не создает новую ветку, а просто переводит вас в отключенное состояние HEAD.
Когда вы делаете "git clone git://location", все ветки и теги извлекаются.
Чтобы работать поверх определенной удаленной ветки, предположим, что это пульт дистанционного управления:
git checkout -b branch origin/branchname
$ git branch -a
чтобы узнать, какие удаленные ветви уже доступны.
Использовать псевдонимы. Хотя нет никаких родных Git однострочных, вы можете определить свои собственные как
git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
а затем используйте его как
git clone-branches
Это не слишком сложно, очень простые и простые шаги следующие:
git fetch origin
Это приведет к тому, что все удаленные ветки будут локальными.
git branch -a
Это покажет вам все удаленные ветки.
git checkout --track origin/<branch you want to checkout>
Проверьте, находитесь ли вы в нужном ветки с помощью следующей команды:
git branch
Результат будет таким:
*your current branch
some branch2
some branch3
Обратите внимание на знак *, обозначающий текущую ветвь.
git clone
загружает все удаленные удаленные ветки, но все еще считает их "remote", хотя файлы находятся в вашем новом репозитории. Там есть одно исключение, которое заключается в том, что процесс клонирования создает локальную ветвь, называемую "ведущий" из удаленной ветки, называемой "master". По умолчанию git branch
показывает только локальные ветки, поэтому вы видите только "master".
git branch -a
показывает все ветки, включая удаленные ветки.
Если вы действительно хотите работать с веткой, вам, вероятно, понадобится "локальная" версия. Чтобы просто создавать локальные ветки из удаленных ветвей (не проверяя их и тем самым меняя содержимое рабочего каталога), вы можете сделать это вот так:
git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree
В этом примере branchone
- имя локальной ветки, которую вы создаете на основе origin/branchone
; если вы хотите создать локальные ветки с разными именами, вы можете сделать это:
git branch localbranchname origin/branchone
Как только вы создали локальную ветвь, вы можете увидеть ее с помощью git branch
(помните, что вам не нужно -a
видеть локальные ветки).
Лучше поздно, чем никогда, но вот лучший способ сделать это:
mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard
На этом этапе у вас есть полная копия удаленного репо со всеми его ветвями (проверьте с помощью git branch
). Вы можете использовать --mirror
вместо --bare
, если у вашего удаленного репо есть свои собственные пульты.
--bare
», упомянутое в последнем предложении, не существует в данном списке команд.
Просто сделайте следующее:
$ 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
Вы видите, что git clone git://example.com/myprojectt 'извлекает все, даже ветки, вам просто нужно их проверить, тогда ваша локальная ветка будет создана.
Вам нужно использовать "git clone" для получения всех ветвей.
git clone <your_http_url>
Даже если вы видите только ветку мастера, вы можете использовать "git branch -a", чтобы увидеть все ветки.
git branch -a
И вы можете переключиться на любую ветвь, которая у вас уже есть.
git checkout <your_branch_name>
Не волнуйтесь, что после "git clone" вам не нужно подключаться к удаленному репо, "git branch -a" и "git checkout" могут быть успешно запущены, когда вы закройте свой Wi-Fi. Таким образом, доказано, что когда вы выполняете "git clone" , он уже скопировал все ветки из удаленного репо. После этого вам не нужно удаленное репо, у вашего локального уже есть коды всех ветвей.
A git clone
должен скопировать весь репозиторий. Попробуйте клонировать его, а затем запустите git branch -a
. Он должен перечислить все ветки. Если вы хотите переключиться на ветвь "foo" вместо "master", используйте git checkout foo
.
git clone
действительно загружает все удаленные ветви, но создает только локальную ветку master. Так как git branch
показывает только локальные ветки, вам нужен git branch -a
чтобы увидеть и удаленные ветки.
Используйте мой инструмент git_remote_branch (вам нужно, чтобы Ruby был установлен на вашем компьютере). Он был создан специально, чтобы сделать удаленные манипуляции с ветками мертвыми.
Каждый раз, когда он выполняет операцию от вашего имени, он печатает ее красным цветом на консоли. Со временем они, наконец, впадают в ваш мозг: -)
Если вы не хотите, чтобы grb запускал команды от вашего имени, просто используйте функцию "объяснять". Команды будут напечатаны на консоль, а не выполнены для вас.
Наконец, все команды имеют псевдонимы, чтобы облегчить запоминание.
Обратите внимание, что это alpha software; -)
Вот помощь при запуске 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 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
все ответы, которые я видел здесь, действительны, но существует гораздо более чистый способ клонирования репозитория и одновременного вытягивания всех ветвей.
Когда вы клонируете репозиторий, вся информация о ветвях фактически загружается, но ветки скрыты. С помощью команды
$ 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" с терминала.
переключите этот репозиторий из пустого (голого) репозитория в обычный репозиторий, переключив логическое значение "голый" из конфигураций git на false:
$ git config --bool core.bare false
Захватите все, что находится внутри текущей папки, и создайте все ветки на локальной машине, что делает это обычным репо.
$ git reset --hard
Итак, теперь вы можете просто ввести команду "git branch", и вы увидите, что все ветки загружены.
Это быстрый способ, с помощью которого вы можете клонировать репозиторий git со всеми ветвями одновременно, но это не то, что вы хотите сделать для каждого отдельного проекта таким образом.
Хорошо, когда вы клонируете свой репо, у вас есть все ветки там...
Если вы просто делаете git branch
, они как бы скрыты...
Поэтому, если вы хотите увидеть все имена веток, просто добавьте флаг --all
следующим образом:
git branch --all
или git branch -a
Если вы просто оформите заказ в филиале, вы получите все, что вам нужно.
Но как быть, если ветка, созданная кем-то другим после вас, клонируется?
В этом случае просто сделайте:
git fetch
и проверьте все ветки снова...
Если вы хотите получить и оформить заказ одновременно, вы можете сделать:
git fetch && git checkout your_branch_name
Также создал изображение ниже для вас, чтобы упростить то, что я сказал:
Глядя на один из ответов на вопрос, я заметил, что его можно сократить:
for branch in `git branch -r | grep -v 'HEAD\|master'`; do
git branch --track ${branch##*/} $branch;
done
Но будьте осторожны, если одна из удаленных ветвей называется как, например. admin_master он не будет загружен!
Благодаря большой рыбе для оригинальной идеи
grep
, чтобы улучшить фильтр, чтобы избежать ложных срабатываний.
#!/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
Этот код потянет весь код удаленных веток на локальное репо.
Клонирование из локального репо не будет работать с git clone и git fetch: многие ветки/теги будут оставлены без изменений.
Чтобы получить клон со всеми ветвями и тегами.
git clone --mirror git://example.com/myproject myproject-local-bare-repo.git
Чтобы получить клон со всеми ветвями и тегами, а также с рабочей копией:
git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master
Для копирования-вставки в командной строке:
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
Для большей читаемости:
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
Я написал эту небольшую функцию Powershell, чтобы иметь возможность извлекать все мои ветки git, которые находятся на удаленном сервере.
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>' #>
}
Больше функций git можно найти в моем репозитории git settings
Мне нужно было сделать то же самое. Вот мой Ruby script.
#!/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]
По состоянию на начало 2017 года ответ в этом комментарии работает:
git fetch <origin-name> <branch-name>
возвращает ветку для вас. Хотя это не вытягивает сразу все ветки, вы можете выполнить эту ветвь в отдельности.
Git обычно (если не указано) извлекает все ветки и/или теги (refs, see: git ls-refs
) из одного или нескольких других репозиториев вместе с объектами, необходимыми для завершения их историй. Другими словами, он извлекает объекты, которые достижимы уже загруженными объектами. Смотрите: Что делает git fetch
действительно?
Иногда у вас могут быть ветки/теги, которые напрямую не связаны с текущим, поэтому git pull --all
/git fetch --all
в этом случае не поможет, но вы можете их перечислить по:
git ls-remote -h -t origin
и получить их вручную, зная имена ссылок.
Итак, чтобы извлечь их все, попробуйте:
git fetch origin --depth=10000 $(git ls-remote -h -t origin)
Параметр --depth=10000
может помочь, если вы поместили репозиторий.
Затем снова проверьте все ветки:
git branch -avv
Если выше не поможет, вам нужно добавить отсутствующие ветки вручную в отслеживаемый список (поскольку они каким-то образом потерялись):
$ git remote -v show origin
...
Remote branches:
master tracked
на git remote set-branches
например:
git remote set-branches --add origin missing_branch
чтобы он выглядел под remotes/origin
после извлечения:
$ 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
Если вы все еще не можете получить ничего, кроме основной ветки, проверьте следующее:
git remote -v
), например.
git config branch.master.remote
есть origin
.origin
указывает на правильный URL: git remote show origin
(см. сообщение).Я использую Bitbucket, Хостинговую Службу Репозитория Atlassian. Поэтому я стараюсь следовать их документам. И это прекрасно работает для меня. С помощью следующих простых и коротких команд вы можете оформить удаленную ветку.
Сначала клонируйте свой репозиторий, затем перейдите в папку назначения. И последнее, но не менее важное: выборка и проверка:
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
Подробную информацию о командах вы найдете в документации: Команда клонирования, Команда извлечения, Команда извлечения
Вот еще одна короткая однострочная команда, которая создает локальные ветки для всех удаленных ветвей:
(git branch -r | sed -n '/->/!s#^ origin/##p' && echo master) | xargs -L1 git checkout
Он также работает правильно, если отслеживание локальных ветвей уже создано.
Вы можете вызвать его после первого git clone
или в любое время позже.
Если вам не нужно, чтобы после клонирования вышла ветвь master
, используйте
git branch -r | sed -n '/->/!s#^ origin/##p'| xargs -L1 git checkout
Ни один из этих ответов не разрезал, за исключением того, что пользователь не находится на правильном пути.
У меня возникли проблемы с перемещением репо с одного сервера/системы на другой. Когда я клонировал репо, он создал только локальную ветвь для мастера, поэтому, когда я нажал на новый пульт, была нажата только ведущая ветвь.
Итак, я нашел эти два метода ОЧЕНЬ полезными. Надеюсь, они помогут кому-то другому.
Метод 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
Метод 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
на оригинальном репо хорошо работает для этого.
git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin
Я собираюсь добавить свои 2 цента здесь, потому что я попытался выяснить, как удалить удаленную ветвь, которую я удалил локально. Происхождение не было моим, и я не хотел переживать хлопоты повторного клонирования всего.
Это сработало для меня:
предполагая, что вам нужно воссоздать ветвь локально:
git checkout -b recreated-branch-name
git branch -a (to list remote branches)
git rebase remotes/remote-origin/recreated-branch-name
Итак, если я разветвлялся от gituser/master до sjp, а затем разветвлял его на sjp/mynewbranch, он выглядел бы так:
$ 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
Этот вариант будет клонировать удаленное репо со всеми локальными веткими без необходимости извлекать каждую ветку по очереди. Не нужно никаких причудливых сценариев.
Создайте папку с тем же именем хранилища, которое вы хотите клонировать и скопируйте, например:
mkdir somerepo
cd somerepo
Теперь выполните эти команды, но с реальным именем пользователя /reponame репо
git clone --bare [email protected]:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch
Voiala! у вас есть все ветки там!
Если вы используете BitBucket,
Вы можете использовать репозиторий импорта, это импортирует всю историю git (все ветки и коммиты)
Вот bash script для извлечения всех ветвей и тегов проекта git в виде снимков в отдельные папки.
https://gist.github.com/hfossli/7562257
Возможно, не то, что было задано напрямую, но некоторые люди могут приехать сюда искать это решение.
Немного поздно на вечеринку, но я думаю, что это делает трюк:
mkdir YourRepo
cd YourRepo
git init --bare .git # create a bare repo
git remote add origin REMOTE_URL # add a remote
git fetch origin refs/heads/*:refs/heads/* # fetch heads
git fetch origin refs/tags/*:refs/tags/* # fetch tags
git init # reinit work tree
git checkout master # checkout a branch
Если это сделает что-то нежелательное, я бы с удовольствием узнал. Однако пока это работает для меня.
git fetch
( kernel.org/pub/software/scm/git/docs/git-fetch.html ), это, вероятно, необходимо скорректировать.
git branch -a
) показывает вам ветви на удаленном компьютере, но если вы попытаетесь проверить какие-либо из них, вы окажетесь в состоянии «отсоединенного HEAD». Следующий ответ «вниз» (второе по популярности) отвечает на другой вопрос (а именно: как вытащить все ветви, и, опять же, это работает только для тех, кого вы отслеживаете локально). В нескольких комментариях указывается, что вы можете проанализировать результатыgit branch -a
с помощью сценария оболочки, который будет локально отслеживать все удаленные ветки. Резюме: не существует мерзкого способа сделать то, что вы хотите, и в любом случае это может быть не очень хорошей идеей.scp [email protected]:/home/some_user/project_folder ~
Не уверен, что это решение работает для github, хотя ..