关于GitBash：如何撤消Git中最近的本地提交？


How do I undo the most recent local commits in Git?

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

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

相关讨论

撤消提交和重做

1
2
3
4
5
$ git commit -m"Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)
  • 这是您要撤消的操作。
  • 这会使您的工作树(磁盘上文件的状态)保持不变，但会撤消提交，并使您提交的更改保持未过时(因此，它们在git status中显示为"未提交的更改"，因此您需要在提交之前再次添加它们)。如果您只想对以前的提交添加更多的更改，或者更改提交消息1，那么可以使用git reset --soft HEAD~，这与git reset HEAD~(其中HEAD~与HEAD~1相同)，但保留现有的更改。
  • 对工作树文件进行更正。
  • git add任何你想包括在你的新承诺中的东西。
  • 提交更改，重用旧的提交消息。reset将旧头复制到.git/ORIG_HEAD；commit与-c ORIG_HEAD将打开一个编辑器，该编辑器最初包含来自旧提交的日志消息，并允许您对其进行编辑。如果不需要编辑消息，可以使用-C选项。

    • 但是要注意，如果您对索引添加了任何新的更改，那么使用commit --amend将把它们添加到以前的提交中。

    如果代码已推送到服务器上，并且您有覆盖历史记录(重新设置)的权限，则：

    1
    git push origin master --force

    你也可以看看这个答案：

    如何将头部移回以前的位置？(分离头)

    上面的答案将向您显示git reflog，用于找出您希望恢复的sha-1是什么。找到要撤消的点后，可以使用上述命令序列。

    但是，请注意，如果您在提交消息中犯了错误，则不需要重置为早期提交。更简单的选择是git reset和git commit --amend，它将打开默认的提交消息编辑器，其中预填充了最后一条提交消息。

    相关讨论

    如果你不知道怎么做的话，撤销承诺有点可怕。但如果你真的明白了，那就太容易了。

    假设你有这个，其中c是你的头，(f)是你文件的状态。

    1
    2
    3
    4
       (F)
    A-B-C
        ↑
      master

    你想用核武器攻击C，却再也见不到它了。你这样做：

    1
    git reset --hard HEAD~1

    结果是：

    1
    2
    3
    4
     (F)
    A-B
      ↑
    master

    现在B是头部。因为您使用了--hard，所以您的文件在commit b时会重置为它们的状态。

    啊，但假设commit c不是一场灾难，只是有一点不好。您希望撤消提交，但在执行更好的提交之前，请保留更改进行一些编辑。从这里重新开始，用C作为你的头：

    1
    2
    3
    4
       (F)
    A-B-C
        ↑
      master

    你可以这样做，省去了--hard：

    1
    git reset HEAD~1

    在这种情况下，结果是：

    1
    2
    3
    4
       (F)
    A-B-C
      ↑
    master

    在这两种情况下，head只是指向最新提交的指针。当您执行git reset HEAD~1操作时，您会告诉git将头部指针移回一个commit。但是(除非你使用--hard)你把你的文件保持原样。所以现在，git status显示了您签入C的更改。您没有丢失任何东西！

    最轻的一点是，您甚至可以撤消提交，但保留文件和索引：

    1
    git reset --soft HEAD~1

    这不仅使您的文件单独存在，甚至使您的索引单独存在。当您执行git status操作时，您将看到索引中的文件与以前相同。事实上，在这个命令之后，您可以执行git commit，并且您将重新执行刚才的相同承诺。

    还有一件事：假设您像在第一个示例中那样破坏了一个提交，但后来发现您毕竟需要它？运气不好，对吧？

    不，还是有办法把它弄回来的。键入git reflog，您将看到一个(部分)提交shas(即散列)的列表，您已经在其中移动了。找到你破坏的承诺，然后这样做：

    1
    git checkout -b someNewBranchName shaYouDestroyed

    你现在恢复了承诺。承诺实际上不会在Git中被破坏大约90天，所以你通常可以回去救一个你不想摆脱的人。

    相关讨论

    我花了一段时间才弄明白，所以也许这能帮助某人…

    根据您是否已将提交公开(推送到远程存储库)，有两种方法可以"撤消"上次提交：

    如何撤消本地提交

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

    1
    2
    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之前的提交：

    1
    2
    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将显示我们最后的承诺已被取消。

    如何撤消公开提交

    如果您已经公开了提交，您将希望创建一个新的提交，它将"还原"您在以前提交中所做的更改(当前头)。

    1
    git revert HEAD

    您的更改现在将被还原并准备好提交：

    1
    2
    3
    4
    5
    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基础-撤销操作

    相关讨论

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

    1
    2
    git rm classdir
    git add sourcedir

    然后修改承诺：

    1
    git commit --amend

    前面的错误提交将被编辑以反映新的索引状态——换句话说，它将像您从未犯过错误一样。

    请注意，只有在还没有推的情况下才应该这样做。如果你已经推了，那么你只需要正常地提交一个修复。

    相关讨论

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

    或

    1
    git reset --hard HEAD~1

    警告：上述命令将永久删除您想要提交的对.java文件(以及任何其他文件)的修改。

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

    相关讨论

    更改上一次提交

    替换索引中的文件：

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

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

    1
    git commit --amend

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

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

    (要更改以前的提交，请使用令人敬畏的交互式钢筋网)

    提示？：将*.class添加到gitignore以阻止此情况再次发生。

    恢复提交

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

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

    1
    git reset @~N

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

    因此，您可以使用：

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

    查看git help reset，特别是--soft--mixed和--hard部分，以便更好地了解这一点。

    重新浮起

    如果您搞砸了，您可以始终使用reflog查找已删除的提交：

    1
    2
    3
    4
    5
    6
    $ 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 。

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

    相关讨论

    如果您计划完全撤消本地提交，无论您在提交时做了什么更改，如果您不担心这一点，只需执行以下命令。

    1
    git reset --hard HEAD^1

    (此命令将忽略整个提交，您的更改将完全从本地工作树中丢失)。如果您想撤消提交，但是想要在临时区域中进行更改(在提交之前，就像在git add之后一样)，那么执行以下命令。

    1
    git reset --soft HEAD^1

    现在，您提交的文件进入临时区域。假设您想将文件放在后期，因为您需要编辑一些错误的内容，那么请执行以下命令

    1
    git reset HEAD

    现在已提交的文件将从阶段区域发送到未经保存的区域。现在文件已经准备好编辑了，所以不管您做了什么更改，您都要进行编辑并添加它，并进行一次新的/新的提交。

    更多

    相关讨论

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    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 [email protected]:thecompany/prometheus.git
     + 09a6480...5a74047 master -> master (forced update)
    prompt>
    相关讨论

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

    选择要列出的提交数，然后这样调用(以登记最后三个提交)

    1
    git rebase -i HEAD~3

    样本列表

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

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

    如何修复以前的本地提交

    使用git-gui(或类似工具)执行git commit --amend。从GUI中，您可以添加或删除提交中的单个文件。您还可以修改提交消息。

    如何撤消上一次本地提交

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

    警告：不小心使用git reset是让您的工作副本进入混乱状态的好方法。我建议Git新手尽量避免这样做。

    如何撤消公开提交

    执行反向樱桃拾取(Git Revert)以撤消更改。

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

    1
    git revert --no-edit HEAD

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

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

    高级：更正公共存储库中的私有分支这可能很危险——请确保您有一个分支机构的本地副本。

    另外请注意：如果其他人正在分支机构工作，则不希望执行此操作。

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

    在本地清理你的分支机构然后就可以了…

    1
    git push origin (branch_name)

    在正常情况下，您可能不必担心您的私有分支提交历史是原始的。只需推送后续提交(参见上面的"如何撤消公开提交")，然后进行挤压合并以隐藏历史记录。

    相关讨论

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

    1
    git reset --soft HEAD~1

    HEAD~1 is a shorthand for the commit before head. Alternatively you can refer to the SHA-1 of the hash if you want to reset to. --soft option will delete the commit but it will leave all your changed files"Changes to be committed", as git status would put it.

    If you want to get rid of any changes to tracked files in the working tree since the commit before head use"--hard" instead.

    或

    If you already pushed and someone pulled which is usually my case, you can't use git reset. You can however do a git revert,

    1
    git revert HEAD

    This will create a new commit that reverses everything introduced by the accidental commit.

    相关讨论

    如果要永久撤消它，并且克隆了一些存储库

    提交ID可以通过

    1
    git log

    那你就可以了-

    1
    2
    3
    git reset --hard <commit_id>

    git push origin <branch_name> -f
    相关讨论

    在sourcetree(gui for github)上，您可以右键单击提交并执行"反向提交"。这将撤消您的更改。

    在终端上：

    您也可以使用：

    1
    git revert

    或：

    1
    2
    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.

    单个命令：

    1
    git reset --soft 'HEAD^'

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

    相关讨论

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

    1
    git reset --soft HEAD~1

    解释：git reset所做的，基本上是reset对任何你想回去的承诺，如果你把它和--soft键结合起来，它会回去，但要保留你的文件中的更改，所以你回到刚添加文件的阶段，HEAD是分支的负责人，如果你和~1结合起来(t他的案子你也用了HEAD^，它只会退回一个你想要的承诺…

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

    How to undo the last commits in Git?

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

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

  • 如果不想保留所做的更改：

    1
    git reset --hard HEAD^

  • 如果要保留更改：

    1
    git reset --soft HEAD^

    • 现在检查你的Git日志。它将显示上一次提交已被删除。

    使用reflog查找正确的状态

    1
    git reflog

    reflog before重置前重新记录

    选择正确的reflog(在我的例子中是f3cb6e2)并键入

    1
    git reset --hard f3cb6e2

    之后，回购头将重置为该头ID。reset effect重置后的日志

    最后，反应图如下图所示。

    reflog after最后归还

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

    1
    git reset --hard HEAD^

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

    1
    git clean

    参见-Git快速参考

    注意：此命令将删除以前的提交，因此请小心使用！git reset --hard更安全–

    第一次运行：

    1
    git reflog

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

    然后这样做：

    1
    git reset --hard ActionIdFromRefLog
    撤消上次提交：

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

    这将撤消上一次提交。

    这里，--soft表示重设为分段。

    HEAD~或HEAD^是指移动到头前承诺。

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

    1
    git commit --amend -m"message"

    它将用新提交替换上一次提交。

    另一种方式：

    签出要还原的分支，然后将本地工作副本重置回要成为远程服务器上最新的提交(之后的所有内容都将变为再见)。为此，在SourceTree中，我右键单击并选择"将BranchName重置为此提交"。

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

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

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

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

    1
    git reset <the previous co>

    在我的案例中，我意外地提交了一些我不想提交的文件。所以我做了以下工作：

    1
    2
    3
    4
    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中恢复提交的基本命令是：

    1
    $ git reset --hard <COMMIT -ID>

    或

    1
    $ git reset --hard HEAD~<n>

    commit-id:commit的id

    n:是您要还原的最后提交数

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

    1
    2
    3
    4
    5
    6
    7
    $ **git log --oneline**

    d81d3f1 function to subtract two numbers

    be20eb8 function to add two numbers

    bedgfgg function to mulitply two numbers

    其中d81d3f1和be20eb8是提交ID。

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

    假设您希望恢复最后一次提交"d81d3f1"。以下是两个选项：

    1
    $ git reset --hard d81d3f1

    或

    1
    $ git reset --hard HEAD~1

    假设您要还原提交"be20eb8"：

    1
    $ git reset --hard be20eb8

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

    1
    $ git reset --help
    相关讨论

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

    1
    git reset --soft HEAD~

    主要有两种情况

    你还没有完成任务

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

    1
    git rm <pathToFile>

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

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

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

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

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

    你已经推动了承诺

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

    相反，您必须在不使用--amend的情况下进行提交(请记住关于-amend`：该选项重写上一次提交的历史记录)。

    使用sourcetree(git的图形工具)查看提交和树。您可以通过右键单击直接手动重置它。

    对于本地提交

    1
    git reset --soft HEAD~1

    或者，如果您不确切地记得提交它的位置，那么可以使用

    1
    git rm --cached <file>

    对于强制提交

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

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

    但我建议你小心使用这个命令。在git filter branch(1)手册页了解更多信息。

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

    1
    git reset --hard HEAD~1
    相关讨论

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

    我只是在给@kyralessa的答案加上两分钱：

    如果您不确定要为--soft使用什么(我使用这个约定来记住它——软表示安全)。

    为什么？

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

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

    完整例子

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

    相关讨论

    你可以使用：

    1
    git reset HEAD@{1}

    此命令将删除不带git日志的错误提交。

    相关讨论

    我们有code.txt文件。我们对它做了一些更改并提交。我们可以用三种方法撤消这个提交，但首先您应该知道什么是阶段文件…分阶段文件是准备提交的文件，如果运行git status，此文件将显示为绿色，如果不分阶段提交，则显示为红色：

    enter image description here

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

    enter image description here

    撤消上次提交：

  • 现在，如果我们只想在不做任何其他更改的情况下撤消提交，则可以使用

    git reset --soft HEAD^

    enter image description here

  • 如果我们希望撤消提交及其更改(这很危险，因为您的更改将丢失)，我们可以使用

    git reset --hard HEAD^

    enter image description here

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

    git reset --mixed HEAD^或简称git reset HEAD^。

    enter image description here

    • 通常，你想撤销一个承诺，因为你犯了一个错误，你想改正它——本质上是操作人员问问题时所做的。所以，实际上，您想要重新提交。

    这里的大多数答案都集中在命令行上。虽然命令行是使用Git的最佳方式，但它可能与其他版本控制系统对Git的使用有点不同。

    下面介绍如何使用图形用户界面。如果您安装了Git，那么您已经拥有了遵循这些说明所需的一切。

    注意：我假设你在推行承诺之前意识到承诺是错误的。如果你不知道推是什么意思，那么你可能还没有推。所以请继续按照指示进行。如果您已经推送了错误提交，那么风险最小的方法就是用一个新的提交来跟踪错误提交，这个提交可以修复问题，就像在不允许您重写历史的版本控制系统中那样。

    也就是说，下面是如何使用GUI修复最近的故障提交：

  • 在命令行中导航到您的存储库，并使用git gui启动GUI。
  • 选择"修正上次提交"。您将看到最后一条提交消息、您准备的文件和未准备的文件。
  • 现在，将内容更改为您希望它们的外观，然后单击提交。

    • 撤消上一次提交

    在很多情况下，您确实希望撤消最后一次提交到代码中的操作。例如，因为你想对它进行广泛的重组，甚至完全放弃它！

    在这些情况下，"重置"命令是您最好的朋友：

    1
    $ git reset --soft HEAD~1

    上面的命令(reset)会将当前头部分支倒带到指定的版本。在上面的示例中，我们希望返回到当前修订之前的版本—有效地使最后一次提交撤消。

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

    如果不想保留这些更改，只需使用--hard标志即可。确保只在确定不再需要这些更改时执行此操作。

    1
    $ git reset --hard HEAD~1

    Enter image description here

    相关讨论

    如果您使用的是sourcetree，这将对您有所帮助。

    右键单击提交，然后选择"重置(当前分支)/master到此提交"，最后选择"软"重置。

    Enter image description here

    只需撤消上一次提交：

    1
    git reset --soft HEAD~

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

    1
    git reset --soft HEAD~2

    或撤消以前的任何提交：

    1
    git reset --soft <commitID>

    (您可以使用git reflog获取commitid)

    撤消以前的提交时，请记住使用

    1
    git clean

    更多详细信息可以在docs:git reset中找到。

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

    或者，您可以使用git revert ：当您希望添加另一个回滚更改的提交(但将其保留在项目历史记录中)时，应该使用恢复。

    相关讨论

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

    在提交和推送的同一个分支上，如果键入"git status"，则不会看到任何新的内容，因为您提交和推送了，现在键入：

    git reset --soft HEAD~1

    这将使您的所有更改(文件)返回到阶段区域，现在要将它们返回到您刚才键入的工作目录(Unstage)中：

    1
    git reset FILE

    其中"file"是要再次提交的文件。现在，这个文件应该在工作目录(未分页)中，包含您所做的所有更改。现在，您可以更改到您想要的任何分支，并提交该分支中的更改。希望这能帮助其他犯同样错误的人。当然，您提交的初始分支仍然存在，并且有所有的更改，但是在我的例子中，这是可以的，如果不适合您，您可以寻找方法来恢复该分支中的提交。

    典型的Git循环

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

  • 第一次从远程服务器克隆

    git clone $project

  • 从远程拉取(当我没有挂起的本地提交要推送时)

    git pull

  • 将一个新的本地文件1添加到$to-be-committedu列表中(想象一下$to-be-u-committedu列表意味着staged区域)

    git add $file1

  • 删除错误地将文件2从$添加到"被提交"列表(假设文件2是像步骤3那样添加的，我不想这样做)

    git reset $file2

  • 提交$to-be-committed-list中的文件1

    git commit -m"commit message description"

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

    git pull --rebase

  • 冲突发生时解决先决条件配置合并工具

    git mergetool #resolve merging here, also can manually merge

  • 添加解决冲突的文件，比如file1：

    git add $file1

  • 继续我以前的REBASE命令

    git rebase --continue

  • 正在推送准备就绪并已同步上一次本地提交

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

    • 相关讨论

    撤消上一次提交：

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

    这将撤消上一次提交。

    这里，--soft表示重设为分段。

    HEAD~ or HEAD^是指移动到头前承诺。

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

    1
    git commit --amend -m"message"

    它将用新提交替换上一次提交。

    Visual Studio用户(2015等)

    如果您不能在Visual Studio中同步，因为不允许将其推到"开发"这样的分支，那么在Visual Studio中，还原和重置(硬或软)都不会起作用。

    根据大量投票的答案：

    在项目根目录的命令提示符下使用该命令，可以对任何试图被推送的内容进行核攻击：

    1
    git reset --hard HEAD~1

    备份或压缩文件以防丢失任何工作等…

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

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

    1
    git reset --hard [cc]

    现在，我们使用以下命令在远程存储库上强制执行此良好提交：

    1
    git push --force-with-lease

    强制选项的"with lease"版本将防止意外删除您不知道的新提交(即，自上次请求以来来自另一个源)。

    我从bitbucket那里得到了commit id，然后做了：

    1
    git checkout commitID .

    例子：

    1
    git checkout 7991072 .

    它将它还原为该提交的工作副本。

    你需要做的简单和快速

    1
        git commit --amend

    如果是私人分支机构或

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

    如果是共享或公共分支。

    您有几个选项可以撤消上一次提交。下面是您的一些选项，总结成一个包含代码片段的答案

    首先，您需要确定哪些是您希望放弃的"错误"提交。我们将用git reflog找到它。

    git reflog

    您也可以使用reflog。git reflog将显示更新HEAD的任何更改，并检查所需的reflog条目将HEAD设置回此提交。

    每次修改头部时，reflog中都会有一个新条目。reflog与unix history命令类似，保存在您的机器上。

    1
    2
    3
    4
    git reflog
    git checkout HEAD@{...}
    # or
    git checkout <sha-1>

    使用签出，您可以返回到任何所需的提交，并且可以创建一个分支或Git签出允许您执行的任何其他选项。

    enter image description here

    git reset HEAD --hard

    "移动"你的头回到想要的承诺。git reset将根据您选择的值--hard/--soft/--mixed检查所需的提交内容到您的临时区域和/或工作目录。--hard将使用给定的内容更新阶段区域和工作目录，并将"分离"本地分支上超过此点的任何其他提交。

    如果这些承诺不是任何其他分支的一部分，它们将成为"悬而未决"。"dangle"内容是指本地存储库中有一个不可访问的内容，它不是任何其他分支的一部分，可以由gc删除或将被删除。

    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.

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

    enter image description here

    删除已推送到GitHub的错误提交

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

    请指定要在GitHub中重新设置的最后一个良好提交ID。

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

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

    使用此命令：

    1
    git checkout -b old-state number_commit

    使用此命令

    1
    git checkout -b old-state 0d1d7fc32

    您总是可以执行以前版本的git checkout ，然后用新代码再次提交。

    为了消除最后一次提交、最后2次提交和最后n次提交中的所有更改：

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

    而且，为了在特定的提交之后摆脱任何东西：

    1
    git reset --hard <commit sha>

    例如。，

    1
    git reset --hard 0d12345

    PS:
    1- Be careful, because of"hard" option, it deletes the local changes
    in your repo as well and reverts to the previous mentioned commit. You
    should run this if you are sure you messed up in your last commit(s)
    and would like to go back in time.

    2- Usually 7 letters of"commit sha" is enough, but in bigger
    projects, you may need up to 12 letters to guarantee be unique. You
    also can mention the whole 40 letters sha.

    3- The above commands work in Github for Windows as well.

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

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

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

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

    如果其中任何一个开始出现其他行为，也可以使用--hard关键字。但是，我只会推荐它，直到它是非常必要的。

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

    如果安装了Git扩展，则可以轻松撤消/还原任何提交(您可以从此处下载Git扩展)。

    打开git扩展，右键单击要还原的提交，然后选择"还原提交"。

    Git Extensions screen shot

    将打开一个弹出窗口(请参见下面的屏幕截图)

    Revert commit popup

    如果要直接提交还原的更改，或者要手动提交还原的更改，请选择"自动创建提交"，保持复选框处于未选中状态，然后单击"还原此提交"按钮。

    Git重置的区别--混合，--软，--硬

    Prerequisite: When a modification to an existing file in your
    repository is made, this change is initially considered as unstaged.
    In order to commit the changes, it needs to be staged which means
    adding it to the index using git add. During a commit operation, the
    files that are staged gets added to an index.

    让我们举个例子：

    1
    - A - B - C (master)

    HEAD指向C，指数与C匹配。

    --软

    • 当我们执行git reset --soft B时，意图删除commit c并将master/head指向b。
    • 现在master/head将指向b，但索引仍然从c更改。
    • 在执行git status时，您可以看到在commit c中索引的文件是分阶段的。
    • 此时执行git commit将创建一个新的提交，其更改与c相同。

    --混合

    • 执行git reset --mixed B。
    • 执行时，master/head将指向b，并且由于使用了混合标志，索引也被修改为与b匹配。
    • 如果此时运行git commit，则不会发生任何事情，因为索引与head匹配。
    • 我们在工作目录中仍然有更改，但是由于它们不在索引中，所以git status将它们显示为未分页。
    • 为了承诺他们，你会先承诺(12)，然后像往常一样承诺。

    --硬

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

    希望对可与git reset命令一起使用的标志进行比较，可以帮助人们明智地使用它们。有关链接1和链接2的详细信息，请参阅这些内容

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

    一些命令：

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

    只需使用git reset --hard 重置您的更改并提供新的提交。您也可以使用git checkout -- 。

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

    1
    git reset HEAD^

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

    您可以从本地存储库撤消提交。请遵循以下方案。

    在下图中，我检查了"测试"分支(使用git命令git checkout -b test)作为本地分支，并检查了本地分支(使用git命令git status)的状态(没有要提交的内容)。

    Enter image description here

    在下一幅图像中，您可以在这里看到我在filter1.txt中做了一些更改，并将该文件添加到临时区域，然后用一些消息提交了我的更改(使用git命令git commit -m"Doing commit to test revert back")。

    "-m表示提交消息"

    Enter image description here

    在下一个图像中，您可以看到提交日志，无论您提交了什么(使用git命令git log)。

    Enter image description here

    因此，在上面的图像中，您可以看到每次提交时的提交ID，以及现在的提交消息，无论您希望恢复或撤消复制哪个提交ID，并点击下面的git命令，git revert {"paste your commit id

    这里是网站：Oh shit, git!。

    以下是很多关于如何在Git中撤消操作的方法。他们中的一些人：

    Oh shit, I need to change the message on my last commit!

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

    Oh shit, I accidentally committed something to master that should have been on a brand new branch!

    1
    2
    3
    4
    5
    6
    # Create a new branch from the current state of master
    git branch some-new-branch-name
    # Remove the commit from the master branch
    git reset HEAD~ --hard
    git checkout some-new-branch-name
    # Your commit lives in this branch now :)

    Rebasing and dropping commits are the best when you want to keep the history clean
    useful when proposing patches to a public branch etc.

    If you have to drop the topmost commit then the following one-liner helps

    ZZU1〔8〕

    But if you want to drop 1 of many commits you did say

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

    and you want to drop commit 'c'

    ZZU1〔9〕

    This will make 'b' as the new base of 'd' eliminating 'c'

    在intellij思想中，只需按alt+9，右键单击提交列表中的某个标记，然后选择"将当前分支重置到此处…"，即可打开git存储库日志。

    头：

    在重置提交之前，我们应该知道head…head只是您工作目录中的当前状态。它由一个提交号表示。

    GIT提交：

    在提交下分配的每个更改都由一个唯一的标记表示。无法删除提交。因此，如果您想要最后一次提交，您可以使用git reset进行深入研究。

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

    方法1：(如果您不知道提交编号，但希望转到第一个)

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

    方法2：(如果知道提交，只需重置为已知提交)

    git reset 0xab3承诺号

    注意：如果您想了解最近的提交，请尝试git log -p -1。

    以下是图形表示：

    Enter image description here

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

    由于没有推送提交，所以远程文件是不变的，因此：

  • 删除本地存储库。
  • 克隆远程存储库。

    • 这有时是必要的，如果你喜欢的吉特客户去再见。(如non-fast-forward错误)

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

    通过以下方式查看日志来查找最后一个提交哈希代码：

    1
    git log

    然后

    1
    git reset <the previous co>

    enter image description here

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

    如果你想删除错误的文件，你应该这样做

    git reset --soft 在这里，如果您执行git status，您将看到临时区域中的文件。您可以选择错误的文件，并从临时区域中将其取下。

    比如下面。

    git reset wrongFile1 wrongFile2 wrongFile3

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

    git add goodFile1 goodFile2

    提交他们

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

    推

    git push origin master

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

    通过

    1
    git reset --hard <your_last_good_commit_hash_here>

    git push origin master

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

    git push --force origin master

    Try this, hard reset to previous commit where those files were not added, then:

    ZZU1〔6〕

    Make sure you have a backup of your changes just in case, as it's a hard reset, which means they'll be lost (unless you stashed earlier)

    What i do each time i need to undo a commit/commits are:

  • git reset HEAD~//我需要撤销的最后一次承诺的数目

  • git status//可选。所有文件现在都为红色(未分页)。

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

    • git add & git commit -m"message" -m"details"
  • 可选：如果需要，我可以通过签出将其余文件的更改回滚到以前的条件：
    • git checkout
  • 如果我已经把它推到远程原点，以前：
    • git push origin -f//使用-f强制推。
    • 1
    git reset --soft HEAD~1

    重置会将当前的头分支倒带到指定的版本。注意--soft标志：这可以确保保留未做修订中的更改。运行该命令后，您将在工作副本中找到未提交的本地修改。

    如果不想保留这些更改，只需使用--hard标志。确保只在确定不再需要这些更改时执行此操作。

    1
     git reset --hard HEAD~1

    Undoing Multiple Commits

    1
    git reset --hard 0ad5a7a6

    但是，请记住，使用reset命令将撤消在返回到以下位置之后的所有提交：enter image description here

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

    1
    git log

    获取提交ID(guid)并运行以下命令：

    1
    git revert <commit_id>
    相关讨论

    如果你想撤销回购协议中的第一个承诺

    您将遇到此问题：

    1
    2
    3
    4
    $ 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"分支上的唯一提交

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

    如果您只想废弃所有本地更改/提交，并使本地分支看起来像您从中开始的源分支…

    git reset --hard origin/branch-name

    用服务器版本替换本地版本，包括所做的更改，这两行代码将强制Git提取并覆盖本地版本。打开命令提示并导航到git项目根目录。如果使用vs，请单击team，synch，然后单击下面的"open command prompt"(打开命令提示)(参见图)。

    Visual Studio

    一旦进入命令提示，继续执行以下两个指令。

    1
    git fetch --all

    然后你这样做

    1
    git reset --hard origin/master

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

    如何编辑早期提交

    一般来说，我不想撤消一堆提交，而是编辑一个较早的提交，以实现我希望在第一时间提交它的方式。

    我发现自己经常修改过去的承诺，为此我写了一个脚本。

    以下是工作流程：

  • 1
    git commit-edit <commit-hash>

    这将使您放弃要编辑的提交。

    提交的更改将被取消，准备好按您希望的第一次进行。

  • 按照您希望的方式，首先修复并准备提交。

    (您可能希望使用git stash save --keep-index来保存您未提交的任何文件)

  • 用--amend重新提交，例如：

    1
    git commit --amend

  • 完成钢筋：

    1
    git rebase --continue

    • 在git-commit-edit之后打这个电话，把它放在你的$PATH里：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    #!/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
    '"$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 user
    if git config --get alias.print-commit-1 &>/dev/null; then
      message=$(git print-commit-1"$commit")
    else
      message=$(git log -1 --format='%h %s'"$commit")
    fi

    if [[ $OSTYPE =~ ^darwin ]]; then
      sed_inplace=(sed -Ei"")
    else
      sed_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 commit
    git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

    echo
    echo"Editing commit: $message">&2
    echo
    相关讨论

    ZZU1〔10〕

    This will generate the opposite changes from the commit which you want to revert back, and then just commit that changes. I think this is the simplest way.

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

    ZZU1〔7〕

    对于那些喜欢图形用户界面的人来说，ungit是一个功能齐全的用于Git的图形用户界面，它包括一个"撤消最后一次提交"按钮。