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

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

$ git pull --all

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

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

• https://stackoverflow.com/a/4754797/430062
• https://stackoverflow.com/a/7216269/430062

Мне помог этот сценарий Bash:

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

Что должно вернуть что-то вроде:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

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

Используйте псевдонимы. Хотя в 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 git: // location», выбираются все ветки и теги.

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

git checkout -b branch origin/branchname

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

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

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

Просто сделай это:

$ 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" могут быть успешно запущены при закрытии Wi-Fi. Итак, доказано, что когда вы выполняете «git clone», он уже скопировал все ветки из удаленного репо. После этого вам не понадобится удаленное репо, у вашего локального уже есть коды всех веток.

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

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

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

$ 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_remote_branch (вам понадобится Ruby установлен на вашем компьютере). Он создан специально, чтобы упростить удаленные манипуляции с ветвями.

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

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

Наконец, у всех команд есть псевдонимы, чтобы упростить запоминание.

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

Вот справка при запуске 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'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 clone http://[email protected]

git pull --all

Принятый ответ git branch -a только показывает удаленные ветви. Если вы попытаетесь checkout открыть филиалы, вы не сможете это сделать, если у вас все еще нет сетевого доступа к исходному серверу.

Кредит: Гейба Копли за предложение использовать git pull --all.

Примечание.
Конечно, если у вас больше нет сетевого доступа к серверу remote/origin, remote/origin branches не будет иметь обновлений, отраженных в их. Их изменения будут отражать коммиты с даты и времени, когда вы выполнили 2 команды, указанные выше.

Чтобы извлечь ВСЕ ваши клонированные ветки в локальные ветки с помощью одной команды, используйте одну из команд bash ниже:

$ for i in $(git branch -a |grep 'remotes' | awk -F/ '{print $3}' \ 
| grep -v 'HEAD ->');do git checkout -b $i --track origin/$i; done

OR

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

for i in $(git branch -a |grep 'remotes' |grep -v 'HEAD ->');do \
basename ${i##\./} | xargs -I {} git checkout -b {} --track origin/{}; done

Приведенные выше команды checkout создадут локальную ветвь в вашем локальном репозитории git, названную так же, как remote/origin/<branchname>, и установят для нее --track изменения из удаленной ветки на сервере remote/origin, если вы восстановите сетевой доступ к исходному серверу репозитория еще раз и выполните команду git pull обычным способом.

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

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

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 or git branch -a

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

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

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

git fetch

и еще раз проверим все ветки ...

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

git fetch && git checkout your_branch_name

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

#!/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. loop through all branches of the remote except master and HEAD
   1. delete local branch (so that we can check out force-updated branches)
   2. проверить ветку с пульта дистанционного управления
4. проверить мастера (ради него)

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

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

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

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

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

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

Этот ответ следует за ответом Никоса С. идея.

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

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.

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

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

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

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

(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

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

Иногда у вас могут быть ветки / теги, которые напрямую не связаны с текущим, поэтому _3 _ / _ 4_ в этом случае не поможет, но вы можете перечислить их:

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

Исправление проблем

Если вы по-прежнему не можете получить ничего, кроме основной ветки, проверьте следующее:

• Double check your remotes (git remote -v), e.g.
  • Validate that git config branch.master.remote is origin.
  • Проверьте, указывает ли origin на правильный URL через: git remote show origin (см. Этот пост).

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

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

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

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

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

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

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

mkdir somerepo
cd somerepo

Теперь выполните эти команды, но с фактическим именем пользователя / репо репо.

git clone --bare [email protected]:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch

Войала! у вас там все ветки!

Немного поздно на вечеринку, но я думаю, что это помогает:

mkdir YourRepo
cd YourRepo
git init --bare .git                       # create a bare repo
git remote add origin REMOTE_URL           # add a remote
git fetch origin refs/heads/*:refs/heads/* # fetch heads
git fetch origin refs/tags/*:refs/tags/*   # fetch tags
git init                                   # reinit work tree
git checkout master                        # checkout a branch

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

Я собираюсь добавить сюда свои 2 цента, потому что я пришел сюда, чтобы узнать, как вытащить удаленную ветку, которую я удалил локально. Origin не был моим, и я не хотел тратить время на повторное клонирование всего

Это сработало для меня:

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

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

Это решение помогло мне скопировать репозиторий в другой:

git merge path/to/source.git --mirror
cd source.git
git remote remove origin
git remote add origin path/to/target.git
git push origin --all
git push origin --tags

В целевом репозитории я вижу те же ветки и теги, что и исходное репозиторий.

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

gitCloneAllBranches() { # clone all git branches at once easily and cd in
  # clone as "bare repo"
  git clone --mirror $1
  # rename without .git extension
  with_extension=$(basename $1)
  without_extension=$(echo $with_extension | sed 's/.git//')
  mv $with_extension $without_extension
  cd $without_extension
  # change from "bare repository" to not
  git config --bool core.bare false
  # check if still bare repository if so
  if [[ $(git rev-parse --is-bare-repository) == false ]]; then
    echo "ready to go"
  else
    echo "WARNING: STILL BARE GIT REPOSITORY"
  fi
  # EXAMPLES:
  # gitCloneAllBranches https://github.com/something/something.git
}

Это то, что я делаю всякий раз, когда мне нужно обрушить все ветки. Благодарности Рэю Вильялобосу от Linkedin Learning. Попробуйте клонировать все ветки, включая коммиты:

mkdir -p -- newproject_folder
cd newproject_folder
git clone --mirror https://github.com/USER_NAME/RepositoryName.git .git
git config --bool core.bare false
git reset --hard

Лучшим альтернативным решением для разработчиков, использующих vscode, является использование Git Shadow Extension. . Это расширение vscode позволяет клонировать содержимое репозитория и каталоги, которые можно фильтровать по имени ветки или хешу фиксации. Таким образом, ветки или коммиты можно использовать в качестве шаблонов / шаблонов для новых проектов.

Вот кроссплатформенная функция PowerShell 7, адаптированная из предыдущих ответов.

function Invoke-GitCloneAll($url) {
    $repo = $url.Split('/')[-1].Replace('.git', '')
    $repo_d = Join-Path $pwd $repo
    if (Test-Path $repo_d) {
        Write-Error "fatal: destination path '$repo_d' already exists and is not an empty directory." -ErrorAction Continue
    } else {
        Write-Host "`nCloning all branches of $repo..."
        git -c fetch.prune=false clone $url -q --progress &&
        git -c fetch.prune=false --git-dir="$(Join-Path $repo_d '.git')" --work-tree="$repo_d" pull --all
        Write-Host "" #newline
    }
}

Примечание. -c fetch.prune=false включает устаревшие ветки, которые обычно исключаются, удалите их, если это вас не интересует.

Вы можете заставить эту работу работать с PowerShell 5.1 (по умолчанию в Windows 10), удалив && из функции, но при этом она будет пытаться git pull, даже если предыдущая команда не удалась. Итак, я настоятельно рекомендую просто использовать кроссплатформенную оболочку PowerShell, которая вас всегда беспокоит.

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

git clone --bare remote-repo-url.git localdirname/.git

(Чистый репозиторий git, созданный с помощью git clone --bare или git init --bare, является репозиторием хранилища, у него нет рабочего каталога, вы не можете создавать или изменять там файлы.)

Измените каталог на свой локальный каталог

cd localdirname

Сделайте ваш репозиторий git изменяемым

git config --bool core.bare false

Восстановите ваш рабочий каталог

git reset --hard

Перечислите все свои филиалы

git branch -al

всеФилиалы

Скрипт для загрузки всех веток из проекта Git

Установка:

sudo git clone https://github.com/marceloviana/allBranches.git && sudo cp -rfv allBranches/allBranches.sh /usr/bin/allBranches && sudo chmod +x /usr/bin/allBranches && sudo rm -rf allBranches

Готовый! Теперь просто вызовите команду (allBranches) и сообщите каталогу проекта Git, что вы хотите загрузить все ветки.

Использование

Пример 1:

~$ allBranches /var/www/myproject1/

Пример 2:

~$ allBranches /var/www/myproject2/

Пример 3 (если он уже находится в каталоге проекта):

~$ allBranches ./

or

~$ allBranches .

Посмотреть результат:

git branch

Ссылка:

Репозиторий allBranches GitHub: https://github.com/marceloviana/allBranches

Если вы используете BitBucket,

вы можете использовать import Repository, это импортирует всю историю git (все ветки и коммиты)