这将添加一个新的提交，删除添加的文件。

git rm yourfiles/*.classgit commit -a -m "deleted all class files in folder 'yourfiles'"

或者您可以重写历史以撤消上次提交。

警告：此命令将永久删除对您提交的.java文件（和任何其他文件）的修改-并从您的工作目录中删除您的所有更改：

git reset --hard HEAD~1

hard reset到HEAD-1将您的工作副本设置为错误提交之前的提交状态。

撤销提交和重做

$ git commit -m "Something terribly misguided" # (0: Your Accident)$ git reset HEAD~                              # (1)[ edit files as necessary ]                    # (2)$ git add .                                    # (3)$ git commit -c ORIG_HEAD                      # (4)

1. git reset是负责撤销的命令。它将撤消您的最后一次提交，而保持您的工作树（磁盘上文件的状态）不变。您需要再次添加它们才能再次提交它们）。
2. 更正工作树文件。
3. git add你想包含在新提交中的任何内容。
4. 提交更改，重用旧的提交消息。reset将旧的头复制到.git/ORIG_HEAD；#2与#3将打开一个编辑器，它最初包含旧提交的日志消息并允许您编辑它。如果您不需要编辑消息，您可以使用#4选项。

或者，编辑前一个提交（或只是其提交消息）、commit --amend将当前索引中的更改添加到前一个提交中。

删除（不恢复）已推送到服务器的提交，用git push origin main --force[-with-lease]重写历史是必要的。使用--force几乎总是一个坏主意, 可以使用--force-with-lease来代替如的git手册所述：

如果你[重写历史提交]已经发表，你应该理解重写历史的含义。

进一步阅读

您可以使用git reflog来确定SHA-1用于您希望恢复的提交。一旦您有了这个值，请使用上面解释的命令序列。

HEAD~与HEAD~1相同。如果您想取消提交多个提交，文章Git中的HEAD是什么？很有帮助。

添加/删除文件以获得您想要的方式：

git rm classdirgit add sourcedir

然后修改提交：

git commit --amend

之前的错误提交将被编辑以反映新的索引状态-换句话说，就像你一开始就没有犯过错误一样。

请注意，只有当您还没有推送时，您才应该这样做。如果您已经推送，那么您只需正常提交修复程序即可。

更改最后一次提交

替换索引中的文件：

git rm --cached *.classgit add *.java

然后，如果它是一个私有分支，修改提交：

git commit --amend

或者，如果它是一个共享分支，则进行新的提交：

git commit -m 'Replace .class files with .java files'

（要更改之前的提交，请使用令人敬畏的交互式rebase）。

ProTip™：将*.class添加到gitignore以阻止这种情况再次发生。

恢复提交

如果您需要更改最后一次提交，修改提交是理想的解决方案，但更通用的解决方案是reset。

您可以使用以下命令将Git重置为任何提交：

git reset @~N

其中N是HEAD之前的提交数，@~重置为上一次提交。

而不是修改提交，你可以使用：

git reset @~git add *.javagit commit -m "Add .java files"

查看git help reset，特别是--soft--mixed和--hard的部分，以便更好地了解它的作用。

重新加载

如果你搞砸了，你可以随时使用reflg来查找丢弃的提交：

$ git reset @~$ git reflogc4f708b HEAD@{0}: reset: moving to @~2c52489 HEAD@{1}: commit: added some .class files$ git reset 2c52489... and you're back where you started

有两种方法可以“撤消”上次提交，具体取决于您是否已经公开提交（推送到远程存储库）：

如何撤消本地提交

假设我在本地提交，但现在我想删除该提交。

git logcommit 101: bad commit    # Latest commit. This would be called 'HEAD'.commit 100: good commit   # Second to last commit. This is the one we want.

要将所有内容恢复到上次提交之前的状态，我们需要将reset恢复到HEAD之前的提交：

git reset --soft HEAD^     # Use --soft if you want to keep your changesgit reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made

现在git log将显示我们的最后一次提交已被删除。

如何撤消公共提交

如果您已经公开了提交，您将需要创建一个新的提交，该提交将“恢复”您在先前提交（当前HEAD）中所做的更改。

git revert HEAD

您的更改现在将被恢复并准备好提交：

git commit -m 'restoring the file I removed by accident'git logcommit 102: restoring the file I removed by accidentcommit 101: removing a file we don't needcommit 100: adding a file that we need

有关更多信息，请查看Git Basics-撤销的东西。

如果你不知道它是如何工作的，那么撤消提交有点可怕。但如果你真的理解了，它实际上非常容易。我将向您展示撤消提交的4种不同方法。

假设你有这个，其中C是你的HEAD，（F）是文件的状态。

   (F)A-B-C↑master

选项1：git reset --hard

你想要销毁提交C并丢弃任何未提交的更改。你这样做：

git reset --hard HEAD~1

结果是：

 (F)A-B↑master

现在B是HEAD。因为您使用了--hard，所以您的文件将重置为提交B时的状态。

选项2：git reset

也许提交C不是一场灾难，而是有点偏离。在做更好的提交之前，你想撤消提交，但保留您的更改进行一些编辑。从这里重新开始，以C作为你的HEAD：

   (F)A-B-C↑master

这样做，去掉--hard：

git reset HEAD~1

在这种情况下，结果是：

   (F)A-B-C↑master

在这两种情况下，HEAD只是指向最新提交的指针。当你做git reset HEAD~1时，你告诉Git将HEAD指针向后移动一次提交。但是（除非你使用--hard）你会保持文件原样。所以现在git status显示了你签入C的更改。你没有丢失任何东西！

选项3：git reset --soft

对于最轻的触摸，您甚至可以撤消你的提交，但保留你的文件和索引：

git reset --soft HEAD~1

这不仅会留下你的文件，甚至会留下你的索引。当你做git status时，你会看到索引中的文件和以前一样。事实上，在这个命令之后，你可以做git commit，你会重做你刚刚做过的同样的提交。

选项4：你做了git reset --hard并需要取回该代码

还有一件事：假设你像第一个例子中的销毁一个提交，但后来发现你还是需要它？运气不好，对吧？

不，有0个办法把它弄回来，输入这个

git reflog

你会看到一个你已经移动的（部分）提交shas（即哈希）列表。找到你销毁的提交，并执行此操作：

git checkout -b someNewBranchName shaYouDestroyed

你现在已经复活了那个提交。提交实际上在Git中大约90天内不会被销毁，所以你通常可以回去拯救一个你不想摆脱的提交。

如果您安装了gitextras，您可以运行git undo来撤消最新的提交。git undo 3将撤消最后三次提交。

我想撤消我们共享存储库中最近的五次提交。我查找了我想回滚到的修订ID。然后我输入以下内容。

prompt> git reset --hard 5a7404742c85HEAD is now at 5a74047 Added one more page to catalogueprompt> git push origin master --forceTotal 0 (delta 0), reused 0 (delta 0)remote: bb/acl: neoneye is allowed. accepted payload.To git@bitbucket.org:thecompany/prometheus.git+ 09a6480...5a74047 master -> master (forced update)prompt>

使用git revert <commit-id>。

要获取提交ID，只需使用git log。

我更喜欢使用git rebase -i来完成这项工作，因为会弹出一个不错的列表，我可以在其中选择要删除的提交。它可能不像这里的其他答案那样直接，但它只是感觉对。

选择要列出多少个提交，然后像这样调用（以登记最后三个）

git rebase -i HEAD~3

样本列表

pick aa28ba7 Sanity check for RtmpSrv portpick c26c541 RtmpSrv version optionpick 58d6909 Better URL decoding support

然后Git将删除您删除的任何行的提交。

如果您计划完全撤消本地提交，无论您对提交所做的更改，如果您对此不担心，只需执行以下命令。

git reset --hard HEAD^1

（此命令将忽略您的整个提交，您的更改将从本地工作树中完全丢失）。如果您想撤消您的提交，但您希望在暂存区域中进行更改（在提交之前就像在git add之后一样），请执行以下命令。

git reset --soft HEAD^1

现在您提交的文件进入暂存区域。假设如果您想取消文件，因为您需要编辑一些错误的内容，然后执行以下命令

git reset HEAD

现在已提交的文件将从暂存区域进入未暂存区域。现在文件已准备好编辑，因此无论您更改什么，您都要去编辑并添加它并进行新的/新的提交。

更多（链接中断）（存档版本）

如何修复之前的本地提交

使用git-gui（或类似的）执行git commit --amend。您可以从GUI中添加或删除提交中的单个文件。您也可以修改提交消息。

如何撤消之前的本地提交

只需将您的分支重置到以前的位置（例如，使用gitk或git rebase）。然后从保存的副本中重新应用您的更改。在您的本地存储库中使用垃圾回收机制后，就像从未发生过不需要的提交一样。要在一个命令中完成所有这些，请使用git reset HEAD~1。

警告的话：粗心使用git reset是让您的工作副本进入混乱状态的好方法。我建议Git新手尽可能避免这种情况。

如何撤消公共提交

执行reverse cherry pick（git恢复）撤消更改。

如果您还没有将其他更改拉到您的分支上，您可以简单地…

git revert --no-edit HEAD

然后将更新的分支推送到共享存储库。

提交历史记录将分别显示两个提交

高级：更正公共存储库中的私人分支

这可能是危险的——确保您有分支的本地副本要重新推送。

另请注意：如果其他人可能在分支上工作，您不希望这样做。

git push --delete (branch_name) ## remove public version of branch

在本地清理您的分支，然后重新启动…

git push origin (branch_name)

在正常情况下，你可能不必担心你的私有分支提交历史是原始的。只需推送一个后续提交（参见上面的“如何撤消公共提交”），然后执行squash-合并以隐藏历史。

另一种方式：

签出你想要恢复的分支，然后将你的本地工作副本重置回你想要成为远程服务器上最新的提交（之后的一切都将再见）。为此，我在SourceTree中右键单击并选择“将BRANCHNAME重置为此提交”。

然后导航到存储库的本地目录并运行以下命令：

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

这将删除本地存储库中当前提交之后的所有提交，但仅限于该分支。

键入git log并找到最后一个提交哈希码，然后输入：

git reset <the previous co>

如果您想永久撤消它，并且您已经克隆了一些存储库。

提交ID可以通过以下方式看到：

git log

然后你可以这样做：

git reset --hard <commit_id>
git push origin <branch_name> -f

在资源树（GitHub的GUI）上，您可以右键单击提交并执行“反向提交”。这应该会撤消您的更改。

在终端上：

您也可以使用：

git revert

或：

git reset --soft HEAD^ # Use --soft if you want to keep your changes.git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

在我的情况下，我不小心提交了一些我不想要的文件。所以我做了以下操作，它起作用了：

git reset --soft HEAD^git rm --cached [files you do not need]git add [files you need]git commit -c ORIG_HEAD

使用gitk或git log--stat验证结果

使用资源树（Git的图形工具）查看您的提交和树。您可以通过右键单击它直接手动重置它。

"将工作树重置为最后一次提交"

git reset --hard HEAD^

"从工作树中清除未知文件"

git clean

见-git快速参考

注意：此命令将删除您之前的提交，所以要小心使用！git reset --hard更安全。

第一轮：

git reflog

它将向您显示您在存储库上执行的所有可能的操作，例如提交、合并、拉取等。

然后这样做：

git reset --hard ActionIdFromRefLog

使用reflg找到正确的状态

git reflog

重置前重新登录

选择正确的重排（在我的情况下是f3cb6e2）并输入

git reset --hard f3cb6e2

之后，存储库HEAD将被重置为HEADO重置后日志

最后reflg看起来像下面的图片

REFLOG FINAL

对于本地提交

git reset --soft HEAD~1

或者如果你不记得它在哪个提交中，你可以使用

git rm --cached <file>

对于一个推送提交

从存储库历史中删除文件的正确方法是使用git filter-branch。也就是说，

git filter-branch --index-filter 'git rm --cached <file>' HEAD

但我建议您谨慎使用此命令。在git-filter（1）手册页处阅读更多信息。

一个命令：

git reset --soft 'HEAD^'

撤消最后一个本地提交效果很好！

如何撤消最后一次Git提交？

要将所有内容恢复到上次提交之前的状态，我们需要重置为HEAD之前的提交。

1. 如果您不想保留您所做的更改：

   git reset --hard HEAD^

2. If you want to keep your changes:

   git reset --soft HEAD^

Now check your git log. It will show that our last commit has been removed.

要重置到以前的版本，永久删除所有未提交的更改：

git reset --hard HEAD~1

如果你犯了垃圾但没有被推，

git reset --soft HEAD~1

头~1是head之前提交的简写。或者，如果您想重置为，您可以参考哈希的SHA-1。--软选项将删除提交，但它会保留所有更改的文件“要提交的更改”，正如git状态所说。

如果您想删除自head之前提交以来对工作树中跟踪文件的任何更改，请改用“--硬”。

或

如果你已经推了，有人拉了，这通常是我的情况，你不能使用git重置。但是你可以做一个git恢复，

git revert HEAD

这将创建一个新的提交，该提交将逆转意外提交引入的所有内容。

有两个主要场景

你还没推我呢

如果问题是您提交的额外文件（并且您不希望在存储库中使用这些文件），您可以使用git rm删除它们，然后使用--amend提交

git rm <pathToFile>

您还可以使用-r删除整个目录，甚至与其他Bash命令组合

git rm -r <pathToDirectory>git rm $(find -name '*.class')

删除文件后，您可以使用修改选项提交

git commit --amend -C HEAD # the -C option is to use the same commit message

这将重写您最近的本地提交，删除额外的文件，因此，这些文件永远不会在推送时发送，也会被GC从您的本地. git存储库中删除。

你已经推迟了承诺

您可以应用其他场景的相同解决方案，然后使用-f选项执行git push，但它是不建议，因为它用不同的更改覆盖了远程历史记录（它可能会弄乱您的存储库）。

相反，您必须在没有--amend的情况下进行提交（请记住关于-修改'：该选项重写上次提交的历史记录）。

通常情况下，你想要撤销提交，因为你犯了一个错误，你想修复它-本质上是OP在提出问题时所做的。

这里的大多数答案都集中在命令行上。虽然命令行是在您熟悉的情况下使用Git的最佳方式，但对于来自其他版本控制系统的Git来说，它可能有点陌生。

以下是使用GUI的方法。如果您安装了Git，那么您已经拥有遵循这些说明所需的一切。

注：我假设你在推送之前就意识到提交是错误的。如果你不知道推送是什么意思，那么你可能还没有推送。继续执行说明。如果你已经推送了错误的提交，风险最小的方法是用一个新的提交来跟进错误的提交来修复问题，就像在不允许你重写历史的版本管理系统中一样。

也就是说，以下是如何使用GUI修复您最近的错误提交：

1. 在命令行上导航到您的存储库并使用git gui启动GUI
2. 选择“修改上次提交”。您将看到上次提交消息、暂存的文件和未暂存的文件。
3. 现在将内容更改为您希望它们的外观，然后单击提交。

只需撤消最后一次提交：

git reset --soft HEAD~

或者撤消上次提交前的时间：

git reset --soft HEAD~2

或撤消任何先前的提交：

git reset --soft <commitID>

（您可以使用git reflog获取提交ID）

当您撤消之前的提交时，请记住清理工作场所

git clean

更多细节可以在文档中找到：git重置

你需要做的简单和快速

    git commit --amend

如果它是一个私人分支机构或

    git commit -m 'Replace .class files with .java files'

如果它是共享或公共分支。

使用此命令

git checkout -b old-state 0d1d7fc32

在我的例子中，我提交并推送到错误的分支，所以我想要的是恢复我所有的更改，以便我可以将它们提交到一个新的正确分支，所以我这样做了：

在你提交和推送的同一个分支上，如果你输入“git state”，你不会看到任何新的东西，因为你提交和推送了，现在输入：

    git reset --soft HEAD~1

这将使您的所有更改（文件）回到舞台区域，现在要将它们放回工作目录（取消舞台），您只需键入：

git reset FILE

其中“文件”是您要再次提交的文件。现在，这个文件应该在工作目录（非分阶段）中，包含您所做的所有更改。现在您可以更改为您想要的任何分支并在该分支中提交更改。当然，您提交的初始分支仍然存在所有更改，但在我的情况下，这是可以的，如果不适合您，您可以寻找在该分支中恢复提交的方法。

删除已经推送到Github的错误提交

git push origin +(previous good commit id):(branch name)

请指定您想在Github中重置的最后一个好的提交ID。

例如。如果最新提交ID错误，则在上面的git命令中使用分支名称指定上一个提交ID。

您可以使用git log获取先前的提交ID

您始终可以执行以前版本的git checkout <SHA code>，然后使用新代码再次提交。

典型的Git循环

在前面的回答中谈到与Git相关的命令时，我想与所有读者分享我典型的Git周期，这可能会有所帮助。这是我使用Git的方式，

1. 第一次从远程服务器克隆

   git clone $project

2. 从远程拉取（当我没有待处理的本地提交推送时）

   git pull

3. 将一个新的本地文件1添加到$to_be_committed_list中（假设$to_be_committed_list表示staged区域）

   git add $file1

4. 从$to_be_committed_list中删除错误添加的file2（假设file2像步骤3一样添加，这是我不想要的）

   git reset $file2

5. 提交$to_be_committed_list的file1

   git commit -m "commit message description"

6. 在推送之前将本地提交与远程存储库同步

   git pull --rebase

7. 解决冲突发生时的问题先决条件配置mergetool

   git mergetool #resolve merging here, also can manually merge

8. 添加冲突解决的文件，假设file1：

   git add $file1

9. 继续我之前的rebase命令

   git rebase --continue

10. 推送就绪并已同步最后一次本地提交

    git push origin head:refs/for/$branch # branch = master, dev, etc.

要撤消本地提交，请使用git reset <commit>。该教程也非常有助于向您展示它是如何工作的。

或者，您可以使用git revert <commit>：当您想要添加另一个回滚更改（但将其保留在项目历史记录中）的提交时，应使用恢复。

简单，在命令行中运行它：

git reset --soft HEAD~

有很多方法可以做到这一点：

Git命令撤消最后一次提交/之前的提交：

警告：不要使用--hard，如果你不知道你在做什么。--hard太危险了，它可能删除您的文件。

在Git中恢复提交的基本命令是：

$ git reset --hard <COMMIT -ID>

或

$ git reset --hard HEAD~<n>

提交标识：提交的ID

n：是您要恢复的最后提交次数

您可以获取提交ID，如下所示：

$ **git log --oneline**
d81d3f1 function to subtract two numbers
be20eb8 function to add two numbers
bedgfgg function to multiply two numbers

其中d81d3f1和be20eb8是提交ID。

现在，让我们看看一些案例：

假设您想恢复上次提交的“d81d3f1”。这里有两个选项：

$ git reset --hard d81d3f1

或

$ git reset --hard HEAD~1

假设你想恢复提交'be20eb8'：

$ git reset --hard be20eb8

有关更详细的信息，您可以参考并尝试其他一些命令，以将头部重置为指定状态：

$ git reset --help

撤销上次提交：

git reset --soft HEAD^或git reset --soft HEAD~

这将撤消最后一次提交。

这里--soft意味着重置到暂存。

HEAD~或HEAD^表示移动到HEAD之前提交。

将最后一次提交替换为新提交：

git commit --amend -m "message"

它将用新提交替换最后一次提交。

我从bitbucket得到了提交ID，然后做了：

git checkout commitID .

示例：

git checkout 7991072 .

它将其恢复到该提交的工作副本。

视觉工作室用户（2015年等）

如果您无法在Visual Studio中同步，因为您不允许推送到像“开发”这样的分支，那么正如我所尝试的那样，在Visual Studio中REVERT或RESET（硬或软）都不起作用。

根据投票吨的答案：

在项目root的命令提示符下使用它来核任何将尝试推送的内容：

git reset --hard HEAD~1

备份或压缩您的文件，以防您不想丢失任何工作等…

只需使用git reset --hard <last good SHA>来重置您的更改并提供新的提交。您也可以使用git checkout -- <bad filename>。

您可以使用：

git reset HEAD@{1}

此命令将在没有Git日志的情况下删除错误的提交。

使用什么，reset --soft还是reset --hard？

我只是为@Kyralessa的回答增加两分钱：

如果您不确定使用什么，请使用--soft（我使用此约定来记住它-<的trong>的oft以确保安全）。

为啥？

如果您错误地选择了--hard，您将以前所未有的方式LOSE您的更改。如果您错误地选择了--soft，您可以通过应用其他命令来实现与--hard相同的结果

git reset HEAD file.htmlgit checkout -- file.html

完整示例

echo "some changes..." > file.htmlgit add file.htmlgit commit -m "wrong commit"
# I need to resetgit reset --hard HEAD~1 (cancel changes)# ORgit reset --soft HEAD~1 # Back to staginggit reset HEAD file.html # back to working directorygit checkout -- file.html # cancel changes

信用归@Kyralessa。

如果你正在使用资源树，这将帮助你。

提交时右键单击，然后选择“重置（当前分支）/master到此提交”，最后选择“软”重置。

为了摆脱最后一次提交、最后2次提交和最后n次提交的（所有更改）：

git reset --hard HEAD~1git reset --hard HEAD~2...git reset --hard HEAD~n

并且，要在特定提交后删除任何内容：

git reset --hard <commit sha>

例如，

git reset --hard 0d12345

使用硬选项时要小心：它也会删除存储库中的本地更改并恢复到前面提到的提交。只有当你确定你在上次提交中搞砸了并且想及时返回时，你才应该运行此选项。

顺便说一句，大约7个字母的提交哈希就足够了，但在更大的项目中，你可能需要最多12个字母才能唯一。如果你愿意，你也可以使用整个提交SHA。

上述命令也适用于GitHub for Windows。

假设您在Visual Studio中工作，如果您进入分支历史记录并查看所有提交，只需选择要撤消的提交之前的事件，右键单击它，然后选择Revert。就这么简单。

认为我们有code.txt文件。我们对其进行了一些更改并承诺。我们可以用三种方法撤销这个提交，但首先你应该知道什么是暂存文件…暂存文件是准备提交的文件，如果您运行git status，此文件将显示为绿色，如果未暂存提交，则显示为红色：

这意味着如果您提交更改，则此文件上的更改不会保存。您可以使用git add code.txt在您的阶段中添加此文件，然后提交更改：

撤销上次提交：

1. 现在，如果我们只想撤消提交而不做任何其他更改，我们可以使用

   git reset --soft HEAD^

   

2. 如果我们想撤消提交及其更改（这很危险，因为你的变化会丢失），我们可以使用

   git reset --hard HEAD^

   

3. 如果我们想撤消提交并从阶段中删除更改，我们可以使用

   git reset --mixed HEAD^或短形式git reset HEAD^

   

我找到了这个站点，它描述了如何撤消您提交到存储库中的内容。

一些命令：

git commit --amend        # Change last commitgit reset HEAD~1 --soft   # Undo last commit

使用此命令：

git checkout -b old-state number_commit

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

First of all what is HEAD?

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

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

detached HEAD

如果您不在最新的提交上-这意味着HEAD指向历史上的先前提交，则称为#1。

在命令行上，它看起来像this-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 commitgit checkout -b <branch name>

git reflog

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

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

git refloggit checkout HEAD@{...}

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

git reset --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 stashgit reset --hard 0d1d7fc32git 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。

git revert <sha-1>

"撤消"给定的提交或提交范围。
重置命令将“撤消”在给定提交中所做的任何更改。
将提交带有撤消补丁的新提交，而原始提交也将保留在历史记录中。

# add new commit with the undo of the original one.# the <sha-1> can be any commit(s) or commit rangegit revert <sha-1>

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

如果您想消除您应该做的错误文件

git reset --soft <your_last_good_commit_hash_here>在这里，如果您执行git status，您将在暂存区域中看到文件。您可以选择错误的文件并将它们从暂存区域中删除。

像下面这样。

git reset wrongFile1 wrongFile2 wrongFile3

您现在只需添加需要推送的文件，

git add goodFile1 goodFile2

把他们交出来

git commit -v或git commit -am "Message"

然后推

git push origin master

但是，如果您不关心更改的文件，您可以硬重置为以前的良好提交并将所有内容推送到服务器。

由

git reset --hard <your_last_good_commit_hash_here>

git push origin master

如果您已经将错误的文件发布到服务器，您可以使用--force标志推送到服务器并编辑历史记录。

git push --force origin master

参考：如何在Git中撤消最后一次提交？

如果您安装了Git扩展，您可以轻松撤消/恢复任何提交（您可以从这里下载Git扩展）。

打开Git扩展，右键单击要恢复的提交，然后选择“恢复提交”。

将打开一个弹出窗口（见下面的屏幕截图）

如果您想直接提交已恢复的更改，或者如果您想手动提交已恢复的更改，请选择“自动创建提交”，保持该框未选中，然后单击“恢复此提交”按钮。

假设您在本地进行了错误的提交并将其推送到远程存储库。您可以使用以下两个命令撤销混乱：

首先，我们需要通过返回我们想要的提交来纠正我们的本地存储库：

git reset --hard <previous good commit id where you want the local repository  to go>

现在我们通过使用以下命令在远程存储库上强制推送这个好的提交：

git push --force-with-lease

强制选项的“带租赁”版本将防止意外删除您不知道的新提交（即自上次拉取以来来自另一个来源）。

通过查看日志找到最后一次提交哈希代码：

git log

然后

git reset <the previous co>

在IntelliJ IDEA中，您只需按Alt+9打开Git存储库日志，鼠标右键单击提交列表中的某个标记，然后选择："重置当前分支到这里…"。

只需使用git执行下面的命令重置它：

git reset --soft HEAD~1

解释：git reset做了什么，它基本上是reset到任何你想回到的提交，然后如果你把它和--soft键结合起来，它会回去，但保留文件中的更改，所以你回到文件刚刚添加的阶段，HEAD是分支的头部，如果你和~1结合（在这种情况下你也使用HEAD^），它只会返回一个你想要的提交…

我在下面的图片中为您创建了更详细的步骤，包括在实际情况下可能发生的所有步骤并提交代码：

为了完整起见，我将给出一个明显的方法，这个方法被前面的答案忽略了。

由于提交没有被推送，远程没有改变，所以：

1. 删除本地存储库。
2. 克隆远程存储库。

这有时是必要的，如果你的花哨的Git客户端去再见（看着你， egit）。

不要忘记重新提交自上次推送以来的保存更改。

头：

在重置提交之前，我们应该了解HEAD…HEAD只是您在工作目录中的当前状态。它由提交编号表示。

执行提交

在一个由唯一标签表示的提交下分配的每个更改。提交不能被删除。所以如果你想要你的最后一次提交，你可以简单地使用git reset潜入它。

你可以使用两种方法深入到最后一次提交：

方法一：（如果您不知道提交号，但想移动到第一个）

git reset HEAD~1  # It will move your head to last commit

方法二：（如果你知道提交，你只需重置你已知的提交）

git reset 0xab3#提交编号

备注：如果你想知道最近的提交尝试git log -p -1

以下是图形表示：

您可以通过两种方式撤消Git提交：首先，如果你想保留你的提交历史，你可以使用git revert：

git revert HEAD~3git revert <hashcode of commit>

其次，您可以使用git reset，它会删除您的所有提交历史记录，并将您的头带到您想要的地方提交。

git reset <hashcode of commit>git reset HEAD~3

您也可以使用--hard关键字，如果它开始表现得不一样。但是，我只会推荐它，直到它是非常必要的。

撤销最后一次提交

有很多情况下，你真的想撤消最后一次提交到你的代码中。例如，因为你想广泛地重组它-甚至完全丢弃它！

在这些情况下，“重置”命令是你最好的朋友：

$ git reset --soft HEAD~1

上面的命令（重置）会将您当前的HEAD分支倒带到指定的版本。在上面的示例中，我们希望返回到当前版本之前的版本-有效地撤消我们的最后一次提交。

注意--soft标志：这确保保留未完成修订中的更改。运行命令后，您会在工作副本中找到未提交的本地修改。

如果您不想保留这些更改，只需使用--hard标志。确保只有在您确定不再需要这些更改时才这样做。

$ git reset --hard HEAD~1

撤消最后一次提交：

git reset --soft HEAD^ or git reset --soft HEAD~

这将撤消最后一次提交。

这里--soft意味着重置到暂存。

HEAD~ or HEAD^表示移动到HEAD之前提交。

将最后一次提交替换为新提交：

git commit --amend -m "message"

它将用新提交替换最后一次提交。

这里是网站：#0。

以下是许多如何在Git中撤消操作的食谱。其中一些：

哦，狗屎，我需要更改我最后一次提交的消息！

git commit --amend# follow prompts to change the commit message

哦，狗屎，我不小心犯了一些主人，应该是一个全新的分支！

# Create a new branch from the current state of mastergit branch some-new-branch-name# Remove the commit from the master branchgit reset HEAD~ --hardgit checkout some-new-branch-name# Your commit lives in this branch now :)

您可以从本地存储库撤消提交。请按照以下方案进行操作。

在下图中，我将“test”分支（使用Git命令git checkout -b test）检查为本地分支，并检查本地分支的状态（使用Git命令git status）是否没有任何可提交的内容。

在下一张图片中，您可以在这里看到我在Filter1.txt中做了一些更改，并将该文件添加到暂存区域，然后使用一些消息提交我的更改（使用Git命令git commit -m "Doing commit to test revert back"）。

"-m用于提交消息"

在下一张图片中，您可以看到您提交的任何内容的提交日志（使用Git命令git log）。

因此，在上图中，您可以看到每个提交的提交ID，以及您的提交消息，现在无论您想恢复或撤消任何提交，都可以复制该提交ID并点击以下Git命令，git revert {"paste your commit id"}.示例：

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

我已经恢复了我的上次提交。现在如果您检查您的Git状态，您可以看到修改后的文件Filter1.txt尚未提交。

试试这个，硬重置到未添加这些文件的上一次提交，然后：

git reset --hard <commit_hash>

确保您有更改的备份以防万一，因为这是一个硬重置，这意味着它们会丢失（除非您之前隐藏）

git push --delete (branch_name) //this will be removing the public version of your branch
git push origin (branch_name) //This will add the previous version back

当您想保持历史记录干净时，重置和删除提交是最好的向公共分支等提出补丁时有用。

如果您必须删除最上面的提交，那么以下一行代码会有所帮助

git rebase --onto HEAD~1 HEAD

但是如果你想放弃你说过的许多提交中的一个

a->b->c->d->master

而你想放弃承诺

git rebase --onto b c

这将使'b'成为'd'消除'c'的新基

git revert commit

这将从您想要恢复的提交中生成相反的更改，然后只需提交该更改。我认为这是最简单的方法。

https://git-scm.com/docs/git-revert

每次我需要撤消提交/提交时我所做的是：

1. git reset HEAD~<n>//我需要撤消的最后一次提交次数

2. git status//可选。所有文件现在都为红色（非暂存）。

3. 现在，我可以添加和提交我需要的文件：

• git add <file names> & git commit -m "message" -m "details"

4. 可选：我可以回滚其余文件的更改，如果我需要，到他们以前的条件，结帐：

• git checkout <filename>

5. 如果我已经把它推到遥远的起源，以前：

• git push origin <branch name> -f//使用-f强制推送。

如果您想撤消存储库中的第一次提交

你会遇到这个问题：

$ git reset HEAD~fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.Use '--' to separate paths from revisions, like this:'git <command> [<revision>...] -- [<file>...]'

发生错误是因为如果最后一次提交是存储库的初始提交（或没有父级），则没有HEAD~。

解决方案

如果您想重置“master”分支上的唯一提交

$ git update-ref -d HEAD$ git rm --cached -r .

如何编辑更早的提交

一般来说，我不想撤消一堆提交，而是编辑一个早期的提交，我希望我一开始就提交了它。

我发现自己经常修复过去的提交，以至于我为它写了一个脚本。

下面是workflow：

1. git提交-编辑<提交-哈希>

   这将把你放在你想要编辑的提交处。

   提交的更改将是联合国阶段，准备好按照您希望的第一次进行。

2. 按照您希望的方式修复和执行提交。

   （您可能希望使用git stash save --keep-index来存储您未提交的任何文件）

3. 使用--amend重做提交，例如：

   git commit --amend

4. Complete the rebase:

   git rebase --continue

Call this following git-commit-edit and put it in your $PATH:

#!/bin/bash
# Do an automatic git rebase --interactive, editing the specified commit# Revert the index and working tree to the point before the commit was staged# https://stackoverflow.com/a/52324605/5353461
set -euo pipefail
script_name=${0##*/}
warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }die () { warn "$@"; exit 1; }
[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"
# Default to editing the parent of the most recent commit# The most recent commit can be edited with `git commit --amend`commit=$(git rev-parse --short "${1:-HEAD~}")
# Be able to show what commit we're editing to the userif git config --get alias.print-commit-1 &>/dev/null; thenmessage=$(git print-commit-1 "$commit")elsemessage=$(git log -1 --format='%h %s' "$commit")fi
if [[ $OSTYPE =~ ^darwin ]]; thensed_inplace=(sed -Ei "")elsesed_inplace=(sed -Ei)fi
export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'git rebase --quiet --interactive --autostash --autosquash "$commit"~git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commitgit commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed
echoecho "Editing commit: $message" >&2echo

使用此命令获取最后一次提交ID（在顶部的日志中，它是最新的）：

git log

获取提交ID（GUID）并运行此命令：

git revert <commit_id>

如果您只是想丢弃所有本地更改/提交，并使您的本地分支看起来像您从…

git reset --hard origin/branch-name

撤消最后一次提交的最简单方法是

git reset HEAD^

这将在您提交之前带来项目状态。

git重置-混合，-软和-硬之间的区别

先决条件：当修改现有文件时在存储库中，此更改最初被认为是未暂存的。为了提交更改，它需要暂存，这意味着使用git add将其添加到索引中。在提交操作期间，暂存的文件将被添加到索引中。

让我们举个例子：

- A - B - C (master)

HEAD指向C，索引匹配C。

--软

• 当我们以删除提交C和将主/头指向B的意图执行git reset --soft B时。
• master/HEAD现在将指向B，但索引仍然从C更改。
• 执行git status时，您可以看到提交C中索引的文件为上演。
• 此时执行git commit将创建一个带有与C相同的变化的新提交

--混合

• 执行git reset --mixed B。
• 在执行时，master/HEAD将指向B和索引也修改为匹配B，因为使用了混合标志。
• 如果我们在这一点上运行git提交，自索引匹配HEAD以来什么都不会发生。
• 我们仍然在工作目录中进行更改，但由于它们不在索引中，git状态显示为未部署。
• 要提交它们，您将git add，然后像往常一样提交。

--硬

• 执行git reset --hard B
• 执行时，master/HEAD将指向B并修改您的工作目录
• C中添加的更改和所有未提交的更改将是删除。
• 工作副本中的文件将与提交B匹配，这将导致永久丢失在提交C中进行的所有更改以及未提交的更改

希望这种对可用于git reset命令的标志的比较将有助于有人明智地使用它们。有关详细信息，请参阅这些Link1和Link2

替换您的本地版本，包括您对服务器版本的更改。这两行代码将强制Git拉取和覆盖本地。

打开命令提示符并导航到Git项目根目录。如果您使用Visual Studio，请单击团队、同步并单击下面的“打开命令提示符”（见图）。

进入Cmd提示符后，继续执行以下两条说明。

git fetch --all

那你就做吧

git reset --hard origin/master

这将用Git服务器上的版本覆盖现有的本地版本。

git reset --soft HEAD~1

重置将把当前HEAD分支倒回指定的版本。

说明--soft标志：这确保保留未完成修订中的更改。运行命令后，您会在工作副本中找到未提交的本地修改。

如果您不想保留这些更改，只需使用--hard标志。请确保仅在您确定不再需要这些更改时才这样做。

 git reset --hard HEAD~1

撤消多个提交

git reset --hard 0ad5a7a6

但是请记住，使用重置命令会撤消您返回的所有提交：

您可以使用git revert <commit-id>。

对于获取提交ID，只需使用git log。

按照以下步骤进行。

步骤1

命中git log

从日志列表中，找到最后一次提交哈希码，然后输入：

步骤2

git reset <hash code>

我在自己遇到同样的问题后写了这篇文章：

如何删除/恢复一个Git提交

基本上你只需要做：

git log，获取SHA哈希的前七个字符，然后执行git revert <sha>，然后执行git push --force。

您也可以通过使用Git恢复命令恢复它，如下所示：git revert <sha> -m -1，然后git push。

为了撤消最后一个本地提交，而不丢弃其更改，我在~/.gitconfig中有这个方便的别名

[alias]undo = reset --soft HEAD^

然后我简单地使用git undo，它非常容易记住。

每个人都以如此复杂的方式评论。

如果您想从分支中删除最后一次提交，最简单的方法是：

git reset --hard HEAD~1

现在要真正推动更改以摆脱您的最后一次提交，您必须

git push --force

就是这样。这将删除你的最后一次提交。

git reset --soft HEAD~1
git status

产出

在主分支上
您的分支领先于“原始/主”1次提交。
（使用“git ush”发布您的本地提交）

要提交的更改：
（使用“git恢复——暂存…”取消暂存）新文件：file1

git log --oneline --graph

产出

• 90f8bb1（HEAD->master）第二次提交\
• 7083e29初始存储库提交\

在这些情况下，“重置”命令是你最好的朋友：

git reset --soft HEAD~1

重置会将当前HEAD分支倒带到指定的修订版。在上面的示例中，我们希望返回到当前修订版之前的版本-有效地撤消我们的最后一次提交。

注意--soft标志：这确保保留未完成修订中的更改。运行命令后，您会在工作副本中找到未提交的本地修改。

如果您不想保留这些更改，只需使用--hard标志。确保只有在您确定不再需要这些更改时才这样做。

git reset --hard HEAD~1

我验证了一个提出的有效方法，这里是一个使用它的具体示例：

如果您想永久撤消/取消上次提交（依此类推，一个接一个，尽可能多）三个步骤：

1：获取你想要到达的提交的id=SHA，当然

$ git log

2：删除您之前的提交

$ git reset --hard 'your SHA'

3：使用-f选项在您的源GitHub上强制执行新的本地历史记录（最后一次提交轨道将从GitHub历史记录中删除）

$ git push origin master -f

示例

$ git log

最后一次提交取消

commit e305d21bdcdc51d623faec631ced72645cca9131 (HEAD -> master, origin/master, origin/HEAD)Author: Christophe <blabla@bla.com>Date:   Thu Jul 30 03:42:26 2020 +0200
U2_30 S45; updating files package.json & yarn.lock for GitHub Web Page from docs/CV_Portfolio...

承诺我们现在想要的

commit 36212a48b0123456789e01a6c174103be9a11e61Author: Christophe <blabla@bla.com>Date:   Thu Jul 30 02:38:01 2020 +0200
First commit, new title

通过删除最后一个来达到之前的提交

$ git reset --hard 36212a4
HEAD is now at 36212a4 First commit, new title

检查是否正常

$ git log
commit 36212a48b0123456789e01a6c174103be9a11e61 (HEAD -> master)Author: Christophe <blabla@bla.com>Date:   Thu Jul 30 02:38:01 2020 +0200
First commit, new title
$ git status
On branch masterYour branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.(use "git pull" to update your local branch)
nothing to commit, working tree clean

在Git（Hub）上更新您的历史记录

$ git push origin master -f
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0To https://github.com/ GitUser bla bla/React-Apps.git+ e305d21...36212a4 master -> master (forced update)

检查是否正常

$ git status
On branch masterYour branch is up to date with 'origin/master'.
nothing to commit, working tree clean

$ git commit -m 'Initial commit'$ git add forgotten_file$ git commit --amend

重要的是要理解，当你修改上一次提交时，与其说是修复它，不如说是用一个新的、改进的提交完全替换它，该提交将旧提交推到一边，并将新提交放在它的位置。实际上，就好像以前的提交从未发生过，它不会出现在你的存储库历史记录中。

修改提交的明显价值是对上次提交进行微小的改进，而不会使您的存储库历史记录与表单的提交消息混乱，“Oops，忘记添加文件”或“Darn，修复上次提交中的错字”。

2.4 Git Basics-撤消的东西

git reset HEAD@{n}将重置您的最后n操作。

对于重置，对于最后一个操作，使用git reset HEAD@{1}。

为了从Git提交中删除一些文件，使用带有“-soft”选项的“git重置”命令并在HEAD之前指定提交。

$ git reset --soft HEAD~1

运行此命令时，您将看到来自最近提交（HEAD）的文件，您将能够提交它们。

现在您的文件位于暂存区域中，您可以再次使用“git重置”命令删除它们（或取消暂存它们）。

$ git reset HEAD <file>

注意：这一次，您正在从HEAD重置，因为您只是想从暂存区域中排除文件

如果您对该文件不再感兴趣，可以使用“git rm”命令从索引（也称为暂存区域）中删除该文件。

$ git rm --cached <file>

当你完成修改后，你可以简单地再次提交你的更改与“修改”选项。

$ git commit --amend

要验证文件是否已从存储库中正确删除，您可以运行“git ls-files”命令并检查该文件是否未出现在文件中（当然如果它是一个新文件）

$ git ls-files
<file1><file2>

使用Git还原从提交中删除文件

从Git 2.23开始，有一种从提交中删除文件的新方法，但您必须确保使用的Git版本大于或等于2.23。

$ git --version

git版本2.24.1

注意：Git 2.23于2019年8月发布，您的计算机上可能还没有此版本。

要安装较新版本的Git，您可以查看本教程。要从提交中删除文件，请使用“git恢复”命令，使用“-source”选项指定源以及要从存储库中删除的文件。

例如，为了从HEAD中删除名为“myfile”的文件，您可以编写以下命令

$ git restore --source=HEAD^ --staged  -- <file>

例如，假设您在“master”分支上的最新提交中编辑了一个文件。

该文件已正确提交，但您想将其从Git存储库中删除。

要从Git存储库中删除您的文件，您首先要恢复它。

$ git restore --source=HEAD^ --staged  -- newfile
$ git status

在分支主

您的分支领先于“原始/主”1次提交。（使用“git ush”发布您的本地提交）

准备提交的变更：

 (use "git restore --staged <file>..." to unstage)modified:   newfile

未为提交暂存的更改：

 (use "git add <file>..." to update what will be committed)(use "git restore <file>..." to discard changes in working directory)modified:   newfile

如您所见，您的文件返回到暂存区域。

从那里，你有两个选择，你可以选择编辑你的文件以便再次提交，或者简单地从你的Git存储库中删除它。

从Git存储库中删除文件

在本节中，我们将描述从Git存储库中删除文件的步骤。

首先，您需要取消暂存您的文件，因为如果它被暂存，您将无法删除它。

要取消暂存文件，请使用“git重置”命令并将HEAD指定为源。

$ git reset HEAD newfile

当您的文件正确取消暂存时，使用“git rm”命令和“-cache”选项，以便从Git索引中删除此文件（这不会删除磁盘上的文件）

$ git rm --cached newfile

新文档rm

现在，如果您检查存储库状态，您将能够看到Git执行了删除提交。

$ git status

在分支主

您的分支领先于“原始/主”1次提交。（使用“git ush”发布您的本地提交）

准备提交的变更：

 (use "git restore --staged <file>..." to unstage)deleted:    newfile

现在您的文件已暂存，只需使用“git提交”和“-修改”选项即可修改存储库中的最新提交。

`$ git commit --amend
[master 90f8bb1] Commit from HEADDate: Fri Dec 20 03:29:50 2019 -05001 file changed, 2 deletions(-)delete mode 100644 newfile

正如你所看到的，这不会创建一个新的提交，但它基本上会修改最近的提交，以便包含你的更改。

从Git提交中删除特定文件

在某些情况下，您不希望所有文件再次暂存：您只能修改存储库中一个非常特定的文件。

为了从Git提交中删除特定文件，使用带有“-soft”选项的“git重置”命令，在HEAD之前指定提交和要删除的文件。

$ git reset HEAD^ -- <file>

完成修改后，您的文件将返回暂存区域。

首先，您可以选择使用“git重置”命令从暂存区域中删除文件，并指定要从HEAD中重置。

$ git reset HEAD <file>

注意：这并不意味着您将丢失对该文件的更改，只是该文件将从暂存区域中删除。

如果您想从索引中完全删除文件，则必须使用带有“-cache”选项的“git rm”命令。

$ git reset HEAD <file>

为了确保您的文件已正确地从暂存区域中删除，请使用“git ls-files”命令列出属于索引的文件。

$ git ls-files

当您完全完成修改后，您可以通过使用带有“-修改”选项的“git提交”命令来修改您删除文件的提交。

$ git commit --amend

我通常首先找到我最近提交的提交哈希：

git log

它看起来像这样：commit {long_hash}

复制此long_hash并重置为它（返回到该提交上的相同文件/状态）：

git reset --hard {insert long_hash without braces}

如果存储库已在本地提交并且尚未推送到服务器，则另一种粗略/外行的解决方法是：

1. Git在另一个位置克隆存储库。
2. 将原始存储库中的修改（文件/目录）复制到这个新存储库中。然后提交并推送新存储库中的更改。
3. 用这个新存储库替换旧存储库。

您可以对不想暂存的文件使用git reset unwanted_file命令。通过使用此命令，我们可以将更改后的文件从暂存区域移动到工作目录。

如何在本地和远程撤销Git中的提交？

Visual Studio Code使这变得非常容易。

#1) $ git commit -m "Something terribly misguided"#2) $ git reset HEAD~

[根据需要编辑文件]

 #3) $ git add .#4) $ git commit -c ORIG_HEAD

如果您想恢复上一次提交，但仍想在本地保留在提交中所做的更改，请使用以下命令：

git reset HEAD~1 --mixed

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

First of all what is HEAD?

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

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

detached HEAD

如果您不在最新的提交上-这意味着HEAD指向历史上的先前提交，则称为#1。

在命令行上，它看起来像这样-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 to 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 commitgit checkout -b <branch name>

git reflog

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

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

git refloggit checkout HEAD@{...}

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

git reset --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 stashgit reset --hard 0d1d7fc32git 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。

git revert <sha-1>

"撤消"给定的提交或提交范围。
重置命令将“撤消”在给定提交中所做的任何更改。
将提交带有撤消补丁的新提交，而原始提交也将保留在历史中。

# Add a new commit with the undo of the original one.# The <sha-1> can be any commit(s) or commit rangegit revert <sha-1>

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

撤销一系列本地提交

OP：如何撤消Git中最近的本地提交？我不小心提交了错误的文件[作为几次提交的一部分]。

启动案例

有几种方法可以将“撤消”作为一系列提交，具体取决于您追求的结果。考虑到下面的开始情况，reset、rebase和filter-branch都可以用来重写您的历史记录。

怎么能C1和C2被撤消以从每次提交中删除tmp.log文件？

在下面的示例中，使用绝对提交引用，但如果您更习惯于相对引用（即HEAD~2或HEAD@{n}），它的工作方式相同。

备选案文1：reset

$ git reset --soft t56pi

使用reset，可以将分支重置为以前的状态，并且将任何复合更改恢复为集结区，然后可以丢弃任何不需要的更改。

备注：由于reset将所有先前的更改聚集到集结区中，单个提交元数据丢失。如果您不同意，那么您可能最好使用rebase或filter-branch。

备选案文2：rebase

$ git rebase --interactive t56pi

使用交互式rebase可以重写分支中的每个违规提交，允许您修改和丢弃不需要的更改。在上面的信息图中，右侧的源树说明了状态帖子rebase。

一步一步

1. 选择rebase应该基于哪个提交（例如t56pi）
2. 通过将pick替换为edit来选择要更改的提交。保存并关闭。
3. Git现在将停止每个选定的提交，允许您重置HEAD、删除不需要的文件并创建全新的提交。

备注：与上面的reset替代方案相比，使用rebase保留了大部分提交元数据。如果您想保留大部分历史记录但仅删除不需要的文件，这很可能是首选选项。

备选案文3：filter-branch

$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD

上面的命令将从所需范围t56pi..HEAD中的所有提交中过滤掉文件./tmp.log（假设我们从上面开始的初始情况）。为了清楚起见，请参阅下面的插图。

与rebase类似，filter-branch可用于从分支的子部分擦除不需要的文件。filter-branch可以自动对每次提交预制所需的操作，而不是通过rebase过程手动编辑每个提交。

备注：就像rebase一样，filter-branch将保留其余的提交元数据，只丢弃所需的文件。请注意C1和C2是如何重写的，以及每次提交中丢弃的日志文件。

结论

就像任何与软件开发相关的事情一样，对于给定问题，有多种方法可以获得相同（或类似）的结果。您只需要选择最适合您特定情况的一种。

最后，一个友好的建议

请注意，上述所有三个替代方案都完全重写了历史记录。除非你确切地知道自己在做什么，并且与团队内部有良好的沟通，否则只重写尚未远程发布的提交！

来源：上面的所有示例都借用了这个博客。

如果您想重新检查最后一次提交并删除日志历史记录

使用下面的命令假设您想转到具有提交ID SHA-71 e 2 e 57458 b de 883 a 37 b 332035 f 784 c 6653 ec 509的上一个提交您可以指向此提交，它将不会在此提交后显示任何日志消息，并且在此之后所有历史记录都将被删除。

git推送来源+71e2e57458bde883a37b332035f784c6653ec509^： master

git reset --soft HEAD~1

软：这将仅从本地删除提交，并保持在文件中完成的更改原样。

    git reset --hard HEAD~1git push origin master

硬：这将从本地和远程删除该提交，并删除在文件中完成的更改。

如果你做了你不喜欢的本地提交，并且它们还没有被推送，你可以将事情重置回以前的好提交。就好像坏提交从未发生过一样。以下是方法：

在您的终端（终端、Git Bash或Windows命令提示符）中，导航到Git存储库的文件夹。运行git state并确保您有一个干净的工作树。每个提交都有一个唯一的哈希（看起来像2f5451f）。你需要找到最后一个好的提交（你想恢复回的那个）的哈希。这里有两个地方可以看到提交的哈希：在GitHub或比特桶或网站上的提交历史记录中。在您的终端（终端、Git Bash或Windows命令提示符）中运行命令git log--Online一旦你知道最后一个好的提交的哈希值（你想恢复到的那个），运行以下命令（用你提交的哈希替换2f5451f）：

git reset 2f5451fgit reset --hard 2f5451f

注：如果你做git重置，提交将被删除，但更改将显示为未提交，让你可以访问代码。这是最安全的选择，因为也许你想要一些代码，你现在可以进行更改和新的提交，这些都很好。通常，你会想撤消提交并丢弃代码，这就是git重置--hard所做的。

在Visual Studio中，只需恢复提交，然后将其与自动创建的恢复提交一起推送

到目前为止，git diff+git应用一直是我的团队的最佳选择，它干净且超级简单，不仅适用于最后一次提交