git clone应该复制整个存储库。尝试克隆它，然后运行git branch -a。它应该列出所有分支。如果您想切换到分支“foo”而不是“master”，请使用git checkout foo。

当您执行“git clone git：//位置”时，将获取所有分支和标签。

为了在特定远程分支之上工作，假设它是原始远程分支：

git checkout -b branch origin/branchname

您正在执行的获取应该会获取所有远程分支，但它不会为它们创建本地分支。如果您使用gitk，您应该会看到远程分支被描述为“远程/起源/开发”或类似的东西。

要基于远程分支创建本地分支，请执行以下操作：

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"

现在，当你在开发分支上时，“git拉取”将把你的本地开发更新到与远程开发分支相同的点。请注意，它将获取所有分支，但只将你所在的分支拉到树的顶部。

首先，克隆一个远程git存储库和#0：

$ git clone git://example.com/myproject$ cd myproject

接下来，查看存储库中的本地分支：

$ git branch* master

但是还有其他分支隐藏在您的存储库中！使用-a标志查看这些：

$ git branch -a* masterremotes/origin/HEADremotes/origin/masterremotes/origin/v1.0-stableremotes/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* experimentalmaster

您可以使用git remote跟踪多个远程存储库：

$ git remote add win32 git://example.com/users/joe/myproject-win32-port$ git branch -a* masterremotes/origin/HEADremotes/origin/masterremotes/origin/v1.0-stableremotes/origin/experimentalremotes/win32/masterremotes/win32/new-widgets

在这一点上，事情变得非常疯狂，所以运行gitk看看发生了什么：

$ gitk --all &

使用我的工具git_remote_branch（grb）。您需要在机器上安装ruby）。它是专门为远程分支操作而构建的。

每次它代表你执行操作时，它都会在控制台以红色打印它。随着时间的推移，它们最终会粘在你的大脑中：-）

如果您不希望grb代表您运行命令，只需使用“解释”功能。命令将打印到您的控制台而不是为您执行。

最后，所有命令都有别名，以使记忆更容易。

注意这是alpha软件；-）

以下是运行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 thekeyword 'explain'. Instead of executing the command, git_remote_branchwill simply output the list of commands you need to run to accomplishthat goal.
Example:grb explain creategrb explain create my_branch github
All commands also have aliases:create: create, newdelete: delete, destroy, kill, remove, rmpublish: publish, remotizerename: rename, rn, mv, movetrack: track, follow, grab, fetch

关于，

git检出-b实验起源/实验

使用

git checkout -t origin/experimental

或者更冗长但更容易记住

git checkout --track origin/experimental

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

我需要做完全一样的事情。这是我的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\//, '')] = lineelselocal << lineendend# Updateremote.each_pair do |loc, rem|next if local.include?(loc)%x[git checkout --track -b #{loc} #{rem}]end%x[git fetch]

如果您有许多远程分支要一次获取，请执行以下操作：

git pull --all

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

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

• 大鱼的回答
• 戴夫的回答

这个Bash脚本帮助了我：

#!/bin/bashfor branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); dogit branch --track "${branch##*/}" "$branch"done

它将为所有远程分支创建跟踪分支，除了master（您可能是从原始clone命令中获得的）。我想你可能仍然需要做一个

git fetch --allgit 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

只要这样做：

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyzBranch branchxyz set up to track remote branch branchxyz from origin.Switched to a new branch 'branchxyz'
$ git pullAlready up-to-date.
$ git branch* branchxyzmaster
$ git branch -a* branchxyzmasterremotes/origin/HEAD -> origin/masterremotes/origin/branchxyzremotes/origin/branch123

您看，git clone git://example.com/myprojectt获取所有内容，甚至是分支，您只需签出它们，然后将创建您的本地分支。

使用--mirror选项似乎可以正确复制remote跟踪分支。但是，它将存储库设置为裸存储库，因此您必须在之后将其转换回正常存储库。

git clone --mirror path/to/original path/to/dest/.gitcd path/to/destgit config --bool core.bare falsegit checkout anybranch

^{参考：Git常见问题解答：如何克隆具有所有远程跟踪分支的存储库？}

您可以轻松切换到分支，而无需使用花哨的“git check out-b一些分支起源/一些分支”语法。您可以执行：

git checkout somebranch

Git会自动做正确的事情：

$ git checkout somebranchBranch somebranch set up to track remote branch somebranch from origin.Switched to a new branch 'somebranch'

Git将检查同名分支是否恰好存在于一个远程分支中，如果存在，它会以与您明确指定它是远程分支相同的方式跟踪它。从Git1.8.2.1的git-check out手册页：

如果没有找到<分支>，但确实存在跟踪分支只有一个具有匹配名称的远程（称之为<远程>），视为相当于

$ git checkout -b <branch> --track <remote>/<branch>

我想这就是诀窍：

mkdir YourRepocd YourRepogit init --bare .git                       # create a bare repogit remote add origin REMOTE_URL           # add a remotegit fetch origin refs/heads/*:refs/heads/* # fetch headsgit fetch origin refs/tags/*:refs/tags/*   # fetch tagsgit init                                   # reinit work treegit checkout master                        # checkout a branch

到目前为止，这对我有效。

以下是做到这一点的最佳方法：

mkdir repocd repogit clone --bare path/to/repo.git .gitgit config --unset core.baregit reset --hard

此时，您拥有远程存储库及其所有分支的完整副本（使用git branch验证）。如果您的远程存储库有自己的远程存储库，您可以使用--mirror而不是--bare。

使用别名。虽然没有任何本机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

我试图找出如何删除我在本地删除的远程分支。Origin不是我的，我不想经历重新克隆所有东西的麻烦。

这对我有效：

假设您需要在本地重新创建分支：

git checkout -b recreated-branch-namegit branch -a (to list remote branches)git rebase remotes/remote-origin/recreated-branch-name

所以如果我从gituser/master分叉到sjp，然后分支到sjp/新分支，它看起来像这样：

$ git checkout -b mynewbranch
$ git branch -amasterremotes/sjp/masterremotes/sjp/mynewbranch
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch

对于复制粘贴到命令行：

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}'`; dogit branch -D $brname ;git checkout -b $brname $remote/$brname ;done ;git checkout master

这将：

1. 签出master（以便我们可以删除我们所在的分支）
2. 选择远程结帐（将其更改为您拥有的任何远程）
3. 遍历所有分支的遥控器，除了master和HEAD0.删除本地分支（以便我们可以查看强制更新的分支）0.检查远程分支
4. 看看主人（为了它）

它基于VonC的答案

这不是太复杂。非常简单和直接的步骤如下：

git fetch origin：这将把所有远程分支带到本地。

git branch -a：这将显示所有远程分支。

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

通过以下命令验证您是否在所需的分支中；

git branch

输出会像这样；

*your current branchsome branch2some branch3

注意表示当前分支的*符号。

为什么你只看到“主人”

git clone下载所有远程分支，但仍然认为它们是“远程的”，即使文件位于您的新存储库中。有一个例外，那就是克隆过程从名为“master”的远程分支创建了一个名为“master”的本地分支。默认情况下，git branch只显示本地分支，这就是为什么您只看到“master”。

git branch -a显示所有分支，包括远程分支。

如何获得本地分支机构

如果你真的想在分支上工作，你可能需要它的“本地”版本。要简单地从远程分支（不检查它们，从而更改您的工作目录的内容）创建本地分支，你可以这样做：

git branch branchone origin/branchonegit branch branchtwo origin/branchtwogit branch branchthree origin/branchthree

在此示例中，branchone是您基于origin/branchone创建的本地分支的名称；如果您想创建具有不同名称的本地分支，您可以这样做：

git branch localbranchname origin/branchone

创建本地分支后，您可以使用git branch查看它（请记住，您不需要-a即可查看本地分支）。

你只需要使用“git clone”来获取所有分支。

git clone <your_http_url>

即使您只看到master分支，您也可以使用“git分支-a”查看所有分支。

git branch -a

您可以切换到您已经拥有的任何分支。

git checkout <your_branch_name>

不要担心在你“git clone”之后，你不需要连接远程存储库。在你没有互联网连接的情况下，“git clone-a”和“git check out”可以成功运行。所以证明当你做“git clone”时，它已经从远程存储库复制了所有分支。之后，你不需要远程存储库。你的本地已经有了所有分支的代码。

这些答案都没有削减它，除了用户没有人在正确的轨道上。

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

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

方法一：

git clone --mirror OLD_REPO_URLcd new-cloned-projectmkdir .gitmv * .gitgit config --local --bool core.bare falsegit reset --hard HEADgit remote add newrepo NEW_REPO_URLgit push --all newrepogit 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_URLcd new-cloned-projectgit clone-branchesgit remote add newrepo NEW_REPO_URLgit push --all newrepogit push --tags newrepo

看着这个问题的一个答案，我注意到可以缩短它：

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

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

这是另一个简短的单行命令为所有远程分支创建本地分支：

(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 branch -a

您可以显示存储库的所有分支，并使用命令

git checkout -b branchname origin/branchname

然后，您可以一次手动“下载”它们。

然而，当你想克隆一个有很多分支的存储库时，与我将展示的一种更清晰、更快的方法相比，前面答案中说明的所有方法都冗长而乏味，尽管它有点复杂。你需要三个步骤来完成这一点：

1.第一步

在您的机器上创建一个新的空文件夹，并从存储库中克隆. git文件夹的镜像副本：

cd ~/Desktop && mkdir my_repo_folder && cd my_repo_foldergit clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git

文件夹my_repo_folder中的本地存储库仍然是空的，现在只有一个隐藏的. git文件夹，您可以从终端使用“ls-alt”命令查看。

2.第二步

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

git config --bool core.bare false

3.第三步

获取当前文件夹中的所有内容并在本地机器上创建所有分支，从而使其成为一个普通的存储库。

git reset --hard

所以现在您只需键入命令“git分支”，您就可以看到所有分支都已下载。

这是一种快速的方法，您可以一次克隆包含所有分支的Git存储库，但这并不是您想以这种方式为每个项目做的事情。

使用你能记住的命令

我用的是比特桶，艾特莱森的存储库托管服务。所以我试着跟踪他们的留档。这对我来说很完美。使用以下简单而简短的命令，您可以结帐您的远程分支。

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

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

就是这样。这里有一个更真实的例子：

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

您将在留档中找到有关命令的详细信息：克隆命令，获取命令，签出命令

Git通常（当未指定时）从一个或多个其他存储库中获取所有分支和/或标签（refs，请参阅：git ls-refs）以及完成其历史记录所需的对象。换句话说，它获取已经下载的对象可访问的对象。参见：#1到底是做什么的？

有时你可能有分支/标签没有直接连接到当前分支/标签，所以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

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 fetchFrom github.com:Foo/Bar* [new branch]      missing_branch -> origin/missing_branch

故障排除

如果您仍然无法获得master分支以外的任何内容，请检查以下内容：

• 仔细检查您的遥控器（git remote -v），例如。
  • 验证git config branch.master.remote是origin。
  • 检查origin是否指向正确的URL：git remote show origin（见这篇文章）。

我编写了这些小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设置存储库中找到。

#!/bin/bashfor branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; dogit branch --track ${branch#remotes/origin/} $branchdone

这些代码将所有远程分支代码拉取到本地存储库。

从本地仓库克隆将不适用于git clone和git提取：许多分支/标签将保持未获取状态。

获取具有所有分支和标签的克隆。

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

要获得具有所有分支和标签但也具有工作副本的克隆：

git clone --mirror git://example.com/myproject myproject/.gitcd myprojectgit config --unset core.baregit config receive.denyCurrentBranch updateInsteadgit checkout master

截至2017年初，答案在本评论有效：

git fetch <origin-name> <branch-name>为您关闭分支。虽然这不会一次拉取所有分支，但您可以单独执行每个分支。

OK，当您克隆您的repo时，您在那里拥有所有分支…

如果你只是做git branch，它们有点隐藏…

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

git branch --all或git branch -a

如果你只是结帐到分支机构，你得到所有你需要的。

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

在这种情况下，只需：

git fetch

再检查一遍所有的分支…

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

git fetch && git checkout your_branch_name

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

原始存储库上的git clone --mirror对此效果很好。

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

如果你使用比特桶，你可以使用导入存储库。这将导入所有Git历史记录（所有分支和提交）。

此变体将克隆一个远程存储库，其中所有分支都在本地可用，而无需逐个签出每个分支。不需要花哨的脚本。

创建一个与您要克隆和cd的存储库同名的文件夹，例如：

mkdir somerepocd somerepo

现在执行这些命令，但使用实际的repo usersname/reponame

git clone --bare git@github.com:someuser/somerepo.git .gitgit config --bool core.bare falsegit reset --hardgit branch

你有所有的分支在那里！

这是一个使用awk的答案。如果在新的存储库上使用，此方法应该就足够了。

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

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

它也可以被修改，因此它调用显式的git checkout -b <branch> -t <remote>/<branch>命令。

这个答案遵循Nikos C.的想法。

或者我们可以指定远程分支。这是基于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 http://user@repo.url

git pull --all

接受的答案git branch -a仅显示远程分支。如果您尝试checkout分支，您将无法，除非您仍然有网络接入到源服务器。

信用：Gabe Kopley的建议使用git pull --all。

备注：
当然，如果您不再具有对#0服务器的网络访问权限，#1将不会在您的存储库克隆中反映任何更新。它们的修订将反映您执行上述两个存储库克隆命令的日期和时间的提交。

要使用一个命令将所有克隆分支签出到地方分支机构，请使用下面的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

或

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

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

上述命令将checkout本地分支到您的本地git存储库中，命名与#1相同，并将其设置为--track更改从#3服务器上的远程分支，如果您再次重新获得对原始存储服务器的网络访问权限并以通常的方式执行git pull命令。

所有分支

从Git项目下载所有brach的脚本

安装：

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

准备好了！现在只需调用命令（allBronches）并告诉Git项目目录您要下载所有分支

使用

示例1：

~$ allBranches /var/www/myproject1/

示例2：

~$ allBranches /var/www/myproject2/

示例3（如果已经在项目目录中）：

~$ allBranches ./

或

~$ allBranches .

查看结果：

git branch

参考：

仓库所有分支GitHub：https://github.com/marceloviana/allBranches

对于使用Visual Studio代码的开发人员来说，更好的替代解决方案是使用Git阴影扩展。

此Visual Studio Code扩展允许克隆存储库内容和目录，这些内容和目录可以按分支名称或提交哈希进行过滤。这样，分支或提交就可以用作新项目的样板/模板。

这是一个根据前面的答案改编的跨平台PowerShell7函数。

function Invoke-GitCloneAll($url) {$repo = $url.Split('/')[-1].Replace('.git', '')$repo_d = Join-Path $pwd $repoif (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 --allWrite-Host "" #newline}}

备注：-c fetch.prune=false使它包含通常会被排除在外的陈旧分支。如果您对它不感兴趣，请删除它。

您可以通过从函数中删除&&来使PowerShell 5.1（Windows 10中的默认值）起作用，但即使前一个命令失败，它也会尝试git pull。因此，我强烈建议只使用跨平台的PowerShell，它总是让您担心尝试。

在这里，我给你写了一个很好的函数，使其易于重复

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

这个解决方案可以让我将一个存储库“复制”到另一个存储库：

git merge path/to/source.git --mirrorcd source.gitgit remote remove origingit remote add origin path/to/target.gitgit push origin --allgit push origin --tags

在目标存储库上，我可以看到与原始存储库相同的分支和标签。

每当我需要删除所有分支时，我都会这样做。来自Linkedin Learning的学分Ray Villalobos。尝试克隆所有分支，包括提交：

mkdir -p -- newproject_foldercd newproject_foldergit clone --mirror https://github.com/USER_NAME/RepositoryName.git .gitgit config --bool core.bare falsegit reset --hard

执行远程存储库的裸克隆，将内容保存到. git目录

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

（裸git存储库，使用git clone--的创建或git init的，是一个存储存储库，它没有一个工作目录，你不能创建或修改文件。

将目录更改为本地目录

cd localdirname

使您的git存储库可修改

git config --bool core.bare false

恢复您的工作目录

git reset --hard

列出你所有的分支

git branch -al

要创建存储在您的git主机（github/bit桶/etc）中的所有分支+refs+tags+etc的“完整”备份，请运行：

mkdir -p -- myapp-mirrorcd myapp-mirrorgit clone --mirror https://git.myco.com/group/myapp.git .gitgit config --bool core.bare falsegit config --bool core.logAllRefUpdates truegit reset --hard # restore working directory

这是我从其他答案中学到的所有东西。

然后，您可以使用此本地存储库镜像过渡到不同的SCM系统/git主机，或者您可以将其保留为备份。它也可以用作搜索工具，因为大多数git主机只搜索每个存储库的“主”分支上的代码，如果您git log -S"specialVar"，您将看到所有分支上的所有代码。

注意：如果您想在日常工作中使用此存储库，请运行：

git config --unset remote.origin.mirror

警告：如果您尝试在日常工作中使用此功能，您可能会遇到奇怪的问题。如果您的ide/编辑器正在进行一些自动获取，您的本地master可能会更新，因为您做了git clone --mirror。然后这些文件出现在您的git暂存区域中。我实际上遇到了一种情况，我在本地功能分支上…该分支没有提交，存储库中的所有文件都出现在暂存区域中。坚果。

我正在从Udemy课程使用Python和Pytest的优雅自动化框架中克隆一个存储库，以便稍后可以查看它离线。我尝试下载zip，但这只适用于当前分支，所以这是我的2美分。

我在Windows上工作，显然，我从WindowsLinux子系统诉诸Ubuntu shell。克隆后，这是我的分支：

$ git clone https://github.com/BrandonBlair/elegantframeworks.git
$ git branch -a
* masterremotes/origin/HEAD -> origin/masterremotes/origin/config_reciperemotes/origin/functionaltestsremotes/origin/masterremotes/origin/parallelremotes/origin/parametrizeremotes/origin/parametrize_data_excelremotes/origin/unittestingremotes/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_recipefunctionaltestsmasterparallelparametrizeparametrize_data_excelunittesting* unittesting1remotes/origin/HEAD -> origin/masterremotes/origin/config_reciperemotes/origin/functionaltestsremotes/origin/masterremotes/origin/parallelremotes/origin/parametrizeremotes/origin/parametrize_data_excelremotes/origin/unittestingremotes/origin/unittesting1

我的是物理的，去掉最初的 remotes/origin/，然后过滤空格分隔符。可以说，我可以只grep去掉HEAD，用一个cut完成，但我会把它留给评论。

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

如何为远程origin匹配pattern上的每个分支创建本地分支。

#!/bin/shgit fetch --allgit for-each-ref --format='%(refname:short)' refs/remotes/origin/pattern |\sed 's@\(origin/\)\(.*\)@\2\t\1\2@' |\xargs -n 2 git branch --track

获取所有远程引用（分支/标签），然后创建本地引用。应该可以在大多数系统上快速工作，而无需检查索引或依赖bashism。