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

Posted 2023-02-21

【中文标题】如何将 Git 存储库恢复到以前的提交？

【英文标题】：How do I revert a Git repository to a previous commit?

【发布时间】：2011-05-06 01:44:52

【问题描述】：

如何从当前状态恢复到某个提交时的快照？

如果我执行git log，那么我会得到以下输出：

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[e-mail]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[e-mail]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[e-mail]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[e-mail]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

如何恢复到 11 月 3 日的提交，即提交 0d1d7fc？

【问题讨论】：

相关How to undo the last Git commit?.

这里是 a very clear and thorough post，关于在 git 中撤消操作，直接来自 Github。

我喜欢 git，但事实上有 35 个答案应该非常简单，这暴露了 git 的一个巨大问题。还是文档？

【参考方案1】：

这在很大程度上取决于您所说的“还原”。

暂时切换到不同的提交

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

# 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

【讨论】：

@Rod's comment on git revert HEAD~3 作为恢复3 提交的最佳方法是一个重要的约定。

你能写出整数吗？喜欢：git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

@MathiasMadsenStav 是的，您当然可以通过完整的 SHA1 指定提交。我使用缩写散列来使答案更具可读性，如果您正在输入，您也倾向于使用它们。如果您要复制和粘贴，请务必使用完整的哈希值。有关如何命名提交的完整说明，请参阅 Specifying Revisions in man git rev-parse。

您可以使用git revert --no-commit hash1 hash2 ...，然后在一次提交中提交每一个还原git commit -m "Message"

@cascabel git revert -m 对我来说很好用！我更喜欢这个而不是 git revert

【参考方案2】：

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

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

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

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

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

【讨论】：

如果你真的想要单独提交（而不是通过一个大提交来恢复所有内容），那么你可以传递--no-edit而不是--no-commit，这样你就不必编辑每次还原的提交消息。

如果 0766c053..HEAD 之间的提交之一是合并，则会弹出错误（与未指定 -m 相关）。这可能会帮助那些遇到的人：***.com/questions/5970889/…

$ git revert --no-commit 53742ae..HEAD 返回fatal: empty commit set passed

如果您在命令末尾删除了“..HEAD”，则只能删除特定的提交。例如：git revert --no-commit 0766c053 将仅删除对 0766c053 所做的特定更改，保持 0766c053 之后的所有更改不变。

@yarin @timhc22 我正在尝试这个，但我想在之前的合并后恢复状态。任何帮助表示赞赏！首先我尝试：git revert --no-commit 5a7e223d6b2ffa5b26653e54db4644690731a7e2..HEAD 错误：commit 759cd2ae17703faa54e39cbf707c8aa86f1c8797 是一个合并，但没有给出 -m 选项。然后我尝试：git revert --no-commit 5a7e223d6b2ffa5b26653e54db4644690731a7e2..HEAD -m 1 错误：指定了主线，但提交 bec2ac84669d0c5dfb57bc9e3eeabb225da7b685 不是合并。

【参考方案3】：

流氓编码员？

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

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

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

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

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?。

【讨论】：

我这样做了，但后来我无法提交并推送到远程存储库。我希望一个特定的旧提交成为 HEAD...

@Lennon。假设您进行了更改，提交并推动了它。您希望本地和远程都看起来好像这从未发生过。首先git reset --hard HEAD^ 您现在已经清除了上次提交的所有本地更改。然后：git push --force origin HEAD 这会在本地获取当前的 HEAD 提交，并覆盖远程中的 HEAD，删除最后一次提交。注意：这不是删除意外推送到遥控器的机密的安全方法。假设所有机密都已泄露，请参阅“--force”注意事项：evilmartians.com/chronicles/…

重置后你需要做git push -f。要非常小心，因为它会删除您从远程分支重置为之前的提交！

【参考方案4】：

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

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

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

---

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

同样来自 cmets，如果你想要一种不那么“笨拙”的方法，你可以使用

git clean -i

【讨论】：

强制警告：不要这样做如果您与其他拥有旧提交副本的人共享您的分支，因为使用这样的硬重置会强制他们必须将他们的工作与新重置的分支重新同步。 有关详细说明如何通过硬重置安全地还原提交而不丢失工作的解决方案，see this answer。

值得注意的是，这将永久删除源目录中所有未提交的文件：/

【参考方案5】：

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

首先什么是 HEAD？

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

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

---

detached HEAD

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

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

---

关于如何从分离的 HEAD 中恢复的几个选项：

---

git checkout

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@...

这会让你回到你想要的提交。

---

git reset HEAD --hard <commit_id>

将您的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.

注意：(Since Git 2.7) 您也可以使用git rebase --no-autostash。

---

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

【参考方案6】：

您可以通过以下两个命令来做到这一点：

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

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

如果您想保留更改，也可以使用：

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

然后它将保存您的更改。

【讨论】：

最简单的答案，就像一个魅力

【参考方案7】：

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

git reset --soft HEAD~1

--soft 表示应将未提交的文件保留为工作文件，而不是 --hard 会丢弃它们。 HEAD~1 是最后一次提交。如果你想回滚 3 个提交，你可以使用 HEAD~3。如果您想回滚到特定的修订号，您也可以使用其 SHA 哈希来执行此操作。

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

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

【讨论】：

注意：这仅适用于您的本地存储库。如果您已将提交推送到远程，则仅在本地重置不会更改远程上的任何内容。尝试在遥控器上撤消更改更加复杂和危险并且充满警告。

【参考方案8】：

最好的办法是：

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

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

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

【参考方案9】：

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

git add . && git checkout master -f

简短说明：

它不会像git revert 那样创建任何提交。 它不会像 git checkout <commithashcode> 那样分离你的 HEAD。 它将覆盖您的所有本地更改并删除自分支中最后一次提交以来添加的所有文件。 它仅适用于分支名称，因此您可以通过这种方式仅恢复到分支中的最新提交。

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

git add . && git reset --hard HEAD

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

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

【参考方案10】：

好的，在 Git 中返回之前的提交非常简单...

恢复不保留更改：

git reset --hard <commit>

恢复保留更改：

git reset --soft <commit>

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

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

---

--软

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

---

--硬

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

---

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

【参考方案11】：

假设您正在谈论 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

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

注意这是Resetting and Forcing the change to the remote，这样如果你团队中的其他人已经拉了git，你会给他们带来问题。你正在破坏变更历史，这是人们首先使用 git 的一个重要原因。

最好使用还原（请参阅其他答案）而不是重置。 如果你是一个人的团队，那可能没关系。

【参考方案12】：

假设您在名为~/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 revert HEAD~3 删除最后 3 次提交

@Rod - 不，这不对。该命令将还原作为 HEAD 的第三个祖父母的提交（不是最后三个提交）。

警告 我希望我在第一个评论之前看到@kflorence 评论！！！

【参考方案13】：

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> 之后添加的文件。

【参考方案14】：

这里有一个更简单的方法可以返回到之前的提交（让它处于未提交状态，随心所欲地处理它）：

git reset HEAD~1

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

【参考方案15】：

您可以自己完成所有这些初始步骤并推送回 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

【参考方案16】：

注意！ 如果用户错误地提交了错误的提交，此命令可能会导致丢失提交历史。总是对你的 git 有额外的备份 万一你犯了错误，还有什么地方比你更安全一些。 :)

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

我就是这样做的：

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

这会在本地仓库恢复，这里使用git push -f后会更新远程仓库。

git push -f

---

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

你会跑

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

紧随其后

git push -f

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

【参考方案17】：

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

git push -f ...

不仅是git push。

【参考方案18】：

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

git back

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

# Remove the latest three commits
git back 3

【参考方案19】：

选择你需要的提交，然后检查它

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

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

git reset --hard HEAD~1

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

【参考方案20】：

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

git reset --hard HEAD

【参考方案21】：

尝试重置为所需的提交：

git reset <COMMIT_ID>

要检查COMMIT_ID，请使用：

git log

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

现在你可以checkout所有未添加的文件

git checkout .

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

git log

更新

如果您的仓库中有唯一提交，请尝试

git update-ref -d HEAD

【参考方案22】：

Revert 是回滚提交的命令。

git revert <commit1> <commit2> 

示例：

git revert 2h3h23233

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

git revert HEAD~1..HEAD

然后做：

git push

【参考方案23】：

如果情况是紧急情况，并且您只想以快速而肮脏的方式执行提问者所要求的操作，假设您的项目位于名为，例如“我的项目”：

---

又快又脏：视情况而定，又快又脏实际上可能非常好。我的解决方案是 NOT 使用极其聪明和恶魔般强大的从潜伏在 .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 年发布，但截至 2021 年底，仍然是最好的。尽早行动：从现在开始，Git 注定要成为你生活的一部分。如果你这样做了，请记住 Git 的大部分复杂性来自分支然后重新合并：你可以在第一次阅读的任何书中跳过这些部分。根据您的问题，没有理由让人们用科学来蒙蔽您的双眼。

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

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

关于“备份到云端”这个主题，下一步是在 GitHub 或（在我看来更好）GitLab 开设一个帐户（当然是免费的）。然后，您可以定期执行 git push 命令以“正确”更新您的云存储库。但同样，谈论这个可能为时过早：git push 必须配置，可能由于完全令人费解的技术原因而无法工作，涉及了解“起源”等。所以一个快速而肮脏的 Cloud-在您变得知识渊博之前，基于备份的方法可能更可取。

【参考方案24】：

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

git stash
git stash clear

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

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

【讨论】：

注意：未添加到索引中的新文件不会被隐藏。您也必须添加它们或手动删除它们。

为什么要清理存储？除了无法解决之外，这实际上是有害的。阅读问题的第一句话会立即使存储解决方案无效（这可能仅对重置为最后一次提交有用）。

【参考方案25】：

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

git add -A .
git reset --hard HEAD

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

【讨论】：

我认为这是对一个相当不同的问题的答案 - ***.com/q/1125968。我将the question here 解释为与 remote 存储库有关。

【参考方案26】：

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

git reset --hard origin/master

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

【参考方案27】：

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

git reset <SHA>

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

git reset --hard <SHA>

【参考方案28】：

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

清空工作树 *。

 git rm -r --cached . && git clean -f -d

使工作树处于我们想要的状态**。

 git checkout 0d1d7fc3 .

创建还原提交。

 git add --all && git commit -m "revert to 0d1d7fc3"

---

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

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

---

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

_{** 指定路径时（此处为：.），结帐将单独保留 HEAD。}

【参考方案29】：

当您的提交被远程推送时，您需要将其删除。让我假设你的分支是 develop 并且它被推送到 origin。

你首先需要从origin中删除develop：

git push origin :develop (note the colon)

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

git reset --hard EFGHIJK

最后，再次推送develop：

git push origin develop

【参考方案30】：

用于回滚（或还原）：

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