Як клонувати всі віддалені гілки в Git?

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

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

Спочатку клонуйте віддалений сховище 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'

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

Це створить гілки відстеження для всіх віддалених гілок, крім головного (який ви, ймовірно, отримали з оригінальної команди клонування). Я думаю, що вам може знадобитися це зробити

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

Використовуючи --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 check -b експериментальне походження / експериментальний

використовуючи

$ git checkout -t origin/experimental

або більш багатослівне, але простіше запам’ятати

$ git checkout --track origin/experimental

може бути краще, що стосується відстеження віддаленого сховища.

Вибір, який ви робите, має отримати всі віддалені гілки, але це не створить для них локальні гілки. Якщо ви використовуєте gitk, ви повинні побачити віддалені гілки, описані як "видалення / походження / dev" або щось подібне.

Щоб створити локальну гілку на основі віддаленої гілки, зробіть щось на кшталт:

git checkout -b dev refs / remotes / origin / dev

Що має повернути щось на кшталт:

Розробник відділення налаштовано для відстеження віддалених відхилень відділення / віддалених / походження / dev
Переключився на нову гілку "dev"

Тепер, коли ви перебуваєте на гілці розробників, "git pull" оновить ваш локальний розробник до тієї ж точки, що й віддалена гілка розробників. Зауважте, що вона отримає всі гілки, але лише тягніть ту, на якій ви знаходитесь, на верхівку дерева.

Коли ви робите "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відображаються лише локальні гілки, тому ви бачите лише "майстер".

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", він вже скопіював усі гілки з віддаленого репо. Після цього вам не потрібно віддаленого репо, ваш місцевий вже має всі коди філій.

A git cloneповинен скопіювати весь сховище. Спробуйте його клонувати, а потім запустіть git branch -a. У ньому повинні бути перелічені всі гілки. Якщо тоді ви хочете перейти до гілки "foo" замість "master", використовуйте git checkout foo.

Використовуйте мій інструмент git_remote_branch (на вашій машині потрібно встановити Ruby). Він створений спеціально для полегшення маніпуляцій із віддаленими гілками.

Кожен раз, коли він робить операцію від вашого імені, він друкує червоним кольором на консолі. З часом вони нарешті впираються у ваш мозок :-)

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

Нарешті, всі команди мають псевдоніми, щоб полегшити запам'ятовування.

Зауважте, що це альфа-програмне забезпечення ;-)

Ось допомога під час запуску довідки з GRB:

git_remote_branch версія 0.2.6

  Використання:

  grb створити ім'я гілки [origin_server] 

  grb опублікувати ім'я гілки [вихідний_сервер] 

  grb перейменувати ім'я гілки [origin_server] 

  grb видалити ім'я гілки [origin_server] 

  grb track track_name [origin_server] 



  Примітки:
  - Якщо origin_server не вказано, передбачається ім'я "origin" 
    (за замовчуванням git)
  - Функція перейменування перейменовує поточну гілку

  Мета-команда пояснення: ви також можете додати будь-яку команду до 
ключове слово 'пояснити'. Замість виконання команди, git_remote_branch
просто виведе список команд, які потрібно виконати для виконання 
та мета.

  Приклад: 
    grb пояснити створення
    grb пояснити створення my_branch github

  Усі команди також мають псевдоніми:
  творити: творити, новий
  delete: видалити, знищити, вбити, видалити, rm
  публікувати: публікувати, віддаляти
  перейменувати: перейменувати, rn, mv, перемістити
  трек: слідкувати, слідкувати, захоплювати, виносити

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

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

$ 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. Другий крок

переключити це сховище з порожнього (голого) сховища в звичайне сховище, перемикаючи булеве значення "голі" конфігурацій git на хибне:

$ git config --bool core.bare false

3. Третій крок

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

$ git reset --hard

Отже, тепер ви можете просто ввести команду "git гілка", і ви можете побачити, що всі гілки завантажені.

Це швидкий спосіб, за допомогою якого ви можете клонувати сховище git з усіма гілками одночасно, але це не те, що ви хочете зробити для кожного окремого проекту таким чином.

Клонування з локального репо не буде працювати з клоном git & 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. пройдіть через усі гілки дистанційного, крім головного та 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

Ось відповідь, яка використовує 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 зазвичай (якщо не вказано) витягує всі гілки та / або теги (refs, див.:) 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