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

3332

У меня есть ветвь master и a development, которые помещаются в GitHub. Я clone d, pull ed и fetch ed, но я не могу получить ничего, кроме ветки master.

Я уверен, что мне не хватает чего-то очевидного, но я прочитал руководство, и я не получаю никакой радости.

задан Peter Coulton 16 сент. '08 в 1:42
источник

32 ответов

  • 1
  • 2
3822

Сначала клонируйте удаленный 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 &
ответ дан emk 16 сент. '08 в 16:28
источник
714

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

$ git pull --all

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

ответ дан Gabe Kopley 13 янв. '11 в 19:42
источник
346

Этот 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

ответ дан bigfish 21 янв. '11 в 5:18
источник
232

Использование опции --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 Часто задаваемые вопросы: Как клонировать репозиторий со всеми удаленно отслеживаемыми ветвями?

ответ дан Dave 27 авг. '11 в 20:49
источник
194

Вы можете легко переключиться на ветку, не используя причудливый "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>
ответ дан Nikos C. 12 мая '12 в 15:11
источник
78

Относительно

$git checkout -b экспериментальное происхождение/экспериментальное

используя

$ git checkout -t origin/experimental

или более подробный, но более простой для запоминания

$ git checkout --track origin/experimental

может быть лучше, с точки зрения отслеживания удаленного репозитория.

ответ дан murphytalk 27 июля '09 в 9:10
источник
70

Выбранный вами выбор должен получить все удаленные ветки, но для них не создаются локальные ветки. Если вы используете 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. Обратите внимание, что он будет извлекать все ветки, но только вытащите ту, которая находится на вершине дерева.

ответ дан Luuk Paulussen 16 сент. '08 в 1:52
источник
52

Когда вы делаете "git clone git://location", все ветки и теги извлекаются.

Чтобы работать поверх определенной удаленной ветки, предположим, что это пульт дистанционного управления:

git checkout -b branch origin/branchname
ответ дан elmarco 16 сент. '08 в 1:47
источник
41

Использовать псевдонимы. Хотя нет никаких родных 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
ответ дан nobody 15 мая '13 в 14:02
источник
38

Это не слишком сложно, очень простые и простые шаги следующие:

git fetch origin Это приведет к тому, что все удаленные ветки будут локальными.

git branch -a Это покажет вам все удаленные ветки.

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

Проверьте, находитесь ли вы в нужном ветки с помощью следующей команды:

git branch

Результат будет таким:

*your current branch 
some branch2
some branch3 

Обратите внимание на знак *, обозначающий текущую ветвь.

ответ дан Samar Kr Mishra 26 дек. '13 в 13:19
источник
36

Почему вы видите только "мастер"

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 видеть локальные ветки).

ответ дан Cerran 05 марта '14 в 16:47
источник
34

Просто сделайте следующее:

$ 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 'извлекает все, даже ветки, вам просто нужно их проверить, тогда ваша локальная ветка будет создана.

ответ дан rapher 31 мая '11 в 14:40
источник
26

Лучше поздно, чем никогда, но вот лучший способ сделать это:

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

На этом этапе у вас есть полная копия удаленного репо со всеми его ветвями (проверьте с помощью git branch). Вы можете использовать --mirror вместо --bare, если у вашего удаленного репо есть свои собственные пульты.

ответ дан Jacob Fike 27 нояб. '12 в 2:42
источник
17

Вам нужно использовать "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" , он уже скопировал все ветки из удаленного репо. После этого вам не нужно удаленное репо, у вашего локального уже есть коды всех ветвей.

ответ дан Haimei 19 нояб. '14 в 18:43
источник
15

Используйте мой инструмент 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
ответ дан webmat 20 сент. '08 в 16:53
источник
15

A git clone должен скопировать весь репозиторий. Попробуйте клонировать его, а затем запустите git branch -a. Он должен перечислить все ветки. Если вы хотите переключиться на ветвь "foo" вместо "master", используйте git checkout foo.

ответ дан MattoxBeckman 16 сент. '08 в 1:46
источник
10

Глядя на один из ответов на вопрос, я заметил, что его можно сократить:

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

Но будьте осторожны, если одна из удаленных ветвей называется как, например. admin_master он не будет загружен!

Благодаря большой рыбе для оригинальной идеи

ответ дан Tebe 20 февр. '15 в 0:33
источник
8

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

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

$ 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" с терминала.

  1. Второй шаг

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

$ git config --bool core.bare false
  1. Третий шаг

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

$ git reset --hard

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

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

ответ дан FedericoCapaldo 06 дек. '15 в 23:08
источник
7

Мне нужно было сделать то же самое. Вот мой 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]
ответ дан user43685 11 дек. '10 в 2:12
источник
7

Для копирования-вставки в командной строке:

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


Это будет:
  • проверить мастер (чтобы мы могли удалить ветвь, в которой мы находимся)
  • выберите удаленный для проверки (измените его на любой удаленный сервер)
  • цикл через все ветки удаленного, кроме master и HEAD
    • удалить локальную ветвь (чтобы мы могли проверять ветки обновляемой силы)
    • проверить ветку с удаленного устройства
  • проверить мастер (ради него)

На основе answer VonC.

ответ дан ikaruss 20 дек. '13 в 9:38
источник
6

Клонирование из локального репо не будет работать с 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
ответ дан raisercostin 24 февр. '17 в 2:55
источник
5
#!/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

Этот код потянет весь код удаленных веток на локальное репо.

ответ дан Albert.Qing 11 дек. '16 в 5:20
источник
5

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 (см. сообщение).
ответ дан kenorb 31 марта '16 в 3:48
источник
4

По состоянию на начало 2017 года ответ в этом комментарии работает:

git fetch <origin-name> <branch-name> возвращает ветку для вас. Хотя это не вытягивает сразу все ветки, вы можете выполнить эту ветвь в отдельности.

ответ дан ashes999 21 апр. '17 в 23:14
источник
4

Ни один из этих ответов не разрезал, за исключением того, что пользователь не находится на правильном пути.

У меня возникли проблемы с перемещением репо с одного сервера/системы на другой. Когда я клонировал репо, он создал только локальную ветвь для мастера, поэтому, когда я нажал на новый пульт, была нажата только ведущая ветвь.

Итак, я нашел эти два метода ОЧЕНЬ полезными. Надеюсь, они помогут кому-то другому.

Метод 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
ответ дан Gaui 23 янв. '15 в 20:51
источник
4

Использовать команды, которые вы можете запомнить

Я использую Bitbucket, службу хостинга репозитория Atlassian. Поэтому я стараюсь следовать их документам. И это отлично работает для меня. С помощью следующих простых и коротких команд вы можете проверить свою удаленную ветку.

Сначала клонируйте свой репозиторий, а затем перейдите в папку назначения. И последнее, но не менее важное: выбор и проверка:

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

Что это. Вот пример более реального мира:

git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Подробную информацию о командах в документах вы найдете: Команда клонирования, Команда Fetch, Команда проверки

ответ дан Phil 11 марта '16 в 23:01
источник
4

Я написал эту небольшую функцию 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 можно найти на my git настройках репо

ответ дан gringo_dave 19 июня '16 в 13:54
источник
4

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

(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
ответ дан jofel 10 сент. '15 в 15:04
источник
1

Я собираюсь добавить свои 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
ответ дан Camwyn 14 июля '13 в 4:30
источник
1

ОК,, когда вы клонируете свое репо, у вас есть все ветки...

Если вы просто делаете git branch, они скрыты...

Итак, если вы хотите увидеть имя всех ветвей, просто добавьте флаг --all:

git branch --all или git branch -a

Если вы просто заказываете ветку, вы получаете все, что вам нужно.

Но как насчет того, если ветвь, созданная кем-то еще после клонирования?

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

git fetch

и снова проверить все ветки...

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

git fetch && git checkout your_branch_name

Также было создано изображение ниже для упрощения того, что я сказал:

git ветвь --all для всех ветвей

ответ дан Alireza 22 июля '17 в 21:29
источник
  • 1
  • 2

Ознакомьтесь с другими вопросами по меткам