4516

我有一个master和一个development分支，都推送到了GitHub。我已经cloned、pulled 和ed，但除了分支fetch之外，我仍然无法得到任何东西。master

我确定我遗漏了一些明显的东西，但是我已经阅读了手册，但我一点也不高兴。

4

45 回答 45

4942

首先，克隆一个远程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 &
于 2008-09-16T13:28:22.230 回答
900

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

git pull --all

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

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

于 2011-01-13T16:42:40.067 回答
517

这个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 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

于 2011-01-21T02:18:36.200 回答
437

使用该--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 常见问题解答：如何克隆包含所有远程跟踪分支的存储库？

于 2011-08-27T17:49:44.263 回答
244

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

如果 <branch> 未找到，但在一个远程（称为 <remote>）中确实存在一个具有匹配名称的跟踪分支，则视为等效于

$ git checkout -b <branch> --track <remote>/<branch>
于 2012-05-12T12:11:54.240 回答
101

关于，

git checkout -b 实验起源/实验

使用

git checkout -t origin/experimental

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

git checkout --track origin/experimental

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

于 2009-07-27T06:10:37.503 回答
82

您正在执行的 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分支相同的点。请注意，它将获取所有分支，但只会将您所在的分支拉到树的顶部。

于 2008-09-15T22:52:51.197 回答
72

使用别名。虽然没有任何原生 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
于 2013-05-15T11:02:27.247 回答
66

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

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

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

于 2012-11-26T23:42:29.080 回答
64

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

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

git checkout -b branch origin/branchname
于 2008-09-15T22:47:00.603 回答
58

为什么你只看到“大师”

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查看本地分支）。

于 2014-03-05T13:47:03.530 回答
50

这并不太复杂。非常简单直接的步骤如下；

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

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

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

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

git branch

输出将是这样的；

*your current branch
some branch2
some branch3

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

于 2013-12-26T10:19:21.353 回答
39

只需这样做：

$ 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' 获取所有东西，甚至是分支，你只需要检查它们，然后你的本地分支就会被创建。

于 2011-05-31T11:40:02.647 回答
31

您只需要使用“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 <your_branch_name>”可以在没有网络连接的情况下成功运行。所以证明当你做“git clone”时，它已经从远程仓库复制了所有的分支。之后，您不需要远程存储库。您的本地已经拥有所有分支机构的代码。

于 2014-11-19T15:43:04.407 回答
27

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

于 2008-09-15T22:46:08.450 回答
21

我在这里看到的所有答案都是有效的，但是有一种更简洁的方法来克隆存储库并一次提取所有分支。

当你克隆一个存储库时，实际上是下载了所有分支的信息，但分支是隐藏的。用命令

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 存储库的快速方法，但您不想以这种方式对每个项目都执行此操作。

于 2015-12-06T20:08:41.227 回答
20

自包含的存储库

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

git clone http://user@repo.url

git pull --all

接受的答案git branch -a仅显示远程分支。如果您尝试访问checkout分支，除非您仍然可以通过网络访问原始服务器，否则您将无法访问。

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

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


使用 `git checkout remote/origin/` 以通常的方式检查 *local* 分支 使用 `git branch -a` 显示保存在 `clone` 存储库中的远程分支。

要使用一个命令将所有克隆分支检出到本地分支，请使用以下 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上远程分支的更改.remote/origingit pull

于 2019-09-25T15:03:25.773 回答
19

使用我的工具git_remote_branch ( grb )。你需要在你的机器上安装Ruby ）。它是专门为使远程分支操作变得非常容易而构建的。

每次它代表您执行操作时，都会在控制台上以红色打印。随着时间的推移，它们最终会进入你的大脑:-)

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

最后，所有命令都有别名，以便于记忆。

请注意，这是alpha 软件；-)

这是运行 grb help 时的帮助：

git_remote_branch 版本 0.2.6

  用法：

  grb create branch_name [origin_server]

  grb 发布分支名称 [origin_server]

  grb 重命名 branch_name [origin_server]

  grb 删除分支名称 [origin_server]

  grb 跟踪分支名称 [origin_server]



  笔记：
  - 如果未指定 origin_server，则假定名称为“origin”
    （git的默认值）
  - 重命名功能重命名当前分支

  解释元命令：您还可以在任何命令前面加上
关键字“解释”。而不是执行命令， git_remote_branch
将简单地输出您需要运行以完成的命令列表
那个目标。

  例子：
    grb 解释创建
    grb 解释创建 my_branch github

  所有命令也有别名：
  创造：创造，新的
  删除：删除，销毁，杀死，删除，rm
  发布：发布，远程化
  重命名：重命名，rn，mv，移动
  跟踪：跟踪，跟随，抓取，获取
于 2008-09-20T13:53:58.913 回答
15

从本地 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
于 2017-02-23T23:55:10.470 回答
13

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

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

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

于 2015-02-19T21:33:08.743 回答
13 
#!/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

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

于 2016-12-11T02:20:42.023 回答
13

好的，当你克隆你的仓库时，你有所有的分支......

如果你只是这样做git branch，它们有点隐藏......

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

git branch --all或者git branch -a

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

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

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

git fetch

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

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

git fetch && git checkout your_branch_name

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

git branch --all 获取所有分支

于 2017-07-22T18:29:55.713 回答
10

对于复制粘贴到命令行：

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. 签出master（这样我们就可以删除我们所在的分支）
  2. 选择远程结帐（将其更改为您拥有的任何远程）
  3. 循环遍历除 master 和 HEAD 之外的所有远程分支 0.删除本地分支（以便我们可以签出强制更新的分支） 0.从远程签出分支
  4. 检查大师（为了它）

它基于VonC的答案。

于 2013-12-20T06:38:02.740 回答
10

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

我在将存储库从一台服务器/系统移动到另一台服务器/系统时遇到了麻烦。当我克隆存储库时，它只为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
于 2015-01-23T17:51:19.670 回答
10

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

于 2016-06-19T10:54:23.777 回答
10

git clone --mirror在原始仓库中对此非常有效。

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin
于 2018-05-25T17:34:43.130 回答
10

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

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) }'

它会在冲突中引发致命的错误消息，但我认为它们是无害的。

这两个命令都可以有别名。

使用nobody的答案作为参考，我们可以使用以下命令来创建别名：

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-allor track-all-branches。

于 2019-06-20T14:05:41.617 回答
8

我需要做同样的事情。这是我的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]
于 2010-12-10T23:12:39.360 回答
7

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

(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
于 2015-09-10T12:04:08.903 回答
7

使用你能记住的命令

我正在使用 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

于 2016-03-11T20:01:06.573 回答
7

Git 通常（如果未指定）从一个或多个其他存储库中获取所有分支和/或标签（参考，请参阅：）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/originfetch 之后：

$ 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

故障排除

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

  • 仔细检查您的遥控器 ( git remote -v)，例如
    • 验证git config branch.master.remote是origin.
    • 检查是否origin通过以下方式指向正确的 URL：（git remote show origin参见这篇文章）。
于 2016-03-31T00:48:48.600 回答
7

截至 2017 年初，此评论中的答案有效：

git fetch <origin-name> <branch-name>为你带来树枝。虽然这不会一次拉出所有分支，但您可以单独执行每个分支。

于 2017-04-21T20:14:17.437 回答
7

我正在从 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。

于 2021-09-04T12:23:30.463 回答
4

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

创建一个与您希望克隆的 repo 同名的文件夹，然后 cd 进入，例如：

mkdir somerepo
cd somerepo

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

git clone --bare git@github.com:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch

瞧！你那里有所有的分支机构！

于 2018-12-08T15:34:05.143 回答
2

我认为这可以解决问题：

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

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

于 2012-09-12T14:01:44.170 回答
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
于 2013-07-14T01:30:10.477 回答
2

该解决方案对我有用，可以将存储库“复制”到另一个存储库：

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

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

于 2020-07-28T13:05:32.250 回答
1

在这里，我给你写了一个很好的函数来让它容易重复

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
}
于 2020-07-23T19:36:03.410 回答
1

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

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
于 2020-09-19T16:17:45.580 回答
1

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

mkdir -p -- myapp-mirror
cd myapp-mirror
git clone --mirror https://git.myco.com/group/myapp.git .git
git config --bool core.bare false
git config --bool core.logAllRefUpdates true
git reset --hard # restore working directory

这是根据我从其他答案中学到的所有内容编译而成的。

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

于 2021-07-29T20:19:28.153 回答
0

对于使用Visual Studio Code的开发人员来说，一个更好的替代解决方案是使用Git Shadow Extension。

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

于 2020-01-22T15:55:09.033 回答
0

这是改编自先前答案的跨平台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，它总是让你烦恼。

于 2020-07-19T07:35:27.337 回答
0

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

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

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

将目录更改为本地目录

cd localdirname

使您的 git 存储库可修改

git config --bool core.bare false

恢复你的工作目录

git reset --hard

列出所有分支

git branch -al
于 2021-07-13T08:58:46.813 回答
-1

所有分店

从 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 ./

或者

~$ allBranches .

查看结果：

git branch

参考：

存储库 allBranches GitHub： https ://github.com/marceloviana/allBranches

于 2019-10-03T11:21:57.697 回答
-2

如果你使用 Bitbucket，你可以使用import Repository。这将导入所有 Git 历史记录（所有分支和提交）。

于 2018-08-18T14:08:26.490 回答