如何撤消 Git 中最近的本地提交？

【问题标题】：How do I undo the most recent local commits in Git?如何撤消 Git 中最近的本地提交？
【发布时间】：2010-10-29 23:12:14
【问题描述】：

我不小心提交了错误的文件到Git，但还没有将提交推送到服务器。

我如何从本地存储库撤消这些提交？

似乎唯一的方法是在某种 GUI 文本编辑器中复制编辑，然后擦除整个本地克隆，然后重新克隆存储库，然后重新应用编辑。然而，

  • 这可能会导致数据丢失。
  • 当只运行了一个意外的git commit 时，很难做到这一点。

有没有更好的办法？

【问题讨论】：

  • 你知道 git 需要什么吗？ git undo，就是这样。然后 git 处理我们这些凡人所犯错误的声誉就消失了。通过在执行任何git 命令之前将当前状态推送到 git 堆栈上来实现。它会影响性能，所以最好添加一个配置标志来决定是否启用它。
  • @YiminRong 这可以通过 Git 的alias 功能来完成：git-scm.com/book/en/v2/Git-Basics-Git-Aliases
  • 对于 VsCode 用户，只需键入 ctrl +shift +G 然后点击三个点，即更多选项，然后点击 undo Last Commit
  • @YiminRong 究竟要撤消什么？有许多非常不同的功能案例，其中“撤消”意味着完全不同的东西。我敢打赌，添加一个新奇特的“魔杖”只会让事情更加混乱。
  • @YiminRong 不买。人们仍然会摸索和撤消不该撤消的事情。但更重要的是，git reflog 已经接近您所描述的内容，但让用户可以更好地控制要（未）做的事情。但是，请不要，“撤消”在任何地方都不起作用，人们会期望实现该功能的许多不同的东西。撤消上次提交？撤消上一个操作？如果最后一个操作是推送，那么撤消的具体方式是（重置并推送）还是（还原并推送）？

标签： git version-control git-commit undo


【解决方案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. 此命令负责撤消。它将撤消您的最后一次提交，同时保持您的工作树（磁盘上文件的状态）保持不变。您需要再次添加它们，然后才能再次提交它们。

  2. 更正工作树文件。

  3. git add 任何您想包含在新提交中的内容。

  4. 提交更改，重复使用旧的提交消息。 reset把老头复制到.git/ORIG_HEAD； commit 和 -c ORIG_HEAD 将打开一个编辑器，该编辑器最初包含来自旧提交的日志消息，并允许您对其进行编辑。如果您不需要编辑消息，可以使用-C 选项。

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

要删除（不恢复）已推送到服务器的提交，需要使用git push origin master --force 重写历史记录。

进一步阅读

How can I move HEAD back to a previous location? (Detached head) & Undo commits

上面的答案将显示git reflog，您可以使用它来确定您希望恢复到的提交的 SHA-1。获得此值后，请使用上述命令序列。

HEAD~ 与 HEAD~1 相同。如果您想取消提交多个提交，文章 What is the HEAD in git? 会很有帮助。

【讨论】：

  • 如果提交到错误的分支，您可以git checkout theRightBranch 进行所有更改阶段。正如我必须做的那样。
  • 如果你在 DOS 下工作，你需要使用git reset --soft HEAD^ 而不是git reset --soft HEAD~1。 ^ 是 DOS 中的延续字符，因此无法正常工作。另外，--soft 是默认值，所以如果你愿意，可以省略它，直接说git reset HEAD~1。
  • zsh 用户可能会得到：zsh: no matches found: HEAD^ - 你需要转义 ^ 即git reset --soft HEAD\^
  • 如果git commit -a 是在-a 应该被忽略时发出的，那么答案是不正确的。在这种情况下，最好不要省略--soft（这将导致--mixed，这是默认值），然后您可以重新存储您打算提交的更改。
  • 如果您已经将更改推送到远程分支，并且如上所示执行 git reset，您将位于远程分支的后面。在这种情况下，最好使用 git revert ，它将添加另一个提交来恢复先前的更改。更多信息here
【解决方案2】：

如果您不知道它是如何工作的，那么撤消提交会有点吓人。但是，如果您确实了解，这实际上非常容易。我将向您展示撤消提交的 4 种不同方式。

选项1：git reset --hard

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

   (F)
A-B-C
    ↑
  master

您想核对提交 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

为了最轻松的操作，您甚至可以撤消您的提交，但保留您的文件和index：

git reset --soft HEAD~1

这不仅让您的文件独立，甚至让您的 index 独立。当您执行git status 时，您会看到索引中的文件和以前一样。事实上，在此命令之后，您可以执行 git commit 并且您将重做您刚刚进行的相同提交。

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

还有一件事：假设您像第一个示例一样销毁了一个提交，然后发现您毕竟需要它？运气不好，对吧？

不，还有 一种方法可以找回它。输入git reflog，你会看到你移动的（部分）提交shas（即哈希）列表。找到你销毁的提交，然后这样做：

git checkout -b someNewBranchName shaYouDestroyed

您现在已经恢复了该提交。提交实际上不会在 Git 中被销毁大约 90 天，因此您通常可以返回并拯救一个您不想摆脱的提交。

【讨论】：

  • 当心！如果您的错误提交是（快进）合并，这可能不会达到您的预期！如果您的头部正在进行合并提交（例如：将分支功能合并到 master 中），git reset --hard~1 会将 master 分支指向功能分支内的最后一次提交。在这种情况下，应该使用特定的提交 ID 而不是相关命令。
  • 请注意HEAD~1 中的数字可以替换为任何正整数，例如HEAD~3。这似乎很明显，但是初学者（像我一样）在运行 git 命令时非常小心，所以他们可能不想冒险自己测试这些东西来搞砸。
  • 遗漏了一个关键点：如果上述提交之前被“推送”到远程，任何“撤消”操作，无论多么简单，都会给其他用户带来巨大的痛苦和痛苦。当他们将来执行“git pull”时，将这个提交保存在他们的本地副本中。因此，如果提交已被“推送”，请改为执行以下操作： git revert git push origin :
  • @FractalSpace，它不会造成“巨大的痛苦和折磨”。在团队中使用 Git 时，我做了一些强制推送。只需要沟通。
  • @Kyralessa 在我的工作场所，搞乱整个团队的工作流程，然后告诉他们如何解决问题不叫“沟通”。 git history re-write 是一种破坏性操作，会导致部分 repo 被丢弃。坚持使用它，而有明确安全的替代品是完全不负责任的。
【解决方案3】：

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

如何撤消本地提交

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

git log
    commit 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 changes
git 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 log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

如需了解更多信息，请查看Git Basics - Undoing Things。

【讨论】：

  • 我发现这个答案最清楚。 git revert HEAD^ 不是前一个，是前一个的前一个。我做到了：git revert HEAD 然后再次推动它工作:)
  • 如果 Git 询问“更多？”当您尝试这些命令时，请在此答案中使用替代语法：stackoverflow.com/a/14204318/823470
  • revert 删除了一些我添加到我的仓库中的文件。谨慎使用！
  • git reset --soft HEAD~1 和 reset --soft HEAD^ 有什么区别？
【解决方案4】：

添加/删除文件以获得所需的内容：

git rm classdir
git add sourcedir

然后修改提交：

git commit --amend

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

请注意，只有在尚未推送时才应该这样做。如果您已推送，那么您只需正常提交修复即可。

【讨论】：

  • 仅供参考：这会删除我的所有文件并且我丢失了更改。
  • UPD：但是，我已经使用 reflog 恢复了它。但收据不适用于初始提交。
  • 使用git rm --cached将文件保留在文件系统中，只从git索引中删除！
【解决方案5】： 
git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

或

git reset --hard HEAD~1

警告：上述命令将永久删除对您要提交的.java 文件（和任何其他文件）的修改。

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

【讨论】：

  • git commit -a -m "" 或 git commit -am "" 自然而然！ :]
  • 另一种使用 stash 的“捷径”；如果您想取消暂存所有内容（撤消 git add），只需 git stash，然后是 git stash pop
【解决方案6】：

更改最后一次提交

替换索引中的文件：

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

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

git commit --amend

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

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

（要更改以前的提交，请使用很棒的 interactive rebase。）

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

恢复提交

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

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

git reset @~N

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

您可以使用以下命令代替修改提交：

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

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

刷新日志

如果你搞砸了，你总是可以使用 reflog 来查找丢弃的提交：

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

【讨论】：

  • 对于那些将来阅读的人 - 请注意 git revert 是一个单独的命令 - 它基本上“重置”单个提交。
【解决方案7】：

使用git revert <commit-id>。

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

【讨论】：

  • 这是什么意思，樱桃选择提交？就我而言，当我编辑文件时，我在错误的分支上。我提交了它然后意识到我在错误的分支。使用“git reset --soft HEAD~1”让我回到提交之前，但现在如果我签出正确的分支，我如何撤消对错误分支中文件的更改，而是进行更改（以相同的名称文件）在正确的分支？
  • 我刚刚使用了git revert commit-id，就像一个魅力。当然，您需要推动您的更改。
  • 我相信那是git cherry-pick <<erroneous-commit-sha>>@astronomerdave。来自，迟到了 2 年的先生。
  • @Kris：使用 rebase 代替cherry-pick。因为它是先进的樱桃采摘
  • 只有当我已经推送我的提交时，我才会使用 revert。否则，重置是更好的选择。不要忘记 revert 会创建一个新的提交，通常这不是目标。
【解决方案8】：

如果您打算完全撤消本地提交，无论您在提交上做了什么更改，如果您对此不担心，只需执行以下命令即可。

git reset --hard HEAD^1

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

git reset --soft HEAD^1

现在您提交的文件进入暂存区。假设如果你想升级文件，因为你需要编辑一些错误的内容，那么执行以下命令

git reset HEAD

现在提交的文件从暂存区进入非暂存区。现在文件已准备好编辑，所以无论您更改什么，您都想编辑并添加它并进行全新/新提交。

More (link broken) (Archived version)

【讨论】：

  • @SMR，在您的示例中，所有内容都仅指向当前 HEAD。头^ = 头^1。以及 HEAD^1 = HEAD~1。当你使用 HEAD~2 时，~ 和 ^ 符号是有区别的。如果您使用 ~2 表示“第一个父母的第一个父母”或“祖父母”。
  • git reset --hard HEAD^1 给我这个错误“致命：不明确的参数'HEAD1'：未知的修订或路径不在工作树中。”
【解决方案9】：

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

【讨论】：

    【解决方案10】：

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

    prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 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>

    【讨论】：

    • 在共享存储库上重写历史通常是一个非常糟糕的主意。我假设您知道自己在做什么，我只是希望未来的读者也知道。
    • 是的，回滚很危险。在推送之前，请确保您的工作副本处于所需状态。推送时，不需要的提交将被永久删除。
    • "就像在现实世界中，如果你想改写历史，你需要一个阴谋：每个人都必须'参与'阴谋（至少每个知道历史的人，即每个人）谁曾从树枝上拉过）。”来源：stackoverflow.com/a/2046748/334451
    【解决方案11】：

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

    选择你想列出多少个提交，然后像这样调用（争取最后三个）

    git rebase -i HEAD~3

    示例列表

    pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

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

    【讨论】：

      【解决方案12】：

      如何修复之前的本地提交

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

      如何撤销之前的本地提交

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

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

      如何撤消公开提交

      执行reverse cherry pick (git-revert) 撤消更改。

      如果您还没有将其他更改拉入您的分支，您可以简单地做...

      git revert --no-edit HEAD

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

      提交历史将分别显示两个提交。

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

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

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

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

      在本地清理你的分支然后重新推送...

      git push origin (branch_name)

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

      【讨论】：

      • 如果您想撤消“--amend”提交，gitk --all $(git reflog | cut -c1-7)& 可能有助于查找以前的修订版。
      • 应该注意的是，如果您在推送到共享存储库之前尝试删除机密信息，则执行还原对您没有帮助，因为该信息仍将保留在以前的历史记录中犯罪。如果您想确保其他人永远不会看到更改，您需要使用git reset
      • 更正远程存储库中的私有分支也可以通过简单的git push origin (branch_name) --force来完成
      【解决方案13】：

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

      提交 id 可以通过以下方式查看：

      git log

      然后你可以这样做：

      git reset --hard <commit_id>

git push origin <branch_name> -f

      【讨论】：

      • 如果不使用“”而只使用“git reset --hard”怎么办？我通常只是想摆脱我尚未提交的最新更新并回到我所做的最新提交，我总是使用“git reset --hard”。
      • @JaimeMontoya 要撤消最新更改，您可以使用 git reset --hard ，但如果您必须硬删除最后“n”次提交，您可以指定一个 SHA
      【解决方案14】：

      如果你已经提交了垃圾但没有推送，

      git reset --soft HEAD~1

      HEAD~1 是 head 之前提交的简写。或者，如果您想重置为，您可以参考散列的 SHA-1。 --soft 选项将删除提交，但它会将所有更改的文件保留为“要提交的更改”，就像 git status 所说的那样。

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

      或

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

      git revert HEAD

      这将创建一个新的提交，它会反转由意外提交引入的所有内容。

      【讨论】：

      • 我是第二种情况，但是当我执行“git revert HEAD”时，它说“错误：提交 [ID] 是一个合并，但没有给出 -m 选项。致命：恢复失败” .有什么建议吗？
      • 可能值得一提的是，您可以使用git log --stat 或git reflog 显示的实际哈希来代替HEAD~1 - 当您需要“撤消”多个提交时很有用。跨度>
      【解决方案15】：

      在SourceTree（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.

      【讨论】：

        【解决方案16】：

        单个命令：

        git reset --soft 'HEAD^'

        撤消上一次本地提交非常有用！

        【讨论】：

        • 我需要用双引号写 git reset --soft "HEAD^"，因为我是从 Windows 命令提示符下写的。
        【解决方案17】：

        只需使用git 执行以下命令即可重置它：

        git reset --soft HEAD~1

        解释：git reset 做了什么，基本上reset 用于您想返回的任何提交，然后如果将其与--soft 键结合使用，它将返回，但保留文件中的更改，以便您回到刚刚添加文件的阶段，HEAD 是分支的负责人，如果您与 ~1 结合使用（在这种情况下，您还使用HEAD^)，它只会返回一个你想要的提交......

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

        【讨论】：

          【解决方案18】：

          如何撤消上一次 Git 提交？

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

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

            git reset --hard HEAD^

          2. 如果您想保留更改：

            git reset --soft HEAD^

          现在检查你的 git 日志。它将显示我们的最后一次提交已被删除。

          【讨论】：

            【解决方案19】：

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

            git reset --hard HEAD^

            “从工作树中清除未知文件”

            git clean

            见 - Git Quick Reference

            注意：此命令将删除您之前的提交，因此请谨慎使用！ git reset --hard 更安全。

            【讨论】：

              【解决方案20】：

              使用 reflog 找到正确的状态

              git reflog

              在重置之前重新记录

              选择正确的reflog（在我的例子中是f3cb6e2）并输入

              git reset --hard f3cb6e2

              之后，repo HEAD 将重置为该 HEADid 重置后记录

              最后reflog如下图所示

              REFLOG FINAL

              【讨论】：

                【解决方案21】：

                第一次运行：

                git reflog

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

                然后做：

                git reset --hard ActionIdFromRefLog

                【讨论】：

                  【解决方案22】：

                  撤消上次提交：

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

                  这将撤消最后一次提交。

                  这里的--soft 表示重置为暂存。

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

                  将上次提交替换为新提交：

                  git commit --amend -m "message"

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

                  【讨论】：

                    【解决方案23】：

                    另一种方式：

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

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

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

                    这将清除本地存储库中当前提交之后的所有提交，但仅针对那个分支。

                    【讨论】：

                      【解决方案24】：

                      输入git log，找到最后一次提交的哈希码，然后输入：

                      git reset <the previous co>

                      【讨论】：

                        【解决方案25】：

                        就我而言，我不小心提交了一些我不想提交的文件。所以我做了以下事情并且成功了：

                        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 验证结果

                        【讨论】：

                          【解决方案26】：

                          简单，在命令行中运行：

                          git reset --soft HEAD~

                          【讨论】：

                            【解决方案27】：

                            主要有两种情况

                            您尚未推送提交

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

                            git rm <pathToFile>

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

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

                            删除文件后，您可以提交，使用 --amend 选项

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

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

                            你已经推送了提交

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

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

                            【讨论】：

                              【解决方案28】：

                              对于本地提交

                              git reset --soft HEAD~1

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

                              git rm --cached <file>

                              对于推送的提交

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

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

                              但我建议您谨慎使用此命令。在 git-filter-branch(1) Manual Page 阅读更多信息。

                              【讨论】：

                                【解决方案29】：

                                要重置为上一个版本，永久删除所有未提交的更改：

                                git reset --hard HEAD~1

                                【讨论】：

                                • 也许您可以在注释/警告中指出他的命令将丢弃提交和工作目录中的更改，而无需进一步询问。
                                • 如果你碰巧这样做了，但并不是所有的都丢失了。请参阅stackoverflow.com/questions/10099258/…、stackoverflow.com/questions/15479501/… 和 stackoverflow.com/questions/7374069/undo-git-reset-hard/7376959。
                                • 使用--soft 将您的更改保留为uncommitted changes、--hard 以完全取消提交并恢复为1。请记住仅对尚未推送的更改执行此类操作。
                                • @Zaz：你是对的；也许我应该澄清一下。只有已添加到索引 (/staged) 或已提交的文件/更改才能恢复。正如您所说，未提交的、未暂存的更改已被git reset --hard 完全抛弃。
                                • 附带说明：每次暂存文件时，git 将其内容存储在其对象数据库中。只有在执行垃圾回收时才会删除存储的内容。因此，可以恢复执行 git reset --hard 时当前未暂存的文件的最后暂存版本（有关更多信息，请参阅上面链接的帖子）。
                                【解决方案30】：

                                使用什么，reset --soft 或 reset --hard？

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

                                如果您不确定要使用什么，请转到 --soft（我使用此约定来记住它——s为了安全起见）。

                                为什么？

                                如果您错误地选择了--hard，您将丢失您以前没有的更改。 如果您错误地选择了--soft，您可以通过应用附加命令来获得与--hard 相同的结果

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

                                完整示例

                                echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

                                感谢@Kyralessa。

                                【讨论】：

                                • 关于差异的非常有用的描述--soft VS --hard atlassian.com/git/tutorials/…
                                • 在--hard 重置时不会真正丢失提交，因为它们将在参考日志中可用 30 天 git reflog。
                                猜你喜欢
                                • 2023-01-03
                                • 2018-09-15
                                相关资源
                                最近更新 更多
                                热门标签
                                Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode