如何克隆所有远程分支？

首先，将远程 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

现在您可以根据需要签出任何分支，而无需访问远程存储库。

注意：这不会创建任何未签出分支的工作副本，这就是问题所在。为此，请参阅

大鱼的回答

戴夫的回答

---

这个 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（您可能从原始克隆命令中获得）。我想你可能还需要做一个

git fetch --all
git pull --all

为了确定。

一个班轮： git branch -a | grep -v 头 | 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 之前在您的设置中进行测试，正如我们所知

---

使用 --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: How do I clone a repository with all remotely tracked branches?}

---

您可以轻松切换到分支，而无需使用花哨的“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 1.8.2.1 的 git-checkout 手册页：

如果 未找到，但在一个远程（称为 ）中确实存在一个具有匹配名称的跟踪分支，则视为等同于 $ git checkout -b --track /<分公司>

---

关于，

git checkout -b 实验起源/实验

使用

git checkout -t origin/experimental

或者更冗长，但更容易记住

git checkout --track origin/experimental

在跟踪远程存储库方面可能会更好。

---

您正在执行的 fetch 应该获取所有远程分支，但不会为它们创建本地分支。如果您使用 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

---

这是执行此操作的最佳方法：

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://location”时，将获取所有分支和标签。

为了在特定的远程分支上工作，假设它是源远程：

git checkout -b branch origin/branchname

---

为什么你只看到“大师”

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 ”可以在没有网络连接的情况下成功运行。所以证明当你做“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. 第二步

通过将 Git 配置的布尔值“bare”切换为 false，将此存储库从空（裸）存储库切换到常规存储库：

git config --bool core.bare false

3. 第三步

抓取当前文件夹中的所有内容并在本地计算机上创建所有分支，从而使其成为一个正常的存储库。

git reset --hard

所以现在你可以输入命令“git branch”，你可以看到所有的分支都被下载了。

这是您可以一次克隆包含所有分支的 Git 存储库的快速方法，但您不想以这种方式对每个项目都执行此操作。

---

自包含的存储库

如果您正在寻找包含所有远程分支和提交日志的独立克隆或备份，请使用：

git clone http://user@repo.url

git pull --all

git branch -a 接受的答案仅显示远程分支。如果您尝试checkout您将无法访问的分支，除非您仍然具有对原始服务器的网络访问权限。

学分： Gabe Kopley's 建议使用 git pull --all。

注意：
当然，如果您不再有网络访问 remote/origin 服务器，remote/origin branches 将没有任何更新反映在您的存储库克隆中。他们的修订将反映您执行上述两个存储库克隆命令的日期和时间的提交。

要使用一个命令将所有克隆分支检出到本地分支，请使用以下 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

或者

如果你的仓库有嵌套分支，那么这个命令也会考虑到这一点：

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 从 上的远程分支更改{4 } 服务器如果您再次重新获得对原始存储库服务器的网络访问权限并以通常的方式执行 git pull 命令。

---

使用我的工具 git_remote_branch (grb)。您需要在您的机器上安装 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'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

---

从本地 repo 克隆不适用于 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

---

#!/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 branch，它们有点隐藏......

因此，如果您想查看所有分支名称，只需添加 --all 标志，如下所示：

git branch --all 或 git branch -a

如果您只是结帐到分行，您将获得所需的一切。

但是如果你克隆后别人创建的分支呢？

在这种情况下，只需执行以下操作：

git fetch

并再次检查所有分支......

如果您想同时提取和结帐，您可以执行以下操作：

git fetch && git checkout your_branch_name

还为您创建了下面的图像以简化我所说的：

https://i.stack.imgur.com/gn2pi.png

---

查看问题的答案之一，我注意到可以缩短它：

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

但请注意，如果远程分支之一被命名，例如 admin_master，它将不会被下载！

---

原始 repo 上的 git clone --mirror 对此非常有效。

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

---

除了user nobody is on the right track之外，这些答案都没有削减它。

我在将存储库从一台服务器/系统移动到另一台服务器/系统时遇到了麻烦。当我克隆存储库时，它只为master创建了一个本地分支，所以当我推送到新的远程时，只推送了master分支。

所以我发现这两种方法非常有用。

方法一：

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

方法二：

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

---

这是一个使用 awk 的答案。如果在新的 repo 上使用此方法就足够了。

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

现有的分支将被简单地检出，或声明为已经存在，但可以添加过滤器以避免冲突。

也可以对其进行修改，以便调用显式 git checkout -b <branch> -t <remote>/<branch> 命令。

此答案遵循 Nikos C. 的 idea。

或者，我们可以指定远程分支。这是基于 murphytalk 的 answer。

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。

---

对于复制粘贴到命令行：

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（以便我们可以删除我们所在的分支）选择远程结帐（将其更改为您拥有的任何远程）循环通过远程的所有分支，除了 master 和 HEAD 0。删除本地分支（以便我们可以签出强制更新分支） 0. 从远程签出主机签出分支（为了它）

它基于 VonC 的 the answer。

---

我编写了这些小的 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 函数可以在 my Git settings repository 中找到。

---

使用你能记住的命令

我正在使用 Bitbucket，这是 Atlassian 的存储库托管服务。所以我尝试遵循他们的文档。这对我来说非常有效。使用以下简单而简短的命令，您可以签出您的远程分支。

首先克隆您的存储库，然后更改为目标文件夹。最后但并非最不重要的一点是获取和结帐：

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

而已。这里有一个更真实的例子：

git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

您将在文档中找到有关命令的详细信息：Clone Command、Fetch Command、Checkout Command

---

我正在从 Udemy 课程 Elegant Automation Frameworks with Python and Pytest 中克隆一个存储库，以便以后可以离线复习它。我尝试下载 zip，但这仅适用于当前分支，所以这是我的 2 美分。

我在 Windows 上工作，显然，我使用了 Windows Subsystem for Linux 中的 Ubuntu shell。克隆后，这是我的分支：

$ git clone https://github.com/BrandonBlair/elegantframeworks.git

$ git branch -a

* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/config_recipe
  remotes/origin/functionaltests
  remotes/origin/master
  remotes/origin/parallel
  remotes/origin/parametrize
  remotes/origin/parametrize_data_excel
  remotes/origin/unittesting
  remotes/origin/unittesting1

然后——在碰了几堵git checkout砖墙之后——最终对我有用的是：

$ for b in `git branch -a | cut -c18- | cut -d\  -f1`; do git checkout $b; git stash; done

在此之后，这是我的分支：

$ git branch -a

  config_recipe
  functionaltests
  master
  parallel
  parametrize
  parametrize_data_excel
  unittesting
* unittesting1
  remotes/origin/HEAD -> origin/master
  remotes/origin/config_recipe
  remotes/origin/functionaltests
  remotes/origin/master
  remotes/origin/parallel
  remotes/origin/parametrize
  remotes/origin/parametrize_data_excel
  remotes/origin/unittesting
  remotes/origin/unittesting1

我的是物理的，删除初始的 remotes/origin/，然后过滤空格分隔符。可以说，我可以grep淘汰HEAD并完成一个cut，但我将把它留给评论。

请注意，您当前的分支现在是列表中的最后一个。如果你不知道为什么会这样，那么你就处于困境中。现在只需git checkout您想要的任何东西。

---

我需要做同样的事情。这是我的 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]

---