如何将 Git 存储库恢复到以前的提交？

这在很大程度上取决于您所说的“还原”是什么意思。

暂时切换到不同的提交

如果你想暂时回到它，鬼混，然后回到你所在的地方，你所要做的就是检查所需的提交：

# This will detach your HEAD, that is, leave you with no branch checked out:
git checkout 0d1d7fc32

或者，如果您想在那里进行提交，请继续并在您使用时创建一个新分支：

git checkout -b old-state 0d1d7fc32

要回到你所在的位置，只需再次检查你所在的分支。 （如果您进行了更改，就像在切换分支时一样，您必须酌情处理它们。您可以重置以丢弃它们；您可以存储、结帐、存储弹出以将它们随身携带；您可以提交如果你想在那里有一个分支，他们可以去那里的一个分支。）

硬删除未发布的提交

另一方面，如果你想真正摆脱从那时起所做的一切，有两种可能性。一，如果您还没有发布任何这些提交，只需重置：

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

如果你搞砸了，你已经丢弃了你的本地更改，但你至少可以通过再次重置来恢复到以前的位置。

使用新提交撤消已发布的提交

另一方面，如果您已经发布了作品，您可能不想重置分支，因为这实际上是在重写历史。在这种情况下，您确实可以还原提交。对于 Git，revert 有一个非常具体的含义：创建一个带有反向补丁的提交以取消它。这样你就不会重写任何历史。

# This will create three separate revert commits:
git revert a867b4af 25eee4ca 0766c053

# It also takes ranges. This will revert the last two commits:
git revert HEAD~2..HEAD

#Similarly, you can revert a range of commits using commit hashes (non inclusive of first hash):
git revert 0d1d7fc..a867b4a

# Reverting a merge commit
git revert -m 1 <merge_commit_sha>

# To get just one, you could use `rebase -i` to squash them afterwards
# Or, you could do it manually (be sure to do this at top level of the repo)
# get your index and work tree into the desired state, without changing HEAD:
git checkout 0d1d7fc32 .

# Then commit. Be sure and write a good message describing what you just did
git commit

git-revert manpage 实际上在其描述中涵盖了很多内容。另一个有用的链接是 this git-scm.com section discussing git-revert。

如果您决定根本不想恢复，您可以恢复恢复（如此处所述）或重置回恢复之前（参见上一节）。

在这种情况下，您可能还会发现此答案很有帮助：
How can I move HEAD back to a previous location? (Detached head) & Undo commits

---

这里有很多复杂而危险的答案，但实际上很容易：

git revert --no-commit 0766c053..HEAD
git commit

这会将 HEAD 中的所有内容恢复为提交哈希，这意味着它将在工作树中重新创建该提交状态就好像在 0766c053 之后的每个提交都被退回一样。然后，您可以提交当前树，它将创建一个全新的提交，基本上等同于您“恢复”到的提交。

（--no-commit 标志让 git 一次恢复所有提交 - 否则将提示您为范围内的每个提交提供一条消息，从而在您的历史记录中添加不必要的新提交。）

这是回滚到先前状态的安全且简单的方法。没有历史被破坏，因此它可以用于已经公开的提交。

---

流氓编码器？

自己工作，只想让它工作？请遵循以下这些说明，它们多年来一直为我和许多其他人可靠地工作。

与他人合作？ Git 很复杂。在您轻率行事之前，请阅读此答案下方的评论。

将工作副本恢复到最近的提交

要恢复到以前的提交，忽略任何更改：

git reset --hard HEAD

HEAD 是当前分支中的最后一次提交

将工作副本还原为较旧的提交

要恢复到比最近提交更早的提交：

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft HEAD@{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

归功于类似的 Stack Overflow 问题，Revert to a commit by a SHA hash in Git?。

---

对我和其他人来说最好的选择是 Git 重置选项：

git reset --hard <commidId> && git clean -f

这对我来说是最好的选择！它简单、快速、有效！

** 注意：** 如评论中所述，如果您与拥有旧提交副本的其他人共享您的分支，请不要这样做

同样从评论中，如果您想要一种不那么“笨拙”的方法，您可以使用

git clean -i

---

在回答之前，让我们添加一些背景知识，解释一下这个 HEAD 是什么。

首先什么是HEAD？

HEAD 只是对当前分支上的当前提交（最新）的引用。在任何给定时间只能有一个 HEAD（不包括 git worktree）。

HEAD 的内容存储在 .git/HEAD 中，它包含当前提交的 40 字节 SHA-1 哈希。

分离头

如果您不是最新的提交 - 这意味着 HEAD 指向历史上的先前提交，它被称为 detached HEAD。

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

在命令行上它看起来像这样 - SHA-1 哈希而不是分支名称，因为 HEAD 没有指向当前分支的尖端：

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

关于如何从分离的 HEAD 中恢复的一些选项：

git结帐

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

这将签出指向所需提交的新分支。此命令将检出给定的提交。

此时您可以创建一个分支并从这一点开始工作：

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

git reflog

您也可以随时使用 reflog。 git reflog 将显示更新 HEAD 的任何更改，并且检查所需的 reflog 条目会将 HEAD 设置回此提交。

每次修改 HEAD 时，reflog 中都会有一个新条目

git reflog
git checkout HEAD@{...}

这将使您回到所需的提交。

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

git reset HEAD --hard

将您的 HEAD “移动”回所需的提交。

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

注意：（从 Git 2.7 开始）您也可以使用 git rebase --no-autostash。

这个模式说明了哪个命令做什么。如您所见，reset && checkout 修改 HEAD。

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

---

您可以通过以下两个命令执行此操作：

git reset --hard [previous Commit SHA id here]
git push origin [branch Name] -f

它将删除您之前的 Git 提交。

如果要保留更改，还可以使用：

git reset --soft [previous Commit SHA id here]

然后它将保存您的更改。

---

如果您想“取消提交”，删除最后的提交消息，并将修改后的文件放回暂存中，您可以使用以下命令：

git reset --soft HEAD~1

--soft 表示应将未提交的文件保留为工作文件，而不是 --hard 将丢弃它们。

HEAD~1 是最后一次提交。如果你想回滚 3 个提交，你可以使用 HEAD~3。如果您想回滚到特定的修订号，您也可以使用其 SHA 哈希来执行此操作。

在您提交了错误的事情并且想要撤消最后一次提交的情况下，这是一个非常有用的命令。

来源：http://nakkaya.com/2009/09/24/git-delete-last-commit/

---

最好的方法是：

git reset --hard <commidId> && git push --force

这会将分支重置为特定的提交，然后将使用与本地相同的提交上传远程服务器。

请注意 --force 标志，因为它会在选定提交之后删除所有后续提交，而没有恢复它们的选项。

---

我尝试了很多方法来恢复 Git 中的本地更改，如果您只想恢复到最新的提交状态，这似乎是最好的。

git add . && git checkout master -f

简短的介绍：

它不会像 git revert 那样创建任何提交。

它不会像 git checkout 那样分离你的 HEAD。

它将覆盖您的所有本地更改并删除自分支中上次提交以来所有添加的文件。

它仅适用于分支名称，因此您可以通过这种方式仅恢复到分支中的最新提交。

我找到了一种更方便和简单的方法来实现上述结果：

git add . && git reset --hard HEAD

HEAD 指向您当前分支的最新提交。

它与 boulder_ruby 建议的代码代码相同，但我在 git reset --hard HEAD 之前添加了 git add . 以擦除自上次提交以来创建的所有新文件，因为这是大多数人在恢复到最新提交时所期望的。

---

好的，回到 Git 中的先前提交非常容易......

在不保留更改的情况下恢复：

git reset --hard <commit>

恢复并保留更改：

git reset --soft <commit>

说明：使用 git reset，您可以重置为特定状态。如上所示，通常将它与提交哈希一起使用。

但是正如您所看到的，区别在于使用两个标志 --soft 和 --hard，默认情况下 git reset 使用 --soft 标志，但始终使用标志是一个好习惯，我解释每个标志：

- 柔软的

解释的默认标志，不需要提供它，不会更改工作树，但它会添加所有已更改的文件准备提交，因此您返回到提交状态，对文件的更改未暂存。

- 难的

小心这个标志。它重置工作树和跟踪文件的所有更改，所有更改都将消失！

我还创建了下面的图像，它可能会在使用 Git 的现实生活中发生：

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

---

假设您正在谈论 master 和相应的分支（也就是说，这可能是您关心的任何工作分支）：

# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Reset remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

我在一篇博文中找到了答案（现在不再存在）

请注意，这是重置并强制更改远程，因此如果您团队中的其他人已经 git pull，您将给他们带来问题。你正在破坏变更历史，这是人们首先使用 git 的一个重要原因。

最好使用revert（见其他答案）而不是reset。如果你是一个人的团队，那么这可能并不重要。

---

Jefromi 解决方案的额外替代方案

Jefromi's solutions 绝对是最好的，您绝对应该使用它们。但是，为了完整起见，我还想展示这些其他替代解决方案，它们也可用于恢复提交（在某种意义上，您创建一个撤消先前提交中更改的新提交，就像 git revert 所做的一样）。

需要明确的是，这些替代方法并不是恢复提交的最佳方法，Jefromi's solutions are，但我只想指出，您也可以使用这些其他方法来实现与 git revert 相同。

备选方案 1：硬复位和软复位

这是 Charles Bailey 对 Revert to a commit by a SHA hash in Git? 的解决方案的略微修改版本：

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft HEAD@{1}

# Commit the changes
git commit -m "Revert to <commit>"

这基本上是通过使用软重置将保留先前提交的状态暂存在索引/暂存区域中的事实来实现的，然后您可以提交。

备选方案 2：删除当前树并替换为新树

此解决方案来自 svick 对 Checkout old commit and make it a new commit 的解决方案：

git rm -r .
git checkout <commit> .
git commit

与备选方案 #1 类似，这会在当前工作副本中重现 <commit> 的状态。必须先执行 git rm，因为 git checkout 不会删除自 <commit> 以来添加的文件。

---

假设您在名为 ~/commits-to-revert.txt 的文本文件中有以下提交（我使用 git log --pretty=oneline 来获取它们）

fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

创建一个 Bash shell 脚本来恢复它们中的每一个：

#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
    git revert $i --no-commit
done

这会将所有内容恢复到以前的状态，包括文件和目录的创建和删除，将其提交到您的分支并保留历史记录，但您将其恢复到相同的文件结构。为什么 Git 没有 git revert --to <hash> 超出了我的理解。

---

这是一种更简单的方法可以返回到先前的提交（并使其处于未提交状态，随心所欲地处理它）：

git reset HEAD~1

所以，不需要提交 ID 等等:)

---

警告！如果用户错误地提交了错误的提交，此命令可能会导致丢失提交历史。总是在其他地方对你的 git 进行额外的备份，以防万一你犯了错误，这比你更安全一些。 :)

我遇到了类似的问题，想恢复到之前的提交。就我而言，我对保留较新的提交不感兴趣，因此我使用了 Hard。

我是这样做的：

git reset --hard CommitId && git clean -f

这将在本地存储库中恢复，在此处使用 git push -f 后将更新远程存储库。

git push -f

例如，如果您想完全忽略下一张图片中名称为 enforce non-group manage policies 的提交

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

你会跑

git reset --hard dd52eb9 && git clean -f

其次是

git push -f

之后，您将看不到该提交 (enforce non-group manage policies)

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

---

您可以自己完成所有这些初始步骤并推送回 Git 存储库。

使用 git pull --all 命令从 Bitbucket 拉取最新版本的存储库。从终端运行带有 -n 4 的 Git log 命令。 -n 后面的数字决定了从本地历史中最近一次提交开始的日志中的提交次数。 $ git log -n 4 使用 git reset --hard HEAD~N 重置存储库历史记录的头部，其中 N 是您想要收回头部的提交次数。在以下示例中，head 将被设置回一个提交，到存储库历史中的最后一次提交： 使用 git push --force 将更改推送到 Git 存储库以强制推送更改。

如果您希望 Git 存储库到以前的提交：-

git pull --all
git reset --hard HEAD~1
git push --force

---

在所有更改之后，当您推送所有这些命令时，您可能必须使用：

git push -f ...

不仅git push。

---

有一个命令（不是核心 Git 的一部分，但它位于 git-extras 包中）专门用于恢复和暂存旧提交：

git undo

根据 man page，它也可以这样使用：

# Remove the latest three commits
git undo 3

---

Revert 是回滚提交的命令。

git revert <commit1> <commit2> 

样本：

git revert 2h3h23233

它能够从 HEAD 获取范围，如下所示。这里 1 表示“恢复上次提交”。

git revert HEAD~1..HEAD

然后做：

git push

---

如果情况很紧急，而您只想以一种快速而肮脏的方式做提问者所问的事情，假设您的项目位于名为“我的项目”的目录下：

QUICK AND DIRTY：根据具体情况，快速和肮脏实际上可能非常好。我的解决方案在这里所做的不是使用极其聪明且功能强大的 git 命令，用从潜伏在 .git/ 目录下的 git 存储库深处拖拉/提取的文件不可逆转地替换您在工作目录中的文件，其中有许多。您不必进行这种深海潜水来恢复可能看起来是灾难性的情况，并且在没有足够专业知识的情况下尝试这样做可能会致命。

复制整个目录并将其命名为其他名称，例如“我的项目 - 复制”。假设您的 git 存储库（“repo”）文件位于“my project”目录下（它们的默认位置，在名为“.git”的目录下），您现在将复制您的工作文件和 repo 文件。在“我的项目”目录中执行此操作： .../my project $ git reset --hard [first-4-letters&numbers-of-commit's-SHA]

这会将“我的项目”下的存储库状态返回到您提交时的状态（“提交”表示您的工作文件的快照）。自“resetted”提交以来的所有提交将在“我的项目”下永远丢失，但是...它们仍将存在在“我的项目 - 副本”下的存储库中，因为您复制了所有这些文件 - 包括 repo 中的文件，在 .../.git/ 下。

然后，您的系统上有两个版本...您可以检查或复制或修改上一次提交中感兴趣的文件或其他文件。如果您决定新工作，因为恢复的提交无处可去，您可以完全丢弃“我的项目 - 副本”下的文件......

如果你想继续项目的状态而不实际丢弃工作，因为这个检索到的提交，那么显而易见的事情是再次重命名你的目录：删除包含检索到的提交的项目（或给它一个临时名称）并重命名你的“我的项目 - 复制”目录回到“我的项目”。然后也许尝试理解这里的其他一些答案，并可能很快再做一次提交。

Git 是一个绝妙的创造，但绝对没有人能够“即时掌握”：试图解释它的人也经常假设其他 VCS [版本控制系统] 的先验知识并深入研究太远太早了，并犯下其他可怕的罪行，例如使用可互换的术语来表示“结帐”-有时看起来几乎是故意使初学者感到困惑的方式。

为了减轻自己的压力，请从我的伤疤中学习。您几乎必须阅读一本关于 Git 的书 - 我建议阅读这本书，Pro Git 第 2 版：可免费下载等。from git central。 2014 年出版，但截至 2022 年初，仍然是最好的。尽早行动：从现在开始，Git 注定要成为你生活的一部分。如果你这样做了，请记住 Git 的大部分复杂性来自分支然后重新合并：Pro Git 这本书实际上非常温和地介绍了这个核心方面，但你可以跳过任何一本关于你的第一次阅读。从您的问题来看，没有理由让人们用科学来蒙蔽您的双眼。

尤其是如果，例如，这是一个绝望的情况，而你是 Git 的新手！

PS：（轻微警告）另一种想法：（现在）将 Git 存储库保存在与工作文件不同的目录中实际上非常简单。这意味着您不会使用上述快速 & 复制整个 Git 存储库。肮脏的解决方案。查看 Fryer 使用 --separate-git-dir here 给出的答案。请牢记这一点，警告：如果您有一个未复制的“单独目录”存储库，并且您进行了硬重置，那么重置提交之后的所有版本都将丢失永远永远，除非您已经（您绝对应该）定期备份您的存储库，最好备份到云端（例如 Google Drive）等其他地方。

关于“备份到云端”这个主题，下一步是在 GitHub 或（在我看来更好）GitLab 开设一个帐户（当然是免费的）。然后，您可以定期执行 git push 命令以“正确”更新您的云存储库。但同样，谈论这个可能为时过早：必须配置 git push，由于完全令人费解的技术原因可能无法工作，涉及了解远程存储库（“来源”等）。因此，在您变得知识渊博之前，一种快速而简单的基于云的备份方法可能更可取。同样，Pro Git 书介绍了远程存储库的工作方式，以及与本地存储库的关系，非常温和而合理。

---

尝试重置为所需的提交：

git reset <COMMIT_ID>

要检查 COMMIT_ID，请使用：

git log

这会将所有更改的文件重置为未添加状态。

现在您可以通过 checkout 所有未添加的文件

git checkout .

要验证您的更改，请使用：

git log

更新

如果您的仓库中有一个并且只有一个提交，请尝试

git update-ref -d HEAD

---

选择您需要的提交，并通过

git show HEAD
git show HEAD~1
git show HEAD~2 

直到您获得所需的提交。要使 HEAD 指向这一点，请执行

git reset --hard HEAD~1

或 git reset --hard HEAD~2 或其他。

---

恢复到最近的提交并忽略所有本地更改：

git reset --hard HEAD

---

这是直接重置为最近提交的另一种方法

git stash
git stash clear

它直接清除您自上次提交以来所做的所有更改。

PS：有点小问题；它还会删除您最近存储的所有存储更改。我想在大多数情况下这无关紧要。

---

想法：您基本上想用先前提交的状态替换当前的工作树状态，然后从中创建一个提交。忽略的文件最好不要更改。方法如下：

清空工作树 *. git rm -r --cached 。 && git clean -f -d 使工作树处于我们想要的状态**。 git 结帐 0d1d7fc3 。创建还原提交。 git add --all && git commit -m "恢复到 0d1d7fc3"

起初我认为 Yarins answer 会是最好的，但它不适用于合并提交。这个解决方案可以。

此外，它不会从历史记录中删除任何内容（推送或推送）。它产生一个干净的提交，代表我们想要恢复的状态。

_{* 通过从工作树中删除未跟踪但未被忽略的文件（在 .gitignore 中指定的文件）。工作树是空的，除了我们想要保留的被忽略的文件（如果没有为 clean 指定 -x 选项）}

_{** 当一个路径被指定时（这里：.），checkout 只留下 HEAD。}

---

为了从一些意外更改中彻底清除编码器的目录，我们使用了：

git add -A .
git reset --hard HEAD

仅 git reset --hard HEAD 将摆脱修改，但不会摆脱“新”文件。在他们的情况下，他们不小心将一个重要文件夹随机拖到某个地方，并且所有这些文件都被 Git 视为新文件，因此 reset --hard 没有修复它。通过预先运行 git add -A .，它使用 git 明确地跟踪它们，并被重置清除。

---

我相信有些人可能会遇到这个问题，想知道如何回滚他们在 master 中所做的已提交更改 - 即扔掉所有东西并返回到 origin/master，在这种情况下，请执行以下操作：

git reset --hard origin/master

https://superuser.com/questions/273172/how-to-reset-master-to-origin-master

---

要将上一次提交的更改保留到 HEAD 并移至上一次提交，请执行以下操作：

git reset <SHA>

如果从上一次提交到 HEAD 不需要更改并丢弃所有更改，请执行以下操作：

git reset --hard <SHA>

---

当您的提交被远程推送时，您需要删除它们。让我假设您的分支正在开发并且它被推到原点。

您首先需要从原点删除开发：

git push origin :develop (note the colon)

然后你需要开发到你想要的状态，让我假设提交哈希是 EFGHIJK：

git reset --hard EFGHIJK

最后，再次推动开发：

git push origin develop

---

对于回滚（或还原）：

1. git revert --no-commit "commit-code-to-remove" HEAD
(e.g. git revert --no-commit d57a39d HEAD)
2. git commit
3. git push

尝试以上两个步骤，如果您发现这是您想要的，那么 git push。

如果您发现有问题，请执行以下操作：

git revert --abort

---