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

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

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

Ответ 1

Сначала клонируйте удаленный 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 &

Ответ 2

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

$ git pull --all

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

Ответ 3

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

Ответ 4

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

Ответ 5

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

Ответ 6

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

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

используя

$ git checkout -t origin/experimental

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

$ git checkout --track origin/experimental

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

Ответ 7

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

Ответ 8

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

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

git checkout -b branch origin/branchname

Ответ 9

Использовать псевдонимы. Хотя нет никаких родных 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

Ответ 10

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

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

Ответ 11

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

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

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

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

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

git branch

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

*your current branch 
some branch2
some branch3

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

Ответ 12

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

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

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

Ответ 13

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

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

Ответ 14

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

Ответ 15

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

Ответ 16

Используйте мой инструмент 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

Ответ 17

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

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

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

Ответ 18

Хорошо, когда вы клонируете свой репо, у вас есть все ветки там...

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

Поэтому, если вы хотите увидеть все имена веток, просто добавьте флаг --all следующим образом:

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

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

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

В этом случае просто сделайте:

git fetch

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

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

git fetch && git checkout your_branch_name

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

Ответ 19

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

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

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

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

Ответ 20

Клонирование из локального репо не будет работать с 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

Ответ 21

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

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

Ответ 22

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

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.

Ответ 23

Мне нужно было сделать то же самое. Вот мой 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]

Ответ 24

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

Ответ 25

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

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

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

Метод 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

Ответ 26

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 (см. сообщение).

Ответ 27

git clone --mirror на оригинальном репо хорошо работает для этого.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin

Ответ 28

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

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

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

Его также можно изменить, чтобы он вызывал явную команду git checkout -b <branch> -t <remote>/<branch>.

Этот ответ следует Никосу С.идее.

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

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

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

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

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

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.

Ответ 29

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

(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

Ответ 30

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

Я использую 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

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