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

У меня есть masterи developmentветка, оба подтолкнули на GitHub . Я cloned, pulled и fetched, но я не могу получить ничего, кроме masterответвления.

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

Сначала клонируйте удаленный репозиторий Git и перейдите в него:

$ 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

Если вы просто хотите быстро взглянуть на ветку upstream, вы можете проверить это непосредственно:

$ git checkout origin/experimental

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

$ git checkout experimental

и ты увидишь

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Эта последняя строка бросает некоторых людей: "Новая ветвь" - а? На самом деле это означает, что ветка берется из индекса и создается для вас локально. Предыдущая линия на самом деле более информативная, он говорит вам , что филиал создается для отслеживания удаленного филиала, что обычно означает происхождение / 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 помог мне:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

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

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 Universe, как мы его знаем

Кредиты на однострочник переходят на пользователя cfi

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

Вы можете легко переключиться на ветку, не используя причудливый синтаксис "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 Git 1.8.2.1:

Если <branch> не найден, но существует отслеживающая ветвь ровно в одном удаленном (называемом <remote>) с соответствующим именем, обрабатывать как эквивалент

$ git checkout -b <branch> --track <remote>/<branch>

Что касается,

$ 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

Который должен вернуть что-то вроде:

Ветвь dev настроена для отслеживания удаленных веток refs / remotes / origin / dev.
Перешел на новую ветку "dev"

Теперь, когда вы находитесь в ветке dev, "git pull" обновит ваш локальный dev до той же точки, что и удаленная ветка dev. Обратите внимание, что он выберет все ветви, но потянет только ту, на которой вы находитесь, на вершину дерева.

Когда вы делаете «git clone git: // location», все ветки и теги выбираются.

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

git checkout -b branch origin/branchname

Используйте псевдонимы. Хотя в 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 cloneзагружает все удаленные ветви, но все еще считает их «удаленными», даже если файлы находятся в вашем новом хранилище. Есть одно исключение, которое заключается в том, что процесс клонирования создает локальную ветвь с именем "master" из удаленной ветки с именем "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видеть локальные ветви).

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

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

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

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

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

git branch

Вывод понравится;

*your current branch 
some branch2
some branch3 

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

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

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

На данный момент у вас есть полная копия удаленного репо со всеми его ветками (проверьте с помощью git branch). Вы можете использовать --mirrorвместо, --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» могут быть успешно запущены при закрытии вашего wifi. Итак, доказано, что когда вы делаете «git clone», он уже скопировал все ветви из удаленного репо. После этого вам не нужно удаленное репо, ваш локальный уже имеет коды всех филиалов.

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

Используйте мой инструмент git_remote_branch (вам нужен Ruby, установленный на вашем компьютере). Он создан специально для упрощения работы с удаленными ветвями.

Каждый раз, когда он выполняет операцию от вашего имени, он печатает ее красным на консоли. Со временем они наконец втыкаются в ваш мозг :-)

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

Наконец, все команды имеют псевдонимы для упрощения запоминания.

Обратите внимание, что это альфа-программа ;-)

Вот справка, когда вы запускаете grb help:

git_remote_branch версия 0.2.6

  Применение:

  grb создать имя_в ветви [origin_server] 

  grb publish branch_name [origin_server] 

  GRB переименовать имя_расхода [origin_server] 

  grb удалить имя_власти [origin_server] 

  GRB-трек имя_сервера [origin_server] 



  Ноты:
  - Если origin_server не указан, предполагается, что имя 'origin' 
    (Git по умолчанию)
  - Функция переименования переименовывает текущую ветку

  Мета-команда объяснения: вы также можете добавить любую команду с помощью 
Ключевое слово «объяснить». Вместо выполнения команды, git_remote_branch
просто выведет список команд, которые нужно выполнить для выполнения 
эта цель.

  Пример: 
    грб объяснить создать
    GRB объяснить создать my_branch GitHub

  Все команды также имеют псевдонимы:
  создать: создать, новый
  удалить: удалить, уничтожить, убить, удалить, RM
  публиковать: публиковать, remotize
  переименовать: переименовать, рн, мв, двигаться
  отслеживать: отслеживать, следовать, захватить, получить

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

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

$ 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 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 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, она не будет загружена!

Спасибо Bigfish за оригинальную идею

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

1. проверьте мастер (чтобы мы могли удалить ветку, в которой мы находимся)
2. выберите пульт, чтобы оформить заказ (замените его на тот, который у вас есть)
3. цикл по всем веткам пульта, кроме master и HEAD
   1. удалить локальную ветку (чтобы мы могли проверить принудительно обновленные ветки)
   2. проверить ветку с пульта
4. проверить мастер (ради этого)

На основании ответа на VonC .

Я написал эти небольшие функции 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

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

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

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

Он также может быть изменен, поэтому он вызывает явное git checkout -b <branch> -t <remote>/<branch> команду.

Этот ответ следует Никос C. «s идея .

В качестве альтернативы мы можем указать удаленную ветку. Это основано на murphytalk «s ответ .

git branch -r | awk '{ system("git checkout -t " $NF) }'

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

Обе команды могут быть псевдонимами.

Используя чей -либо ответ в качестве ссылки, мы можем использовать следующие команды для создания псевдонимов:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Лично я бы использовал track-allили track-all-branches.

Мне нужно было сделать то же самое. Вот мой скрипт на Ruby .

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

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

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

Таким образом, я нашел эти два метода очень полезными. Надеюсь, они помогут кому-то еще.

Способ 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

Git обычно (если не указан) извлекает все ветви и / или теги (ссылки, см .:) 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(см. Этот пост ).

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

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

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

(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