如何将Git存储库还原为以前的提交

Question

如何从当前状态恢复为在某次提交时创建的快照？

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

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <me@me.com>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <me@me.com>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <me@me.com>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <me@me.com>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

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

Answer 1

这很大程度上取决于“恢复”的含义。

暂时切换到其他提交

如果你想暂时回到它，傻瓜，然后回到你所在的位置，你所要做的就是检查所需的提交：

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

或者，如果你想在那里做提交，那就去吧，当你在它的时候做一个新的分支：

git checkout -b old-state 0d1d7fc32

要回到原来的位置，只需检查一下你所在的分店。 （如果你做了更改，就像转换分支一样，你必须在适当的时候处理它们。你可以重置它们扔掉它们;你可以藏匿，结账，存放pop以带走它们;你可以提交如果你想要那里的分支，他们到那里的一个分支。）

硬删除未发布的提交

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

# 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:
git revert a867b4af..0766c053 

# 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 to move HEAD back to a previous location? (Detached head)

Answer 2

将工作副本还原为最近提交

要恢复到之前的提交，请忽略所有更改：

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

Answer 3

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

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

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

（--no-commit标志允许git立即恢复所有提交 - 否则会提示您为该范围内的每个提交发送一条消息，并使用不必要的新提交乱丢您的历史记录。）

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

Answer 4

我和其他人的最佳选择是Git重置选项：

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

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

---

注意： 正如评论中所述，如果您与拥有旧提交副本的其他人共享您的分支

，请不要执行此操作

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

git clean -i

Answer 5

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

的 First of all what is HEAD?

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

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

---

的 detached HEAD

如果您没有进行最新提交 - 意味着HEAD指向历史记录中的先前提交，则称为 detached HEAD 。< / p>

在命令行上它看起来像这样 - 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>

“移动”你的头回到所需的提交。

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

Answer 6

如果您想要＆＃34;取消提交＆＃34;，删除最后一次提交消息，并将修改后的文件放回到分段中，您将使用以下命令：

git reset --soft HEAD~1

• --soft表示未提交的文件应保留为与--hard相对的工作文件，这些文件会丢弃它们。
• HEAD~1是最后一次提交。如果要回滚3次提交，可以使用HEAD~3。如果要回滚到特定的修订版号，也可以使用其SHA哈希来执行此操作。

如果您提交了错误的内容并且想要撤消上次提交，这是一个非常有用的命令。

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

Answer 7

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

git add . && git checkout master -f

简短说明：

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

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

git add . && git reset --hard HEAD

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

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

Answer 8

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

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

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

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

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

然后它会保存您的更改。

Answer 9

好的，回到以前的git提交非常简单......

在不保留更改的情况下还原：

git reset --hard <commit>

将保留还原为：

git reset --soft <commit>

解释：使用git reset，您可以重置为特定状态，如上所述，通常使用提交哈希。

但正如您所看到的不同之处在于使用两个标记--soft和--hard，默认情况下git reset使用--soft标记，但这是一个很好的做法，总是使用标记，我解释每一面旗帜：

- 软

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

- 硬

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

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

Answer 10

最好的方法是：

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

这会将分支重置为特定的提交，然后以与本地相同的提交上载远程服务器（这将在该特定的提交之后完全限制命令）

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

Answer 11

除了这个确切的组合之外，这里没有任何东西对我有用：

git reset --hard <commit_hash>
git push origin <branch_name> --force

这里的关键是强制推送，没有额外的提交/提交消息等。

Answer 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>超出我的范围。

Answer 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>"

这基本上可以通过使用软重置将使先前提交的状态保留在index / staging-area中的事实来实现，然后您可以提交它。

备选方案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>。

Answer 14

假设你正在谈论主人和那个分支（说这可能是你关心的任何工作分支）：

# 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，则会导致问题。你正在摧毁改变历史，这是人们首先使用git的一个重要原因。

最好使用还原（参见其他答案）而不是重置。 如果你是一个单人团队，那么它可能并不重要。

Answer 15

这是一种更简单的方式，可以回到之前的提交（让它处于非公开状态，无论你喜欢什么，都可以使用它）：

git reset HEAD~1

因此，不需要提交ID等等）。

Answer 16

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

git back

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

# Remove the latest three commits
git back 3

Answer 17

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

git push -f ...

不仅git push。

Answer 18

您可以自己完成所有这些初始步骤，然后再回到git repo。

1. 使用以下方法从Bitbucket中提取最新版本的存储库 git pull --all命令。

2. 从终端运行带-n 4的git log命令。 -n之后的数字确定从本地历史记录中最近一次提交开始的日志中的提交数。

   $ git log -n 4

3. 使用git reset --hard HEAD~N重置存储库历史记录的头部，其中N是您想要返回的提交数。在下面的示例中，头部将被设置为一个 提交到存储库历史记录中的最后一次提交：

4. 使用git push --force将更改推送到git repo以强制推送 改变。

如果您希望git存储库到先前的提交

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

Answer 19

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

git reset --hard HEAD

Answer 20

选择您需要的提交，然后按

进行检查

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

直到你得到所需的提交。要使HEAD指向，请执行

git reset --hard HEAD~1

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

Answer 21

要保持从先前提交到HEAD的更改并移至上一次提交，请执行：

git reset <SHA>

如果从之前的HEAD提交中不需要更改并且只丢弃所有更改，请执行以下操作：

git reset --hard <SHA>

Answer 22

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

git add -A .
git reset --hard HEAD

只是git reset --hard HEAD将摆脱修改，但它不会摆脱“新”文件。在他们的情况下，他们意外地随机拖动了一个重要文件夹，所有这些文件被Git视为新文件，因此reset --hard没有修复它。通过预先运行git add -A .，它会使用git显式跟踪它们，以便通过重置来消除它们。

Answer 23

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

git stash
git stash clear

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

PS：它有点问题;它还会删除您最近存储的所有存储更改。在大多数情况下，我猜这应该不重要。

Answer 24

我相信有些人可能会想要知道如何回滚他们在主人身上做出的改变 - 也就是扔掉所有东西然后回到原点/主人，在这种情况下，这样做：< / p>

git reset --hard origin/master

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

Answer 25

Revert是回滚提交的命令。

git revert <commit1> <commit2> 

样品：

git revert 2h3h23233

它能够从HEAD中获取范围，如下所示。这里1表示＆＃34;还原最后一次提交。＆＃34;

git revert HEAD~1..HEAD

然后执行git push

Answer 26

还原最近的提交：

git reset --hard HEAD

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

还原为较早的提交： 恢复旧版本的最快方法是使用reset命令：

# Resets index to former commit
git reset 56e05fced 

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

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

这会将您的HEAD分支倒退到指定的版本。此版本之后的所有提交都将被撤消；您的项目与当时的情况完全一样。

reset命令带有两个选项，其中更有趣的一个是--soft标志。如果使用它而不是--hard，则Git会将所有“未完成”提交中的更改保留为本地修改。

在 新本地分支机构

中恢复修订

如前所述，在您的HEAD分支上使用reset命令是一项非常严厉的动作：它将删除指定修订版之后的所有提交（在此分支上）。如果您确定要这样做，那么一切都很好。

但是，还有一种更安全的方式，以防您希望不影响当前的HEAD分支。由于在Git中“分支机构”是如此便宜和容易，因此我们可以轻松地创建一个从该旧版本开始的新分支机构：

git checkout -b old-project-state 0ad5a7a6

通常，checkout命令仅用于切换分支。但是，提供-b参数，还可以让它创建一个新分支（在本示例中为 old-project-state ）。如果您不希望它从当前的HEAD版本开始，则还需要提供一个提交哈希-我们要还原的旧项目版本。

您现在有了一个名为 old-project-state 的新分支，它反映了项目的旧版本-无需触摸甚至删除任何其他提交或分支。

Answer 27

如果情况是紧急情况，并且您只想以快速和肮脏的方式执行提问者的要求，假设您的项目位于目录“my”项目“：

1. 复制整个目录并调用其他内容，例如“my project - copy”

2. 执行：

   git reset --hard [first-4-letters&numbers-of-commit's-SHA]
   

您的系统上有两个版本...您可以检查或复制或修改先前提交中感兴趣的文件或其他任何内容。你可以完全放弃“我的项目 - 复制”下的文件，如果你已经决定新工作无处可去......

显而易见的是，如果你想继续执行项目状态而不实际丢弃工作，因为这个检索到的提交是重新命名你的目录：删除包含检索到的提交的项目（或给它一个临时名称）和将“我的项目 - 复制”目录重命名为“我的项目”。然后可能很快就会做另一次提交。

Git是一个出色的创作，但你不能只是“随时拿起它”：试图解释它的人经常假设其他VCS的先验知识[版本控制系统并且过早地钻研太深，并犯下其他罪行，比如使用可互换的术语来“退出” - 有时候看起来几乎可以混淆一个初学者。

为了节省很多压力，你必须要读一本关于Git的书 - 我建议"Version Control with Git"。如果你说“必须”时你可以相信我（或者更确切地说是我的伤疤），那么你可以选择 NOW 。 Git的大部分复杂性来自分支然后重新合并。但是从你的问题来看，没有理由为什么人们应该用科学来炫耀你。

特别是如果，例如，这是一个绝望的情况，你是Git的新手！

PS：另一个想法：将Git存储库（“repo”）保存在除工作文件之外的目录中（实际上）非常简单。这意味着你不必使用上面的快速＆amp; amp;来复制整个Git存储库。肮脏的解决请参阅Fryer使用--separate-git-dir here的答案。 被警告，但是：如果您有一个“单独目录”存储库而您没有复制，并且您进行了硬重置，则重置提交之后的所有版本将永远丢失，除非您我们绝对应该定期备份您的存储库，最好是在其他地方备份到云端（例如Google Drive）。

Answer 28

尝试重置为所需的提交 -

git reset <COMMIT_ID>

（检查COMMIT_ID使用git log）

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

现在您可以通过

checkout所有未添加的文件

git checkout .

检查git log以验证您的更改。

<强>更新

如果您的回购中有一个且仅提交，请尝试

git update-ref -d HEAD

Answer 29

当您的提交被远程推送时，您需要将其删除。让我假设你的分支正在发展，它被推到原点。

首先需要从原点中删除develop：

git push origin :develop (note the colon)

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

git reset --hard EFGHIJK

最后，再次推动发展：

git push origin develop

Answer 30

  

警告！如果用户错误地提交了错误的提交，此命令可能会导致丢失提交历史记录。总是有你额外的git备份   如果你犯错误，还有其他地方，比你更安全一些。   ：）

我遇到了类似的问题，并希望恢复早期的提交。在我的情况下，我没有进行更新的提交，因此我使用了Hard。

我就这样做了：

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

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

git push -f

Answer 31

在GitKraken上你可以这样做：

1. 右键单击要重置的提交，选择：重置为此提交/硬：



1. 再次右键单击提交，选择：当前分支名称/推送：



1. 点击强制推送：



Obs。：您需要小心，因为硬重置后的所有提交历史都会丢失，并且此操作是不可逆转的。你需要确定你在做什么。

Answer 32

如果你想纠正上次提交中的一些错误，那么一个好的选择就是使用 git commit --amend 命令。如果任何引用都没有指向最后一次提交，那么这将起到作用，因为它创建一个与最后一次提交具有相同父级的提交。如果没有对最后一次提交的引用，它将被简单地丢弃，并且此提交将是最后一次提交。这是在不恢复提交的情况下纠正提交的好方法。但它有其自身的局限性。

Answer 33

首先，获取在某个日期标识提交的字符串，执行：

git rev-list -n 1 --before="2009-07-27 13:37" origin/master

它打印提交标识符，取字符串（例如XXXX）并执行：

git checkout XXXX

Answer 34

用于回滚（或恢复）：

  

  
1. git revert --no-commit＆＃34; commit-code-to-remove＆＃34;头   （例如git revert --no-commit d57a39d HEAD）
  
2. git commit
  
3. git push
  

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

如果您发现错误，请执行以下操作：

  

git revert --abort

Answer 35

使用SourceTree可以轻松完成。只需右键单击您正在寻找的提交，然后从菜单中选择“结帐”。

Answer 36

另一个最简单的解决方案;你必须改变分支才能做到这一点，但之后你可以运行：

git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

Answer 37

git reflog

选择git reflog的HEAD数量，你想要恢复和执行的地方（本例中我选择12）：

git reset HEAD@{12} --hard

Answer 38

由于某些原因，我无法手动恢复我，所以这就是我最终的做法。

1. 检查出我想要的分支，复制它。
2. 检查了最新的分支。
3. 将我想要的分支内容复制到最新分支的目录中，覆盖更改并提交。

Answer 39

将分支恢复到任何特定提交的最简单方法，您无法更改我找到的历史记录：

1. 结帐您希望还原的提交或分支。
2. 编辑.git / HEAD并将ref更改为要还原到的分支。

如：

echo 'ref: refs/heads/example' > .git/HEAD

如果您随后执行git状态，则应该看到您所在的分支与您希望恢复的分支之间的所有更改。

如果一切都很好，你可以提交。你也可以使用git diff revert..example来确保它是一样的。

Answer 40

如果您想暂时还原更改

• 有人提交了破坏构建或破坏您正在使用的功能的代码

您可以使用git log搜索上次工作提交，然后运行

git pull --rebase

当远程分支再次运行时，您可以

{{1}}

这种方法比临时更改的git checkout要好，因为你没有处于分离状态。

Answer 41

重置分阶段的更改和提交

通过git reset命令，您可以更改HEAD（工作树指向的最新提交）。它修改登台区域或登台区域和工作树。 Git完全按照您的意愿进行提交的能力意味着您有时需要撤消对使用git add暂存的更改的更改。您可以通过调用git reset HEAD <file to change>来实现。您有两个选择可以完全摆脱更改。 git checkout HEAD <file(s) or path(s)>是撤消对暂存区和工作树的更改的快速方法。但是，请谨慎使用此命令，因为它会删除对工作树的所有更改。 Git不知道这些更改，因为它们从未提交。一旦运行此命令，就无法取回这些更改。您可以使用的另一个命令是git reset --hard。它同样会对您的工作树造成破坏，任何未提交的更改或分阶段的更改在运行后都会丢失。运行git reset -hard HEAD与git checkout HEAD相同。它只需要一个文件或路径即可使用。您可以将--soft与git reset一起使用。它将存储库重置为您指定的提交并分阶段进行所有这些更改。您已经进行的任何更改都不会受到影响，您的工作树中的更改也不会受到影响。最后，您可以使用--mixed重置工作树而不进行任何更改。这也将撤消所有已进行的更改。 >

还原提交

有时我们会犯错误。不应该共享的提交将被推送到公共存储库中，提交具有无法修复的错误，需要被撤消，或者也许您不再需要该代码了。调用git revert。git revert命令可以实现您所期望的功能。它通过对历史记录应用反向提交来还原单个提交。有时您需要还原多个提交以完全撤消更改。您可以使用-no-commit，也可以使用-n告诉Git执行还原，但不要提交更改。这使您可以将所有还原提交合并为一个提交，这在需要还原跨越多个提交的功能时很有用。确保以相反的顺序还原提交-首先提交最新的提交。否则，您可能会尝试还原尚不存在的代码，从而使Git感到困惑。

Answer 42

如果要删除完成提交，请尝试以下操作：

git reset --hard commitId //delete your local commits
git push -f origin yourOrigin //delete your github remotes commits

Answer 43

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

1. Emppy工作树*。

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

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

   git checkout 0d1d7fc3 .
   

3. 创建还原提交。

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

---

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

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

---

通过从工作树中删除未跟踪但未被忽略的文件（在 .gitignore 中指定的文件）来

_{*。除了我们要保留的被忽略文件（如果未为-x指定clean选项）之外，工作树为空}

_{**指定路径（此处为.）时，签出仅保留HEAD。}

Answer 44

我没有看到使用樱桃挑选：

• 提交A（反向B）
• 提交B

樱桃采摘A：

• 提交B
• 提交A（反向B）
• 提交B