关于Git签出：如何将Git存储库恢复为以前的提交


How to revert a Git repository to a previous commit

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

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

more blah blah blah...

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

And yet more blah blah...

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

Yep, more blah blah.

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

相关讨论

这很大程度上取决于你所说的"还原"。

临时切换到其他提交

如果你想暂时回到原来的状态，那就绕过去，然后回到原来的状态，你所要做的就是检查一下你想要的承诺：

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

或者，如果你想在那里的时候做出承诺，那就在那里做一个新的分支吧：

1
git checkout -b old-state 0d1d7fc32

要回到原来的位置，只需再次查看您所在的分支。(如果你已经做出了改变，像往常一样在切换分支时，你必须适当地处理它们。您可以重新设置以丢弃它们；您可以隐藏、结帐、存储弹出窗口以随身携带它们；如果您希望在那里建立分支，您可以将它们提交到那里的分支。)

硬删除未发布的提交

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

1
2
3
4
5
6
7
8
9
10
11
# 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有一个非常具体的含义：使用reverse补丁创建一个commit来取消它。这样你就不会重写任何历史。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 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手册在其描述中实际上涵盖了很多这方面的内容。另一个有用的链接是git-scm.com部分，讨论git还原。

如果您决定根本不想还原，可以还原还原(如此处所述)或重置回还原之前的状态(请参阅上一节)。

在这种情况下，您也会发现这个答案很有用：如何将头部移回以前的位置？(分离头)

相关讨论

正在将工作副本还原为最新提交

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

1
git reset --hard HEAD

其中head是当前分支中的最后一个提交

将工作副本还原为旧提交

要恢复到比最新提交早的提交，请执行以下操作：

1
2
3
4
5
6
7
8
9
10
# 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

学分转到一个类似的堆栈溢出问题，在git中通过sha散列返回到commit？.

相关讨论

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

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

这将把所有内容从头部还原到提交哈希，这意味着它将在工作树中重新创建提交状态，就好像从那时起的每个提交都被退回了。然后您可以提交当前树，它将创建一个全新的提交，本质上相当于您"恢复"到的提交。

(--no-commit标志允许Git一次恢复所有提交—否则将提示您为该范围内的每个提交发送一条消息，并将不必要的新提交丢弃在您的历史记录中。)

这是一种安全、简单的回滚到以前状态的方法。历史不会被破坏，所以它可以用于已经公开的提交。

相关讨论

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

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

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

注意：正如评论中提到的，如果您与其他拥有旧提交副本的人共享您的分支，则不要这样做。

另外，从评论中，如果你想要一个不那么"疯狂"的方法，你可以使用

git clean -i

相关讨论

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

First of all what is HEAD?

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

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

detached HEAD

如果您没有进行最新的提交，这意味着HEAD指向历史上的一个先前的提交，它被称为detached HEAD。

Enter image description here

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

Enter image description here

关于如何从分离的头部恢复的几个选项：git checkout

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

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

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

1
2
3
4
5
6
7
8
# 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设置回此提交。

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

1
2
git reflog
git checkout HEAD@{...}

这将使你回到你想要的承诺

Enter image description here

git reset HEAD --hard

"移动"你的头回到想要的承诺。

1
2
3
4
5
6
7
8
9
10
11
# 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。

Enter image description here

相关讨论

如果要"取消提交"，请清除最后一条提交消息，并将修改后的文件放回临时状态，则将使用以下命令：

1
git reset --soft HEAD~1
  • --soft表示未提交的文件应保留为工作文件，而不是将其丢弃的--hard。
  • HEAD~1是最后一次提交。如果要回滚3个提交，可以使用HEAD~3。如果要回滚到特定的修订号，也可以使用其sha散列进行回滚。

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

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

相关讨论

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

1
git add . && git checkout master -f

简短描述：

  • 它不会像git revert那样产生任何承诺。
  • 它不会像git checkout 那样分开你的头。
  • 它将覆盖所有本地更改，并删除自上次提交分支以来添加的所有文件。
  • 它只与分支名称一起工作，因此您只能以这种方式在分支中恢复到最新的提交。

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

1
git add . && git reset --hard HEAD

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

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

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

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

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

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

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

然后它将保存您的更改。

相关讨论

好吧，回到Git上一次提交非常简单…

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

1
git reset --hard <commit>

保留更改后还原：

1
git reset --soft <commit>

解释：使用git reset，你可以重置到一个特定的状态，这是常见的使用它与提交散列，如你所见。

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

--软

如前所述，不需要提供默认标志，它不会更改工作树，而是添加所有已准备好提交的更改文件，因此您将返回到提交状态，对文件所做的更改将被取消。

--硬

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

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

git reset to a commit

除了这个确切的组合，这里没有什么对我有用的：

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

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

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

创建一个bash shell脚本来恢复它们：

1
2
3
4
5
6
#!/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 是我无法理解的。

相关讨论

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

Jefromi的解决方案绝对是最好的，你应该使用它们。但是，为了完整性起见，我还想展示这些其他可选的解决方案，这些解决方案也可以用于恢复提交(从某种意义上说，您创建了一个新的提交来撤销以前提交中的更改，就像git revert所做的那样)。

显然，这些替代方案不是恢复承诺的最佳方法，Jefromi的解决方案是，但我想指出的是，您也可以使用这些其他方法来实现与git revert相同的事情。

备选方案1：硬重置和软重置

这是CharlesBailey的解决方案的一个非常小的修改版本，它可以通过git中的sha散列返回到commit？：

1
2
3
4
5
6
7
8
# 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的解决方案，用于签出旧提交并使其成为新提交：

1
2
3
git rm -r .
git checkout <commit> .
git commit

与备选方案1类似，这在当前工作副本中复制了的状态。必须先执行git rm，因为git checkout不会删除之后添加的文件。

相关讨论

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

1
2
3
4
5
# Revert local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

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

我在一篇博文中找到了答案(现在不存在了)

相关讨论

这里有一个更简单的方法返回到以前的提交(并使其处于未提交状态，您可以随意处理它)：

1
git reset HEAD~1

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

相关讨论

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

1
git push -f ...

不仅是git push。

相关讨论

有一个命令(不是核心git的一部分，但它在git extras包中)专门用于恢复和转移旧提交：

1
git back

在手册页上，还可以这样使用：

1
2
# Remove the latest three commits
git back 3

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

  • 使用git pull --all命令。

  • 使用-n 4从终端运行git log命令。-n后面的数字确定日志中从本地历史记录中最近的提交开始的提交数。

    $ git log -n 4

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

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

    • 如果您希望Git存储库以前提交

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

    还原为最新提交并忽略所有本地更改：

    1
    git reset --hard HEAD

    选择所需的提交，并通过检查

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

    直到你得到所需的承诺。为了说明这一点，一定要

    1
    git reset --hard HEAD~1

    或者是git reset --hard HEAD~2或者其他什么。

    相关讨论

    要保留从上一个提交到头的更改并移动到上一个提交，请执行以下操作：

    1
    git reset <SHA>

    如果上一次提交到头部不需要更改，只需放弃所有更改，请执行以下操作：

    1
    git reset --hard <SHA>
    这是另一种直接重置为最近提交的方法

    1
    2
    git stash
    git stash clear

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

    附言：有点问题，它也会删除你最近存储的所有隐藏更改。我想在大多数情况下都不重要。

    相关讨论

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

    1
    2
    git add -A .
    git reset --hard HEAD

    只需git reset --hard HEAD就可以删除修改，但它不能删除"新"文件。在他们的案例中，他们不小心将一个重要文件夹随机拖到了某个地方，所有这些文件都被Git视为新文件，所以一个reset --hard没有修复它。通过预先运行git add -A .，它明确地用git跟踪它们，并通过重置消除它们。

    我相信有些人可能会遇到这样的问题，希望知道如何回滚他们在主服务器中所做的承诺更改——即扔掉所有东西，返回到源服务器/主服务器，在这种情况下，执行以下操作：

    1
    git reset --hard origin/master

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

    还原最近的提交：

    1
    git reset --hard HEAD

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    # 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

    这将使您的头分支倒带到指定的版本。在这个版本之后的所有提交都被有效地撤销了；您的项目和那个时候完全一样。

    reset命令有两个选项，其中一个更有趣的选项是--soft标志。如果您使用它而不是--hard，那么git将保留这些"未完成"提交中的所有更改作为本地修改。

    在新的本地分支中恢复修订

    如前所述，在您的HEAD分支上使用reset命令是一个非常激烈的操作：它将删除指定修订之后的任何提交(在此分支上)。如果你确定这是你想要的，一切都很好。

    不过，还有一种更安全的方法，以防您更喜欢保持您当前的头分支不变。由于"分支"在Git中既便宜又容易，因此我们可以轻松地创建一个新分支，从旧版本开始：

    1
    git checkout -b old-project-state 0ad5a7a6

    通常，checkout命令只用于切换分支。但是，提供-b参数，还可以让它创建一个新的分支(在本例中称为旧项目状态)。如果您不希望它从当前的头部修订开始，您还需要提供一个提交哈希-我们要恢复的旧项目修订。

    现在，您有了一个名为旧项目状态的新分支，它反映了项目的旧版本——不需要触摸甚至删除任何其他提交或分支。

    REVERT是回滚提交的命令。

    1
    git revert <commit1> <commit2>

    Sample：

    git revert 2h3h23233

    它可以像下面那样从头部开始移动。这里1说"恢复上次提交"。

    git revert HEAD~1..HEAD

    然后做git push。

    如果情况紧急，而你只想快速而肮脏地完成发问者的要求，假设你的项目在"我的项目"目录下：

  • 复制整个目录并将其命名为其他内容，如"我的项目-复制"

  • 做：

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

    • 然后系统上有两个版本…您可以检查、复制或修改以前提交的感兴趣的文件或其他文件。如果你已经决定新的工作毫无进展的话，你可以完全放弃"我的项目副本"下的文件。

    如果您希望在不实际放弃工作的情况下继续项目的状态，因为这个检索到的提交将再次重命名您的目录：删除包含检索到的提交的项目(或给它一个临时名称)，然后将您的"我的项目-复制"目录重命名回"我的项目"。然后很快再做一次承诺。

    Git是一个杰出的创造，但你不能仅仅"随时随地"去理解它：同样，那些试图解释它的人往往会假定自己对其他VCS(版本控制系统)有先见之明，并且过早地钻研得太深，并且犯下其他罪行，例如使用可互换的术语"签出"，这种方式有时看起来几乎是故意的。混淆初学者。

    为了减轻你自己的压力，你必须读一本关于Git的书——我建议你读"带Git的版本控制"。如果我说"必须"的时候你能相信我(或者更确切地说是我的伤疤)，那么你现在就可以这么做了。Git的复杂性很大程度上来自于分支和重聚。但从你的问题来看，人们没有理由用科学蒙蔽你的双眼。

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

    另一种想法是：将git存储库("repo")保存在一个目录中，而不是保存工作文件的目录中，这(现在)实际上非常简单。这意味着您不必使用上述快速和肮脏的解决方案复制整个Git存储库。请参阅fryer使用的答案——这里是单独的git dir。不过，请注意：如果您有一个"单独的目录"存储库，而您没有复制该存储库，并且您进行了硬重置，则重置提交之后的所有版本都将永远丢失，除非您像绝对应该的那样定期备份存储库，最好是将其备份到云端(如Google Drive)以及其他位置。

    尝试重置为所需提交-

    git reset

    (要检查提交ID，请使用git log)

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

    现在，您可以通过以下方式删除所有未添加的文件：

    git checkout .

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

    更新

    如果在回购中只有一个承诺，请尝试

    git update-ref -d HEAD

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

    您首先需要从源位置移除显影：

    1
    git push origin :develop (note the colon)

    然后，您需要获得您想要的开发状态，让我假设提交哈希为efghijk：

    1
    git reset --hard EFGHIJK

    最后，再次推动开发：

    1
    git push origin develop

    Caution! This command can cause losing commit history, if user put the wrong commit mistakenly. Always have en extra backup of your git some
    where else just in case if you do mistakes, than you are a bit safer.
    :)

    我也遇到过类似的问题，我想回到以前的承诺。在我的情况下，我没有被灌输保持更新的承诺，因此我使用了Hard。

    我就是这样做的：

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

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

    1
    git push -f

    如果您想在最后一次提交中纠正一些错误，一个好的选择是使用git-commit--amend命令。如果最后一次提交没有被任何引用指向，那么这将实现技巧，因为它使用与最后一次提交相同的父级创建提交。如果没有对最后一次提交的引用，它将被丢弃，而这个提交将是最后一次提交。这是一种纠正提交而不恢复提交的好方法。但它也有自己的局限性。

    在Gitkraken上，您可以这样做：

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

    • enter image description here

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

    • enter image description here

  • 点击力推：

    • enter image description here

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

    对于回滚(或还原)：

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

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

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

    git revert --abort

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

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

    它打印提交标识符，获取字符串(例如XXXX)并执行以下操作：

    1
    git checkout XXXX

    另一个最简单的解决方案是：您必须更改分支才能执行此操作，但之后您只需运行：

    1
    git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    相关讨论

    使用sourcetree可以更容易地完成。只需右键单击要查找的提交，然后从菜单中选择"签出"。

    enter image description here

    1
    git reflog

    选择git reflog头的编号，您希望在其中恢复到和执行(对于本例，我选择12)：

    1
    git reset HEAD@{12} --hard

    由于某种原因，我无法手动还原我的，所以我最终是这样做的。

  • 签出我想要的分支，复制它。
  • 签出了最新的分支。
  • 将我想要的分支的内容复制到最新分支的目录中，覆盖并提交更改。

    • 将分支恢复到任何特定提交的最简单方法是：

  • 签出要恢复的提交或分支。
  • 编辑.git/head并更改要恢复到的分支的引用。

    • 例如：

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

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

    如果一切看起来都好，你可以承诺。您还可以使用git diff revert..示例来确保它是相同的。

    如果要临时还原更改，因为

    • 有人提交了破坏构建或破坏正在处理的功能的代码

    您可以使用git日志搜索最后一次工作提交，然后运行

    1
    git rebase --onto <commitId>

    当远程分支再次工作时，您可以

    1
    git pull --rebase

    对于临时更改，此方法优于Git签出，因为您没有处于分离状态。

    重置阶段性更改和提交

    git reset命令允许您更改头部—最新的将工作树点提交到存储库中。它修改临时区域或临时区域和工作树。Git能够完全按照您想要的方式处理提交，这意味着您有时需要撤消对Git Add所进行的更改。你可以打电话给git reset HEAD 。有两个选项可以完全消除更改。git checkout HEAD 是一种撤消对临时区域和工作树的更改的快速方法。但是，请小心使用此命令，因为它会删除对工作树的所有更改。Git不知道这些更改，因为它们从未被提交过。运行此命令后，无法恢复这些更改。另一个命令是git reset --hard。它对您的工作树具有同样的破坏性，任何未提交的更改或阶段性更改在运行后都会丢失。运行git reset -hard头与git checkout head执行相同的操作。它不需要文件或路径就可以工作。您可以使用带git reset的--soft。它将存储库重置为您指定的提交，并对所有这些更改进行阶段处理。您已经进行的任何更改都不会受到影响，工作树中的更改也不会受到影响。最后，您可以使用--mixed重置工作树，而不进行任何更改。这也会取消任何已进行的更改。

    恢复承诺

    有时我们会犯错。不应该共享的提交被推送到公共存储库，提交有一个无法修复的bug，需要撤消，或者您可能不再需要该代码。这些情况都要求使用git revert。git revert命令执行您可能期望的操作。它通过对历史记录应用反向提交来还原单个提交。有时需要还原多个提交以完全撤消更改。您可以使用-no-commit，也可以使用-n通知git执行还原，但在提交更改之前停止。这使您可以将所有恢复提交合并为一个提交，如果需要恢复跨越多个提交的功能，这将非常有用。确保先按与最新提交相反的顺序还原提交。否则，您可能会通过尝试还原尚不存在的代码来混淆Git。

    我没看到用樱桃采摘：

    • 提交A(反向B)
    • 提交B

    樱桃摘A：

    • 提交B
    • 提交A(反向B)
    • 提交B
    相关讨论