如何克隆具有特定修订版/变更集的 git 存储库？

How to clone git repository with specific revision/changeset?

提问by John

How can I clone git repository with specific revision, something like I usually do in Mercurial:

如何克隆具有特定修订版的 git 存储库，就像我通常在 Mercurial 中所做的那样：

hg clone -r 3 /path/to/repository

采纳答案by CB Bailey

UPDATE 2Since Git 2.5.0the feature described below can be enabled on server side with configuration variable uploadpack.allowReachableSHA1InWant, here the GitHub feature requestand the GitHub commit enabling this feature. Note that some Git servers activate this option by default, e.g. Bitbucket Server enabled it since version 5.5+. See this answer on Stackexchangefor a exmple of how to activate the configuration option.

更新 2从Git 2.5.0 开始，下面描述的功能可以在服务器端使用配置变量启用uploadpack.allowReachableSHA1InWant，这里是GitHub 功能请求和GitHub 提交启用此功能。请注意，某些 Git 服务器默认激活此选项，例如 Bitbucket Server 从5.5+ 版本开始启用它。有关如何激活配置选项的示例，请参阅Stackexchange 上的此答案。

UPDATE 1For Git versions 1.7 < v < 2.5use git clone and git reset, as described in Vaibhav Bajpai's answer

更新 1对于 Git 版本，请1.7 < v < 2.5使用 git clone 和 git reset，如Vaibhav Bajpai 的回答中所述

If you don't want to fetch the full repository then you probably shouldn't be using clone. You can always just use fetch to choose the branch that you want to fetch. I'm not an hg expert so I don't know the details of -rbut in git you can do something like this.

如果您不想获取完整的存储库，那么您可能不应该使用clone. 你总是可以使用 fetch 来选择你想要获取的分支。我不是汞专家，所以我不知道细节，-r但在 git 中你可以做这样的事情。

# make a new blank repository in the current directory
git init

# add a remote
git remote add origin url://to/source/repository

# fetch a commit (or branch or tag) of interest
# Note: the full history up to this commit will be retrieved unless 
#       you limit it with '--depth=...' or '--shallow-since=...'
git fetch origin <sha1-of-commit-of-interest>

# reset this repository's master branch to the commit of interest
git reset --hard FETCH_HEAD

回答by Vaibhav Bajpai

$ git clone $URL
$ cd $PROJECT_NAME
$ git reset --hard $SHA1

To again go back to the most recent commit

再次回到最近的提交

$ git pull

回答by CB Bailey

Cloning a git repository, aptly, clones the entire repository: there isn't a way to select only one revision to clone. However, once you perform git clone, you can checkout a specific revision by doing checkout <rev>.

克隆一个 git 存储库，恰当地，克隆整个存储库：没有办法只选择一个修订版进行克隆。但是，一旦您执行了git clone，您就可以通过执行 来检出特定的修订版checkout <rev>。

回答by Peter Kovac

To clone only one single specific commiton a particular branch or tag use:

要在特定分支或标签上只克隆一个特定的提交，请使用：

git clone --depth=1 --branch NAME https://github.com/your/repo.git

Unfortunately, NAMEcan only be branch name or tag name (not commit SHA).

不幸的是，NAME只能是分支名称或标签名称（不能提交 SHA）。

Omit the --depthflag to download the whole history and then checkout that branch or tag:

省略--depth标志以下载整个历史记录，然后检出该分支或标签：

git clone --branch NAME https://github.com/your/repo.git

This works with recent version of git (I did it with version 2.18.0).

这适用于最新版本的 git （我用 version 做到了2.18.0）。

回答by Walter Mundt

If you mean you want to fetch everything from the beginning up to a particular point, Charles Bailey's answer is perfect. If you want to do the reverse and retrieve a subset of the history going back from the current date, you can use git clone --depth [N]where N is the number of revs of history you want. However:

如果您的意思是要获取从开始到特定点的所有内容，那么 Charles Bailey 的答案是完美的。如果您想反向操作并检索从当前日期返回的历史子集，您可以使用git clone --depth [N]其中 N 是您想要的历史转数。然而：

--depth

Create a shallow clone with a history truncated to the specified number of revisions. A shallow repository has a number of limitations (you cannot clone or fetch from it, nor push from nor into it), but is adequate if you are only interested in the recent history of a large project with a long history, and would want to send in fixes as patches.

- 深度

创建一个将历史记录截断为指定修订数量的浅层克隆。浅层存储库有很多限制（你不能从它克隆或获取，也不能从它推入或推入），但如果你只对一个历史悠久的大型项目的近期历史感兴趣，并且想要将修复作为补丁发送。

回答by phill

Just to sum things up (git v. 1.7.2.1):

总结一下（git v. 1.7.2.1）：

1. do a regular git clonewhere you want the repo (gets everything to date — I know, not what is wanted, we're getting there)
2. git checkout <sha1 rev>of the rev you want
3. git reset --hard
4. git checkout -b master

1. 定期git clone在您想要的回购处进行（获取最新的所有内容 - 我知道，不是想要的，我们正在到达那里）
2. git checkout <sha1 rev>你想要的转速
3. git reset --hard
4. git checkout -b master

回答by JamesG

TL;DR - Just create a tag in the source repository against the commit you want to clone up to and use the tag in the fetch command. You can delete the tag from the original repo later to clean up.

TL;DR - 只需在源存储库中针对要克隆到的提交创建一个标签，并在 fetch 命令中使用该标签。您可以稍后从原始存储库中删除标签以进行清理。

Well, its 2014 and it looks like Charles Bailey's accepted answer from 2010 is well and truly outdated by now and most (all?) of the other answers involve cloning, which many people are hoping to avoid.

好吧，它是 2014 年，看起来 Charles Bailey 从 2010 年开始接受的答案现在已经完全过时了，大多数（全部？）其他答案都涉及克隆，许多人希望避免这种情况。

The following solution achieves what the OP and many others are looking for, which is a way to create a copy of a repository, including history, but only up to a certain commit.

以下解决方案实现了 OP 和许多其他人正在寻找的内容，这是一种创建存储库副本的方法，包括历史记录，但仅限于某个提交。

Here are the commands I used with git version 2.1.2 to clone a local repo (ie. a repository in another directory) up to a certain point:

以下是我在 git 2.1.2 版中用于将本地存储库（即另一个目录中的存储库）克隆到某个点的命令：

# in the source repository, create a tag against the commit you want to check out
git tag -m "Temporary tag" tmptag <sha1>

# create a new directory and change into that directory
cd somewhere_else;mkdir newdir;cd newdir

# ...and create a new repository
git init

# add the source repository as a remote (this can be a URL or a directory)
git remote add origin /path/to/original/repo

# fetch the tag, which will include the entire repo and history up to that point
git fetch origin refs/tags/tmptag

# reset the head of the repository
git reset --hard FETCH_HEAD

# you can now change back to the original repository and remove the temporary tag
cd original_repo
git tag -d tmptag

Hopefully this solution keeps working for a few more years! :-)

希望这个解决方案还能再工作几年！:-)

回答by M.Othman

You Can use simply git checkout <commit hash>

你可以简单地使用 git checkout <commit hash>

in this sequence

在这个序列中

bash git clone [URLTORepository] git checkout [commithash]

bash git clone [URLTORepository] git checkout [commithash]

commit hash looks like this "45ef55ac20ce2389c9180658fdba35f4a663d204"

提交哈希看起来像这样“45ef55ac20ce2389c9180658fdba35f4a663d204”

回答by sibaz

Using 2 of the above answers (How to clone git repository with specific revision/changeset?and How to clone git repository with specific revision/changeset?) Helped me to come up with a definative. If you want to clone up to a point, then that point has to be a tag/branch not simply an SHA or the FETCH_HEAD gets confused. Following the git fetch set, if you use a branch or tag name, you get a response, if you simply use an SHA-1 you get not response.
Here's what I did:- create a full working clone of the full repo, from the actual origin

使用上述答案中的 2 个（如何使用特定修订版/变更集克隆 git 存储库？以及如何使用特定修订版/变更集克隆 git 存储库？）帮助我想出了一个确定性。如果您想克隆到某个点，那么该点必须是一个标签/分支，而不仅仅是一个 SHA，否则 FETCH_HEAD 会被混淆。在 git fetch 集之后，如果您使用分支或标签名称，则会收到响应，如果您仅使用 SHA-1，则不会收到响应。
这就是我所做的：-从实际来源创建完整存储库的完整工作克隆

cd <path to create repo>
git clone git@<our gitlab server>:ui-developers/ui.git 

Then create a local branch, at the point that's interesting

然后创建一个本地分支，这很有趣

git checkout 2050c8829c67f04b0db81e6247bb589c950afb14
git checkout -b origin_point

Then create my new blank repo, with my local copy as its origin

然后创建我的新空白 repo，以我的本地副本作为其来源

cd <path to create repo>
mkdir reduced-repo
cd reduced-repo
git init
git remote add local_copy <path to create repo>/ui
git fetch local_copy origin_point

At that point I got this response. I note it because if you use a SHA-1 in place of the branch above, nothing happens, so the response, means it worked

那时我得到了这个回应。我注意到它是因为如果你使用 SHA-1 代替上面的分支，什么都不会发生，所以响应意味着它有效

/var/www/html/ui-hacking$ git fetch local_copy origin_point
remote: Counting objects: 45493, done.
remote: Compressing objects: 100% (15928/15928), done.
remote: Total 45493 (delta 27508), reused 45387 (delta 27463)
Receiving objects: 100% (45493/45493), 53.64 MiB | 50.59 MiB/s, done.
Resolving deltas: 100% (27508/27508), done.
From /var/www/html/ui
 * branch            origin_point -> FETCH_HEAD
 * [new branch]      origin_point -> origin/origin_point

Now in my case, I then needed to put that back onto gitlab, as a fresh repo so I did

现在在我的情况下，我需要把它放回 gitlab，作为一个新的 repo，所以我做了

git remote add origin git@<our gitlab server>:ui-developers/new-ui.git

Which meant I could rebuild my repo from the origin_point by using git --git-dir=../ui/.git format-patch -k -1 --stdout <sha1> | git am -3 -kto cherry pick remotely then use git push originto upload the whole lot back to its new home.

这意味着我可以通过git --git-dir=../ui/.git format-patch -k -1 --stdout <sha1> | git am -3 -k远程使用cherry pick从origin_point重建我的repo，然后使用git push origin将整个地块上传回新家。

Hope that helps someone

希望能帮助某人

回答by vladkras

My version was a combination of accepted and most upvoted answers. But it's a little bit different, because everyone uses SHA1 but nobody tells you how to get it

我的版本是接受和最受好评的答案的组合。但它有点不同，因为每个人都使用 SHA1 但没有人告诉你如何获得它

$ git init
$ git remote add <remote_url>
$ git fetch --all

now you can see all branches & commits

现在你可以看到所有的分支和提交

$ git branch -a
$ git log remotes/origin/master <-- or any other branch

Finally you know SHA1 of desired commit

最后你知道所需提交的 SHA1

git reset --hard <sha1>