如何将文件重置或恢复到特定版本？

Question

如何在特定提交 hash （我通过git log和git diff确定）将修改后的文件恢复为其先前的版本？

Answer 1

假设您想要的提交的哈希是c5f567 ：

git checkout c5f567 -- file1/to/restore file2/to/restore

git checkout手册页提供了更多信息。

如果您想恢复到c5f567之前的提交，请附加~1 （其中 1 是您想要返回的提交数，可以是任何值）：

git checkout c5f567~1 -- file1/to/restore file2/to/restore

作为旁注，我一直对这个命令感到不舒服，因为它既用于普通事物（在分支之间更改），也用于不寻常的破坏性事物（丢弃工作目录中的更改）。

---

还有一个新的git restore命令专门用于恢复已修改的工作副本文件。 如果您的 git 足够新，您可以使用此命令，但文档附带警告：

此命令是实验性的。 行为可能会改变。

Answer 2

您可以使用 diff 命令快速查看对文件所做的更改：

git diff <commit hash> <filename>

然后要将特定文件还原为该提交，请使用 reset 命令：

git reset <commit hash> <filename>

如果您有本地修改，您可能需要使用--hard选项。

管理航点的一个很好的工作流程是使用标签在您的时间线中清晰地标记点。 我不太明白你的最后一句话，但你可能想要的是从前一个时间点分出一个分支。 为此，请使用方便的 checkout 命令：

git checkout <commit hash>
git checkout -b <new branch name>

然后，当您准备好合并这些更改时，您可以根据您的主线重新设置：

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Answer 3

您可以使用对 git 提交的任何引用，如果最方便的话，包括 SHA-1。 关键是命令看起来像这样：

git checkout [commit-ref] -- [filename]

Answer 4

git checkout -- foo

这会将foo重置为 HEAD。 你也可以：

git checkout HEAD^ foo

一次修订，等等。

Answer 5

并且要恢复到最常需要的最后提交的版本，您可以使用这个更简单的命令。

git checkout HEAD file/to/restore

Answer 6

我刚才遇到了同样的问题，我发现这个答案最容易理解（ commit-ref是您要返回的日志中更改的 SHA 值）：

git checkout [commit-ref] [filename]

这会将旧版本放在您的工作目录中，如果需要，您可以从那里提交它。

Answer 7

从 git v2.23.0 开始，有一个新的git restore方法应该承担git checkout的部分责任（即使接受的答案也提到git checkout非常令人困惑）。 请参阅github 博客上的更改亮点。

此命令的默认行为是使用来自source参数的内容（在您的情况下将是提交哈希）恢复工作树的状态。

因此，根据 Greg Hewgill 的回答（假设提交哈希是c5f567 ），命令如下所示：

git restore --source=c5f567 file1/to/restore file2/to/restore

或者如果你想恢复到 c5f567 之前的一次提交的内容：

git restore --source=c5f567~1 file1/to/restore file2/to/restore

Answer 8

如果您知道需要返回多少次提交，您可以使用：

git checkout master~5 image.png

这假设您在master分支上，并且您想要的版本是 5 次提交。

Answer 9

我想我找到了……来自http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

有时你只想回到过去，忘记过去的每一个变化，因为它们都是错误的。

从...开始：

$ git log

它向您显示了最近提交的列表，以及它们的 SHA1 哈希值。

接下来，键入：

$ git reset --hard SHA1_HASH

将状态恢复到给定的提交并从记录中永久删除所有较新的提交。

Answer 10

这对我有用：

git checkout <commit hash> file

然后提交更改：

git commit -a

Answer 11

当你说“回滚”时，你必须小心。 如果您曾经在提交 $A 中有一个文件版本，然后在两个单独的提交 $B 和 $C 中进行了两次更改（所以您看到的是文件的第三次迭代），如果您说“我想回滚到第一个”，你真的是这个意思吗？

如果你想摆脱第二次和第三次迭代的变化，这很简单：

$ git checkout $A file

然后你提交结果。 该命令询问“我想从提交 $A 记录的状态中签出文件”。

另一方面，您的意思是摆脱第二次迭代（即提交 $B）带来的更改，同时保留提交 $C 对文件所做的更改，您希望恢复 $B

$ git revert $B

请注意，创建提交 $B 的人可能不是很自律，并且可能在同一次提交中提交了完全不相关的更改，并且此还原可能会触及文件以外的文件，而不是您看到有问题的更改，因此您可能需要在执行后仔细检查结果所以。

Answer 12

有趣的是，如果工作副本位于名为foo的目录中，则git checkout foo将不起作用； 但是， git checkout HEAD foo和git checkout ./foo都会：

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Answer 13

1. Git 将文件还原为特定的提交

git checkout Last_Stable_commit_Number -- fileName

2.Git 将文件还原到特定分支

git checkout branchName_Which_Has_stable_Commit fileName

Answer 14

以下是rebase的工作原理：

 git checkout <my branch> git rebase master git checkout master git merge <my branch>

---

假设你有

---o----o----o----o master \---A----B <my branch>

前两个命令 ... commit git checkout git rebase master

...查看要应用于master分支的更改分支。 rebase命令从<my branch>获取提交（在master中找不到）并将它们重新应用到master的头部。 换句话说， <my branch>中第一个提交的父级不再是master历史中的先前提交，而是master的当前负责人。 这两个命令是一样的：

git rebase master <my branch>

记住这个命令可能更容易，因为“base”和“modify”分支都是明确的。

. 最终的历史结果是：

 ---o----o----o----o master \----A'----B' <my branch>

---

最后两个命令...

git checkout master
git merge <my branch>

...进行快进合并以将所有<my branch>更改应用于master 。 如果没有这一步，rebase 提交不会被添加到master 。 最终结果是：

 ---o----o----o----o----A'----B' master, <my branch>

master和<my branch>都引用B' 。 此外，从这一点开始，删除<my branch>引用是安全的。

git branch -d <my branch>

Answer 15

目标文件的第一个重置头

git reset HEAD path_to_file

第二次签出该文件

git checkout -- path_to_file

Answer 16

如果您想将文件恢复到以前的提交（以及要恢复的文件已经提交），您可以使用

git checkout HEAD^1 path/to/file

或者

git checkout HEAD~1 path/to/file

然后只需暂存并提交“新”版本。

有了在合并的情况下提交可以有两个父级的知识，您应该知道 HEAD^1 是第一个父级，而 HEAD~1 是第二个父级。

如果树中只有一个父级，则任何一个都可以。

Answer 17

git-aliases、awk 和 shell 函数来救援！

git prevision <N> <filename>

其中<N>是要为文件<filename>回滚的文件的修订数。
例如，要检查单个文件x/y/zc的前一个版本，运行

git prevision -1 x/y/z.c

---

git prevision 是如何工作的？

将以下内容添加到您的gitconfig

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

该命令基本上

• 对指定文件执行git log并
• 在文件的历史记录中选择适当的提交 ID 并
• 对指定文件的 commit-id 执行git checkout 。

本质上，在这种情况下，人们会手动做的所有事情，
包含在一个漂亮、高效的 git-alias 中 - git-prevision

Answer 18

这里有很多建议，大部分是git checkout $revision -- $file 。 几个不起眼的选择：

git show $revision:$file > $file

而且，我经常使用它来临时查看特定版本：

git show $revision:$file

或者

git show $revision:$file | vim -R -

（OBS： $file需要以./为前缀，如果它是git show $revision:$file工作的相对路径）

更奇怪的是：

git archive $revision $file | tar -x0 > $file

Answer 19

我必须在这里插入EasyGit ，它是一个包装器，可以让 git 对新手更容易上手，而不会让经验丰富的用户感到困惑。 它所做的一件事就是 赋予git revert更多的含义。 在这种情况下，您只需说：

eg revert foo/bar foo/baz

Answer 20

但是请注意， git checkout ./foo和git checkout HEAD ./foo并不完全相同。 一个例子：

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

（第二个add阶段文件在索引中，但它没有被提交。）

Git checkout ./foo表示从索引中恢复路径./foo ； 添加HEAD指示 Git 在执行此操作之前将索引中的该路径恢复为其HEAD修订版。

Answer 21

对我来说，没有一个答复似乎很清楚，因此我想添加我的，这似乎超级简单。

我有一个提交abc1 ，之后我对文件file.txt进行了几次（或一次修改）。

现在说我在文件file.txt中搞砸了一些东西，我想回到之前的提交abc1 。

1. git checkout file.txt ：这将删除本地更改，如果您不需要它们

2. git checkout abc1 file.txt ：这会将您的文件带到您想要的版本

3. git commit -m "Restored file.txt to version abc1" ：这将提交您的还原。

4. git push ：这将推送远程存储库中的所有内容

在第 2 步和第 3 步之间，您当然可以执行git status来了解发生了什么。 通常你应该看到file.txt已经添加了，这就是为什么不需要git add的原因。

Answer 22

这里的许多答案声称使用git reset ... <file>或git checkout ... <file>但这样做，您将丢失在要恢复的提交之后提交的对<file>的所有修改。

如果您只想从单个文件的一次提交中恢复更改，就像git revert的那样，但仅适用于一个文件（或说提交文件的子集），我建议同时使用git diff和git apply那样（ <sha> = 你想要恢复的提交的哈希值）：

git diff <sha>^ <sha> path/to/file.ext | git apply -R

基本上，它将首先生成与您要还原的更改相对应的补丁，然后反向应用补丁以删除这些更改。

当然，如果还原的行已被<sha1>和HEAD之间的任何提交修改（冲突），则它将不起作用。

Answer 23

为了转到文件的先前提交版本，获取提交号，然后说 eb917a1

git checkout eb917a1 YourFileName

如果您只需要返回到上次提交的版本

git reset HEAD YourFileName
git checkout YourFileName

这只会带您进入文件的最后提交状态

Answer 24

这是一个非常简单的步骤。 将文件签出到我们想要的提交 id，这里之前是一个提交 id，然后只需 git commit amend 就完成了。

# git checkout <previous commit_id> <file_name>
# git commit --amend

这非常方便。 如果我们想将任何文件带到提交顶部的任何先前提交 id，我们可以轻松做到。

Answer 25

git checkout ref|commitHash -- 文件路径

例如

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

Answer 26

您可以通过 4 个步骤完成：

1. 使用您要专门还原的文件还原整个提交 - 它将在您的分支上创建一个新提交
2. 提交的软重置 - 删除提交并将更改移动到工作区
3. 手动选择要还原并提交的文件
4. 删除工作区中的所有其他文件

您需要在终端中输入的内容：

1. git revert <commit_hash>
2. git reset HEAD~1
3. git add <file_i_want_to_revert> && git commit -m 'reverting file'
4. git checkout .

祝你好运

Answer 27

使用git log获取特定版本的哈希键，然后使用git checkout <hashkey>

注意：不要忘记在最后一个之前键入哈希。 最后一个哈希指向您当前的位置（HEAD）并且没有任何改变。

Answer 28

显然有人需要写一本关于 git 的通俗易懂的书，或者需要在文档中更好地解释 git。 面对同样的问题，我猜想

cd <working copy>
git revert master

将撤消似乎要做的最后一次提交。

伊恩

Answer 29

git revert <hash>

将还原给定的提交。 听起来您认为git revert只影响最近的提交。

这并不能解决您的问题，如果您想恢复特定文件中的更改并且该提交更改的内容多于该文件。

Answer 30

如果您在最后一次提交中提交了错误的文件，请按照说明进行操作：

1. 开源树，改到这个提交

2. 更改行并找到错误文件作为提交发送的提交

3. 您可以在该提交中看到您的更改列表
4. 选择它然后单击...按钮右侧...单击反向文件
5. 然后您可以在左下角的文件状态选项卡上看到它，然后单击取消暂存：

6. 打开您的 Visual Studio 代码并通过提交已删除的文件来恢复
7. 毕竟，您可以在源代码树中看到最后一次提交的结果

Answer 31

git log --oneline  // you see commits, find commit hash to which you want reset
git diff y0urhash src/main/.../../YourFile.java   // to see difference
git reset y0urhash src/main/.../../YourFile.java   // revert to y0urhash commit
git status                                        // check files to commit
git commit -m "your commit message"
git push origin

Answer 32

这是我的方式。

a) 在 Android Studio 中，打开文件。

b) git -> Show History，找到我想要恢复的上一个提交。 获取 commit_id（即提交哈希）。

c) git checkout commit_id file_path

Answer 33

如果您正在使用 Git 扩展并且只想恢复到文件的父提交，则可以选择包含要恢复的更改的提交，然后在详细信息窗格中选择“差异”选项卡，右键单击您要还原的文件，然后是“将文件重置为” ....，然后是“A”（父级）

Answer 34

对于文件“a.txt”、“b.txt”、“c.txt”：

1. git revert -n <commit> （例如git revert -n HEAD恢复最后一次提交）。 这将准备（但不提交！）并暂存所有更改以撤消特定提交

2. git reset 。 这将取消暂存所有反向更改，以便您可以手动添加要更改回来的文件。

3. git add a.txt b.txt c.txt 。 这会将您要撤消更改的文件添加到新提交中。

4. git commit -m 'Undo <commit> for a.txt, b.txt, c.txt' 。 提交实际更改

5. git reset --hard 。 摆脱你不想撤消的任何事情。

Answer 35

• 运行以下执行软重置的命令，更改将出现在您的本地。

git reset --soft HEAD^1

• 查看您之前提交到本地的文件的状态，然后进行更改。

 git status

• 进行更改后提交并推送文件。

• 不会显示错误提交文件的先前提交历史记录

在从原点拉出之前总是有修剪（可选步骤）

 git remote prune origin