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

у меня есть master и development бранч, оба нажаты на GitHub. Я cloned,pullЭд, и fetchЭД, но я по-прежнему не могу получить ничего, кроме master ветку обратно.

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

30 ответов


во-первых, клонировать удаленный 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

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

$ git checkout origin/experimental

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

$ git checkout experimental

и вы увидите

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

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

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


этой Баш скрипт выручил меня:

#!/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{}) {print qq(git branch --track /\n)} else {$d{$_}=1}' | csh -xfs как обычно: проверьте в настройках перед копированием rm-rf Юниверса, как мы его знаем

кредиты для one-liner перейти к пользователю 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:

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

$ 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

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

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "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 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 загружает все удаленные удаленные ветви, но по-прежнему считает их "удаленными", даже если файлы находятся в Вашем новом репозитории. Есть одно исключение из этого, которое заключается в том, что процесс клонирования создает локальную ветвь под названием "master" из удаленной ветви под названием "master". По умолчанию git branch показывает только локальные ветви, поэтому вы видите только "master".

git branch -a показывает все филиалы, включая remote ветви.


как получить местные отделения

если вы действительно хотите работать над филиалом, вам, вероятно, понадобится его "локальная" версия. Чтобы просто создать локальные ветви из удаленных ветвей (не проверяя их и тем самым изменяя содержимое вашего рабочего каталога), вы можете сделать это так:

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 если удаленный РЕПО собственных пультов.


просто сделать это:

$ 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: / / пример.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", он уже скопировал все ветви из удаленного РЕПО. После этого вам не нужно удаленное РЕПО, у вашего локального уже есть коды всех филиалов.


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


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

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

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

наконец, все команды имеют псевдонимы, чтобы облегчить запоминание.

обратите внимание, что это программное обеспечение alpha ;-)

вот справка при запуске справки grb:

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's 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

затем вы можете "загрузить" их вручную по одному за раз.


однако, когда вы хотите клонировать РЕПО с большим количеством ветвей, все способы, иллюстрированные выше, длинны и утомительны в отношении гораздо более чистого и быстрого способа, который я собираюсь показать, хотя это немного сложно. Для этого нужно сделать три шага:--6-->

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

  1. второй шаг

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

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

возьмите все, что внутри текущая папка и создайте все ветви на локальном компьютере, поэтому сделайте это обычным РЕПО.

$ git reset --hard

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

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


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

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

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

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


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

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

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

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

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

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

в этом случае, просто do:

git fetch

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

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

git fetch && git checkout your_branch_name

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

git branch --all to get all branches


для копирования-вставки в командную строку:

git checkout master ; remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",); print }'`; 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(/^[^\/]+\//,"",); print }'
`; do
    git branch -D $brname ;
    git checkout -b $brname $remote/$brname ;
done ;
git checkout master


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

на основе ответ of VonC.


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

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

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

Я написал это маленькое Powershell функции, чтобы иметь возможность проверять все мои ветви git, которые находятся на origin remote.

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 repo


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

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

сначала клонировать ваш репозиторий, затем перейдите в папку назначения. И последнее, но не менее важное: fetch and checkout:

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

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


Git обычно (если не указано) извлекает все ветви и / или теги (ссылки, см.: git ls-refs) из одного или нескольких других репозиториев вместе с объектами, необходимыми для завершения их истории. Другими словами, он извлекает объекты, которые доступны для объектов, которые уже загружены. См.: что значит git fetch действительно?

иногда у вас могут быть ветви / теги, которые напрямую не связаны с текущим, поэтому git pull --all/git fetch --all не поможет в в этом случае, но вы можете перечислить их по:

git ls-remote -h -t origin

и получить их вручную, зная имена ref.

так приведи их всех попробуй:

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

by 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 is origin.
    • проверить, если origin указывает на правый URL через:git remote show origin (см. в должности).

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

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


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

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

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

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

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

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

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

Если вам не нужен master ветка проверена после клонирования, используйте

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout

Я собираюсь добавить свои 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