撤消提交和重做

$ 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)

1. 这是您要撤消的内容.
2. 这会使您的工作树(磁盘上的文件状态)保持不变但撤消提交并保留您未提交的更改(因此它们将显示为"未提交的更改" git status,因此您需要添加它们在提交之前再次).如果你只需要添加更多的变化上一次提交,或更改提交信息¹,您可以使用git reset --soft HEAD~替代,这就好比是git reset HEAD~(这里git add是一样的reset),但离开你现有的变化上演.
3. 对工作树文件进行更正.
4. .git/ORIG_HEAD 您想要包含在新提交中的任何内容.
5. 提交更改,重用旧的提交消息.commit将旧头复制到-c ORIG_HEAD; -Cwith commit --amend将打开一个编辑器,该编辑器最初包含来自旧提交的日志消息,并允许您编辑它.如果您不需要编辑邮件,则可以使用该git reflog选项.

但请注意,如果您已对索引添加了任何新更改,则使用git reset它们会将它们添加到您之前的提交中.

如果代码已经推送到您的服务器并且您有权覆盖历史记录(rebase),那么:

git push origin master --force

你也可以看看这个答案:

如何将HEAD移回以前的位置？(独立头)

上面的答案将向您展示git commit --amend哪些用于找出您希望恢复的SHA-1是什么.一旦找到要撤消的点,就可以使用上面解释的命令序列.

¹但是,请注意,如果您在提交消息中犯了错误,则无需重置为先前的提交.更简单的选择是HEAD~(为了更新您之后所做的任何更改),然后HEAD~1打开您的默认提交消息编辑器,预先填充上一次提交消息.

• 如果你在DOS下工作,而不是`git reset --soft HEAD ^`你需要使用`git reset --soft HEAD~1`.^是DOS中的延续字符,因此无法正常工作.另外,`--soft`是默认值,所以你可以省略它,如果你愿意,只需说`git reset HEAD~1`.
• 如果提交是错误的分支,你可以在所有更改阶段"git checkout theRightBranch".正如我必须做的那样.
• zsh用户可能会得到:`zsh:找不到匹配项:HEAD ^` - 你需要转义^ ie`git reset --soft HEAD\^`
• 在较新版本的 git 中，`HEAD~` 可以替换为 `@~`。
• Running the first command gives `fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.`
• I've googled & hit this page about 50 times, and I always chuckle at the first line of code `git commit -m "Something terribly misguided"`
• 如果偶然地说，当应该省略`-a`时发出`git commit -a`，答案是不正确的。在这种情况下，最好不要遗漏`--soft`（这将导致`--mixed`这是默认值），然后您就可以保留要提交的更改。
• @IcyBrk git add是一个命令。`git add [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [-补丁| -p] [-编辑| -e] [-[no-] all | -[no-]忽略删除| [-更新| -u]] [-添加意图| -N] [-刷新] [-忽略错误] [-忽略忽略] [--chmod =（+ |-）x] [-] [<pathspec> ...
• 如果您已经将更改推送到远程分支，并且如上所示执行git reset，则您将位于远程分支后面。在这种情况下，最好使用git revert <commit hash>，它将添加另一个还原先前更改的提交。更多信息[此处]（http://christoph.ruegg.name/blog/git-howto-revert-a-commit-already-pushed-to-a-remote-reposit.html）
• 这几乎是一个全面的答案。万一您的“最后一次提交” ===“您的第一次提交”-重置将什么都不会做，只会抛出致命的消息。在这种情况下，请使用`git update-ref -d HEAD`。
• **zsh** 用户应该 [关闭 globbing](http://bewatermyfriend.org/p/2016/002/) 使用 `noglob git` 来摆脱这种对插入符号 `^` 字符的持续困扰。
• - git reset --hard HEAD~1，将返回一次提交并删除所有 git 知道的文件，但不会删除未跟踪的文件，因为 git 不知道它们。- git reset HEAD~1，将保留当前提交的所有更改，但使它们不被跟踪 - git reset --soft HEAD~1，将保持你提交的文件暂存，未跟踪的文件仍然未被跟踪

如果您不知道它是如何工作的,撤消提交有点可怕.但是如果你理解的话,它实际上非常容易.

假设您有这个,其中C是您的HEAD,(F)是您的文件的状态.

   (F)
A-B-C
?
master

你想要提交C并且永远不会再看到它.你做这个:

git reset --hard HEAD~1

结果是:

 (F)
A-B
?
master

现在B是HEAD.因为您使用过--hard,您的文件将重置为它们在提交B时的状态.

啊,但是假设提交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的变化.你没有丢失任何东西!

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

git reset --soft HEAD~1

这不仅会使您的文件单独存在,甚至会使您的索引单独存在.执行此操作时git status,您将看到索引中的文件与以前一样.事实上,在这个命令之后,你可以做,git commit而你将重做你刚才所做的相同提交.

还有一件事:假设你在第一个例子中销毁了一个提交,但后来发现你需要它呢？运气好,对吗？

不,还有仍办法把它找回来.键入git reflog,你会看到你已经移动过的(部分)提交shas(即散列)的列表.找到你销毁的提交,并执行以下操作:

git checkout -b someNewBranchName shaYouDestroyed

你现在复活了这个提交.提交实际上并没有在Git中被摧毁大约90天,所以你通常可以回去拯救一个你不想甩掉的人.

• 缺少一个关键点:如果所述提交之前被"推送"到远程,任何"撤销"操作,无论多么简单,都会给在本地副本中提交此提交的其他用户带来巨大的痛苦和痛苦,当他们将来做'git pull'时.因此,如果提交已被"推送",请执行以下操作:git revert <bad-commit-sha1-id> git push origin:
• @Kyralessa在我的工作场所,搞乱整个团队的工作流程然后告诉他们如何修复sh*t不称为"沟通".git历史重写是一种破坏性的操作,导致回购的部分被废弃.坚持使用它,同时提供清晰安全的替代品是完全不负责任的.
• 我想要修改一个提交,再也不会看到它了.我用`--hard`你的例子,但我没有意识到我的工作树中所有未经分级的变化也被破坏了!我打算将这些文件作为稍后提交的一部分提交.现在似乎不可能恢复这些文件 - 我甚至尝试了你发布的关于`reflog`的解决方案,但是这并没有恢复以前未停止的更改.
• 谨防!如果您的错误提交是(快进)合并,这可能无法达到预期效果!如果您的头部处于合并提交(例如:合并分支功能进入主控),则`git reset --hard~1`会将主分支指向功能分支内的最后一次提交.在这种情况下,应使用特定的提交ID而不是相对命令.
• @FractalSpace,它不会造成"巨大的痛苦和痛苦".在团队中使用Git时,我做了一些强制推动.所需要的只是沟通.
• [重置揭秘](http://git-scm.com/blog/2011/07/11/reset.html) by Scott Chacon（GitHub CIO，_Pro Git_ 作者）解释和说明了 `git reset` 命令以及如何从下往上移动 HEAD (`--soft`)，更新索引 (`--mixed`，_default_) 并更新工作目录 (`--hard`)。我一直使用 Kyralessa 的答案作为备忘单，但 Scott 的博客文章终于让它点击并坚持下去！
• @Kyralessa：如果我两次执行“ git reset --hard HEAD ^”，状态会转变为“（A）”吗？
• 由于有这么多人支持该答案，因此我提供了以下反馈：编写一组易于阅读且易于执行的说明，以帮助我解决问题。另一个答案有它；这个没有。
• 考虑注意`HEAD~1`中的数字可以替换为任何正整数,例如`HEAD~3`.这看起来很明显,但是初学者(像我一样)在运行git命令时非常小心,所以他们可能不想冒险通过自己测试这些东西搞乱一些事情.
• 有人可以评论“如果你已经推送了提交怎么办？”。这个答案仍然有效，还是让它变得更加困难？
• @espertus,或许可以通过一种方式来看待它:这里有三件事:你的文件,你的索引和你的历史(也就是你的分支指针).假设你在提交C(如上所述).您的文件,索引和分支指针匹配.如果你使用git reset --soft HEAD~1,你的分支指针会回到B,但是你的文件和索引保持在C的版本.如果你使用git reset --mixed HEAD~1,你的分支指针和索引移动回到B,但你的文件保持在C的状态.然后你的文件显示更改,但你的索引没有.git reset --hard HEAD~1将所有三个移回.
• `git reset --hard HEAD~1` 和 `git reset --hard` 之间有什么区别，如果您需要的是简单地删除您在最近一次提交后所做的所有更改？我总是使用`git reset --hard`，它会带我回到我最近的提交。打个比方，我觉得这有点像在不保存更改的情况下关闭应用程序，这样 RAM 内存中的所有内容都将丢失，但保留 ROM 内存中的内容，在这个类比中使用最新提交作为 ROM 内存，以及尚未保存的 RAM 内存中尚未提交的更改。
• Given how many times I've Googled this, I think I need to tattoo `git reset --soft HEAD~1` on the back of my hand.

这花了我一段时间才弄明白,所以也许这会帮助别人......

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

如何撤消本地提交

假设我在本地提交,但现在想删除该提交.

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`然后再次推动它有效:)
• If Git asks you "More?" when you try these commands, use the alternate syntax on this answer: https://stackoverflow.com/a/14204318/823470

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

git rm classdir
git add sourcedir

然后修改提交:

git commit --amend

之前的错误提交将被编辑以反映新的索引状态 - 换句话说,它就像你从未犯过错误一样.

请注意,只有在尚未推送的情况下才应执行此操作.如果你已推,那么你只需要正常提交修复.

• FYI: This removes all my files and I lost changes.
• Use `git rm --cached` to keep the files in the filesystem and only delete them from the git index!

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

要么

git reset --hard HEAD~1

警告:上述命令将永久删除.java您要提交的文件(和任何其他文件)的修改.

在您错误提交之前,hard resetto HEAD-1会将您的工作副本设置为提交状态.

• `git commit -a -m""`或`git commit -am""`自然!:]

要更改上次提交

替换索引中的文件:

git rm --cached *.class
git 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 *.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` 是一个单独的命令 - 它基本上“重置”了一个单一的提交。

使用 git revert <commit-id>

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

• 这意味着什么,樱桃选择提交？在我的情况下,当我编辑文件时,我在错误的分支上.我承诺了,然后意识到我在错误的分支.使用"git reset --soft HEAD~1"让我回到提交之前,但是现在如果我签出了正确的分支,我如何撤消对错误分支中的文件的更改,而是使它们(在同一个命名中)文件)在正确的分支？
• 我相信那将是'git cherry-pick << wrong-commit-sha >>`@astronomerdave.从,差不多2年 - 晚到党.

如果您计划完全撤消本地提交,无论您在提交时做了什么更改,如果您对此没有任何担心,只需执行以下命令即可.

git reset --hard HEAD^1

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

git reset --soft HEAD^1

现在,您提交的文件将进入暂存区域.假设您想要更新文件,因为您需要编辑一些错误的内容,请执行以下命令

git reset HEAD

现在提交的文件从分阶段区域进入未分区区域.现在文件已经可以编辑了,所以无论你改变什么,你都要编辑并添加它并进行新的/新的提交.

更多

• @SMR,在你的例子中,所有都只指向当前的HEAD.HEAD ^ = HEAD ^ 1.和HEAD ^ 1 = HEAD~1一样.使用HEAD~2时,〜和^符号之间存在差异.如果你使用~2表示"第一个父母的第一个父母"或"祖父母".

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

我想在我们的共享存储库中撤消最新的5次提交.我查找了我要回滚的修订版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>

• 在共享存储库上重写历史通常是一个非常糟糕的主意.我假设你知道你在做什么,我只希望未来的读者也这样做.
• "就像在现实世界中一样,如果你想改写历史,你需要一个阴谋:每个人都必须'参与'阴谋(至少每个知道历史的人,即所有曾经离开过分支的人) ".资料来源:http://stackoverflow.com/a/2046748/334451

我更喜欢使用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将删除您删除的任何行的提交.

如何修复以前的本地提交

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

如何撤消先前的本地提交

只需将分支重置为上一个位置(例如,使用gitk或git rebase).然后从保存的副本中重新应用更改.在本地存储库中进行垃圾收集之后,就像从未发生过意外提交一样.要在单个命令中执行所有操作,请使用git reset HEAD~1.

警告:不小心使用git reset是将工作副本置于混乱状态的好方法.我建议Git新手尽可能避免这种情况.

如何撤消公共提交

执行反向樱桃选择(git-revert)以撤消更改.

如果您还没有将其他更改添加到您的分支,您可以简单地...

git revert --no-edit HEAD

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

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

高级:更正公共存储库中的专用分支

这可能很危险 - 请确保您有分支的本地副本以进行重新注册.

另请注意:如果其他人可能正在分支机构工作,您不希望这样做.

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

在当地清理您的分支,然后重新抢购......

git push origin (branch_name)

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

• `gitk --all $(git reflog | cut -c1-7)&`如果要撤消'--amend'提交,可能有助于找到以前的修订版.
• 应该注意的是,如果您在推送到共享存储库之前尝试删除机密信息,那么执行还原操作将无法帮助您,因为该信息仍将位于上一次提交的历史记录中.如果您想确保其他人永远不会看到更改,您需要使用`git reset`

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

提交ID可以通过以下方式查看

git log

然后你可以做 -

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

• @JaimeMontoya要撤消最新更改，可以使用`git reset --hard`，但是如果必须硬删除最后的“ n”个提交，则可以指定一个SHA

如果你犯了垃圾而没有推,

git reset --soft HEAD~1

如果你想在工作树中删除对工作树中跟踪文件的任何更改,那么在头部之前使用" --hard "代替.

要么

git revert HEAD

• 可能值得一提的是，您可以使用由 git log --stat 或 git reflog 显示的实际散列而不是 HEAD~1 ，这在您需要“撤消”多个提交时很有用。

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

一个命令:

git reset --soft 'HEAD^'

它可以很好地撤消上一次本地提交!

• 我需要用双引号写git reset --soft"HEAD ^",因为我是从Windows命令提示符下写的.
• 它应该没有任何引号。

只需使用以下命令重置它git:

git reset --soft HEAD~1

解释:什么git reset,它基本上reset是你要回去的任何提交,然后如果你把它与--soft密钥组合,它会返回,但保留你的文件中的更改,所以你回到舞台该文件刚刚添加,HEAD是分支的负责人,如果你结合~1(在这种情况下你也使用HEAD^),它将只返回一个你想要的提交...

我将在下面的图片中为您创建更多详细信息,包括在实际情况下可能发生的所有步骤并提交代码:

如何撤消上次Git提交？

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

1. git reset --hard HEAD^
   

2. git reset --soft HEAD^
   

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

使用reflog查找正确的状态

git reflog

重置前的REFLOG

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

git reset --hard f3cb6e2

之后,repo HEAD将重置为该HEADid
重置后的日志

最后,reflog如下图所示

REFLOG FINAL

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

git reset --hard HEAD^

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

git clean

看 - Git快速参考

注意:此命令将删除您之前的提交,因此请谨慎使用!git reset --hard更安全 -

第一次运行:

git reflog

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

然后做:

git reset --hard ActionIdFromRefLog

撤消上次提交:

git reset --soft HEAD^ 要么 git reset --soft HEAD~

这将撤消上次提交.

这--soft意味着重置为暂存.

HEAD~或者HEAD^意味着在HEAD之前提交.

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

git commit --amend -m "message"

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

其他方式:

签出要还原的分支,然后将本地工作副本重置回您希望成为远程服务器上最新版本的提交(之后的所有内容将再次发生).为此,在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>

在我的情况下,我不小心提交了一些我不想要的文件.所以我做了以下工作:

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 reset --soft HEAD~

有很多方法可以做到:

Git命令撤消上次提交/先前提交:

警告:如果您不知道自己在做什么,请不要使用--hard.--hard太危险了,它可能会删除你的文件.

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

$ git reset --hard <COMMIT -ID>

要么

$ git reset --hard HEAD~<n>

COMMIT-ID:提交的ID

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

您可以获得提交ID,如下所示:

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

其中d81d3f1和be20eb8是commit id.

现在让我们看一些案例:

假设您要还原最后一次提交'd81d3f1'.这有两个选择:

$ git reset --hard d81d3f1

要么

$ git reset --hard HEAD~1

假设您要还原提交'be20eb8':

$ git reset --hard be20eb8

有关更多详细信息,您可以参考并尝试其他一些命令,以便将头重置为指定状态:

$ git reset --help

• `git reset --hard HEAD~1`是**太危险了**!这不仅仅是'取消最后一次提交',而是将repo完全恢复到之前的提交.因此,您将放弃上次提交中提交的所有更改!

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

要重置为先前的修订,请永久删除所有未提交的更改:

git reset --hard HEAD~1

• 也许你可以在一个注释/警告说他的命令将丢弃提交**和工作目录中的更改**而不再询问任何进一步.
• 使用`--soft`将你的更改保存为`uncommitted changes`,`--hard`来完全修改提交并将其恢复为1.请记住仅对尚未推送的更改执行此类操作.
• 如果碰巧偶然发生这种情况,不是所有情况都会丢失.请参阅http://stackoverflow.com/questions/10099258/how-can-i-recover-a-lost-commit-in-git,http://stackoverflow.com/questions/15479501/git-commit-lost-after -reset-hard-not-found-by-fsck-not-in-reflog和http://stackoverflow.com/questions/7374069/undo-git-reset-hard/7376959.

对于本地提交

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)手册页.

主要有两种情况

你尚未推送提交

如果问题是您提交的额外文件(并且您不希望存储库中存在这些文件),则可以使用它们将其删除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存储库中删除.

你已经推送了提交

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

相反,你必须不进行提交--amend(记住这个关于-amend`:该选项重写最后一次提交的历史记录).

什么用,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` https://www.atlassian.com/git/tutorials/resetting-checking-out-and-reverting/
• 在 `--hard` 重置时不会真正丢失提交，因为它们将在 ref 日志中可用 30 天 `git reflog`。

认为我们有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 reset HEAD@{1}

没有Git日志,此命令将删除错误的提交.

• 或者`git reset @ ~`

通常,你想要撤消一个提交,因为你犯了一个错误而你想修复它 - 基本上就是当他提出问题时OP做了什么.实际上,你真的想要重做提交.

这里的大部分答案都集中在命令行上.虽然命令行是使用Git的最佳方式,但是对于那些来自其他版本控制系统的Git来说,它可能有些陌生.

以下是使用GUI的方法.如果您安装了Git,那么您已经掌握了遵循这些说明所需的一切.

注意:我会假设您在推送之前意识到提交是错误的.如果你不知道什么是推,你可能没有推,所以继续说明.如果您推送了错误的提交,那么风险最小的方法就是使用修复事物的新提交来跟进错误提交,就像在版本控制系统中执行此操作一样,不允许您重写历史记录.

也就是说,这是如何使用GUI修复最近的错误提交:

1. 在命令行上导航到您的存储库并启动gui git gui
2. 选择"修改上次提交".您将看到上次提交的消息,您上传的文件以及您没有的文件.
3. 现在将内容更改为您希望它们的外观,然后单击Commit.

撤消上次提交

在很多情况下,您确实要撤消最后一次提交到代码中.例如,因为你想广泛地重组它 - 甚至完全丢弃它!

在这些情况下,"重置"命令是你最好的朋友:

$ git reset --soft HEAD~1

上面的命令(重置)会将当前的HEAD分支回滚到指定的版本.在上面的示例中,我们希望返回到当前版本之前的版本 - 实际上使我们的上一次提交撤消.

请注意该--soft标志:这可确保保留撤消修订中的更改.运行该命令后,您将在工作副本中找到更改为未提交的本地修改.

如果您不想保留这些更改,只需使用该--hard标志即可.当您确定不再需要这些更改时,请务必执行此操作.

$ git reset --hard HEAD~1

只需撤消上次提交:

git reset --soft HEAD~

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

git reset --soft HEAD~2

或者撤消之前的任何提交:

git reset --soft <commitID>

(你可以使用commitID git reflog)

撤消之前的提交时,请记得使用清理工作区

git clean

更多细节可以在文档中找到:git-reset

如果您正在使用SourceTree,这将对您有所帮助.

右键单击提交,然后选择 " Reset(当前分支)/ master到此提交 ",最后选择 "Soft"reset.

要撤消您使用的本地提交git reset <commit>.此教程也非常有助于向您展示它的工作原理.

或者,您可以使用git revert <commit>:当您要添加另一个回滚更改的提交(但将它们保留在项目历史记录中)时,应使用还原.

撤消上次提交:

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

这将撤消上次提交.

这--soft意味着重置为暂存.

HEAD~ or HEAD^ 意味着在HEAD之前移动到提交.

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

git commit --amend -m "message"

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

在我的情况下,我提交并推送到错误的分支,所以我想要的是让我所有的更改,所以我可以将它们提交到一个新的正确分支,所以我这样做:

在你提交和推送的同一个分支上,如果你输入"git status",你就不会看到任何新东西,因为你提交并推送了,现在输入:

git reset --soft HEAD~1

这将使您在舞台区域中的所有更改(文件)返回,现在将它们返回到您键入的工作目录(unstage):

git reset FILE

其中"文件"是您要再次提交的文件.现在,此FILE应位于工作目录(未分级)中,并且您执行了所有更改.现在,您可以更改为所需的任何分支,并在该分支中提交更改.希望这有助于其他人犯了同样的错误.当然,你提交的初始分支仍然存在所有更改,但在我的情况下,如果它不适合你,你可以寻找在该分支中恢复该提交的方法.

您有几个选项可以撤消上次提交.以下是您的一些选项,总结为带有代码段的单个答案

首先,您需要确定哪些是您希望丢弃的"错误"提交.我们将用HEAD它来找到它.

First of all what is HEAD?

你总是可以使用它HEAD.
HEAD将显示更新的任何更改,git worktree并检出所需的reflog条目将设置HEAD回此提交.

每次修改HEAD时,都会有一个新条目.git/HEAD.
在detached HEAD类似于UNIX的历史命令,并在您的计算机上本地保存.

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

使用结帐,您可以返回任何所需的提交,您可以创建分支或git checkout允许您执行的任何其他选项.

HEAD

"移动"你的头回到所需的提交.
Git reset会根据detached HEAD您选择的值,将所需的提交内容签出到您的临时区域和/或工作目录.HEAD将使用给定内容更新阶段区域和工作目录,并将在本地分支上"分离"超出此点的任何其他提交.

如果这些提交不属于任何其他分支,他们将变得"悬挂".
"悬挂"内容意味着您的本地存储库中存在不可访问的内容,该内容不属于任何其他分支,可以删除或将被删除git checkout.

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

视觉工作室用户(2015年等)

如果您无法在Visual Studio中进行同步,因为您不允许按照我的尝试推送到"开发"之类的分支,在Visual Studio中,无论REVERT还是RESET(硬或软)都可以.

根据TONS OF VOTES的回答:

在项目根目录的命令提示符处使用此命令来查看将尝试推送的任何内容:

git reset --hard HEAD~1

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

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

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

git reset --hard HEAD~1

现在要真正推动该更改以摆脱上次提交，您必须

git push --force

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

• But keep in mind that --hard will completely discard all the changes that were made in the last commit as well as the content of the index.

典型的Git循环

在前面的答案中谈到与Git相关的命令时,我想与所有可能有用的读者分享我的典型Git周期.这是我如何使用Git,

1. git clone $project

2. git pull

3. git add $file1

4. git reset $file2

5. git commit -m "commit message description"

6. git pull --rebase

7. git mergetool #resolve merging here, also can manually merge

8. git add $file1

9. git rebase --continue

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

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

git reset --soft HEAD~1

重置会将您当前的 HEAD 分支倒回到指定的修订版。在我们上面的例子中，我们想返回到当前修订之前的那个——有效地撤销我们最后一次提交。

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

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

git reset --hard HEAD~1

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

首先,我们需要通过回到我们想要的提交来纠正我们的本地存储库:

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

现在,我们使用以下命令在远程存储库上强制推送此良好提交:

git push --force-with-lease

它的'with-lease'版本的force选项可以防止意外删除你不知道的新提交(即自你上次拉动后来自另一个来源).

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

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

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

例如.如果最新的commit id错误,则在上面的git命令中使用分支名称指定先前的commit id.

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

我从中获取了提交ID bitbucket,然后执行了:

git checkout commitID .

例:

git checkout 7991072 .

它将它恢复为该提交的工作副本.

你需要做到轻松快捷

    git commit --amend

如果它是一个私人分支或

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

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

使用此命令

git checkout -b old-state 0d1d7fc32

使用此命令:

git checkout -b old-state number_commit

您可以随时git checkout <SHA code> 使用以前的版本,然后使用新代码再次提交.

为了摆脱上次提交(所有更改),最后2次提交和最后n次提交:

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

并且,在特定提交后摆脱任何东西:

git reset --hard <commit sha>

例如,

git reset --hard 0d12345

2-通常7个字母的"commit sha"就足够了,但在较大的项目中,你可能需要最多12个字母以保证是唯一的.你也可以提到整个40个字母sha.

3-以上命令也适用于Github for Windows.

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

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

其次是你可以使用git reset,这将删除你所有的提交历史记录,并让你的头提交到你想要的地方.

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

--hard如果任何一个关键字开始表现,你也可以使用该关键字.但是,我只会推荐它,直到它非常必要.

git reset --mixed, - soft和--hard之间的区别

我们来举个例子:

- A - B - C (master)

HEAD指向C和索引匹配C.

- 柔软的

• 当我们执行git reset --soft B与打算除去提交Ç和主/ HEAD指向乙.
• 主/ HEAD现在将指向B,但索引仍然从C更改.
• 执行时,git status您可以将提交C中索引的文件视为暂存.
• 此时执行a git commit将创建一个与C相同的更改的新提交

--mixed

• 执行git reset --mixed B.
• 执行时,master/HEAD将指向B,并且由于使用了混合标志 ,索引也会被修改为匹配B.
• 如果我们此时运行git commit,则由于索引与HEAD匹配,所以不会发生任何事情.
• 我们仍然在工作目录中进行了更改,但由于它们不在索引中,因此git status将它们显示为未分级.
• 要提交它们,您可以git add像往常一样提交.

- 硬

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

希望这种可用于git reset命令的标志的比较将有助于某人明智地使用它们.有关详细信息,请参阅这些链接link1和link2

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

$ git reset --soft HEAD~1

运行此命令时，您将看到最近提交 (HEAD) 中的文件，您将能够提交它们。

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

$ git reset HEAD <file>

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

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

$ git rm --cached <file>

完成修改后，只需使用“-amend”选项再次提交更改即可。

$ git commit --amend

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

$ git ls-files
<file1>
<file2>

使用 Git Restore 从提交中删除文件

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

$ git --version

Git 版本 2.24.1

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

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

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

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

举个例子，假设您在“master”分支上最近一次提交中编辑了一个文件。

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

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

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

在分支 'master'

您的分支领先于 'origin/master' 1 次提交。（使用“git push”来发布你的本地提交）

要提交的更改：

 (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 reset”命令并将 HEAD 指定为源。

$ git reset HEAD newfile

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

$ git rm --cached newfile

rm '新文件'

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

$ git status

在分支 'master'

您的分支领先于 'origin/master' 1 次提交。（使用“git push”来发布你的本地提交）

要提交的更改：

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

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

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

`如您所见，这不会创建新的提交，但它实际上会修改最近的提交以包含您的更改。

从 Git 提交中删除特定文件

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

要从 Git 提交中删除特定文件，请使用带有“-soft”选项的“git reset”命令，在 HEAD 之前指定提交以及要删除的文件。

$ git reset HEAD^ -- <file>

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

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

$ git reset HEAD <file>

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

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

$ git reset HEAD <file>

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

$ git ls-files

当您完全完成修改后，您可以使用带有“–amend”选项的“git commit”命令来修改您从中删除文件的提交。

$ git commit --amend

我找到了这个网站,它描述了如何撤消已提交到存储库的内容.

一些命令:

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

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

如果你安装了Git Extensions,你可以轻松撤消/恢复任何提交(你可以从这里下载git扩展).

打开Git Extensions,右键单击要还原的提交,然后选择"Revert commit".

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

如果要直接提交还原的更改,请选择"自动创建提交",或者如果要手动提交已还原的更改,请保持未选中该框,然后单击"还原此提交"按钮.

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

这是网站:Oh shit, git!.

这里有很多食谱如何在Git中撤消.他们中有一些:

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

# 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 :)

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

git reset HEAD^

这将在您提交之前引入项目状态.

git reset --soft HEAD~1

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

请注意该--soft标志：确保已撤消的修订中的更改得以保留。运行该命令后，您将在工作副本中找到未提交的本地修改作为更改。

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

 git reset --hard HEAD~1

git reset --hard 0ad5a7a6

但是请记住，使用reset命令会撤消返回到以下命令之后的所有提交：

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

在下面的图像中,我检查了'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但尚未提交.

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

由于未提交提交,因此远程未更改,因此:

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

如果您喜欢Git客户端再见,这有时是必要的.(例如non-fast-forward错误)

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

头:

在重置提交之前,我们应该知道HEAD ... HEAD只是您工作目录中的当前状态.它由提交号表示.

Git提交:

在提交下分配的每个更改由唯一标记表示.提交无法删除.因此,如果您想要最后一次提交,您可以直接使用它git reset.

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

方法1 🙁如果你不知道提交号,但想要转到第一个)

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

方法2 🙁如果您知道提交,则只需重置为已知提交)

git reset 0xab3 #提交号码

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

这是图形表示:

git reset --soft HEAD~1
git status

输出

要提交的更改：（
使用“git restore --staged ...”取消暂存）新文件：file1

git log --oneline --graph

输出

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

在IntelliJ IDEA中,您可以通过按Alt+ 9,在提交列表中的某个标签处单击鼠标右键来打开Git存储库日志,然后选择:"将当前分支重置为此处...".

当您希望在向公共分支机构等提出补丁时保持历史记录清洁有用时,重新提交和删除提交是最好的.

如果你必须放弃最顶层的提交,那么下面的单行帮助

git rebase --onto HEAD~1 HEAD

但是如果你想丢掉许多提交中的一个,你就说了

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

你想放弃提交'c'

git rebase --onto b c

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

通过查看日志来查找最后一次提交哈希码:

git log

然后

git reset <the previous co>

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

如果您想永久撤消/取消您的最后一次提交（依此类推，一个接一个，您想要多少个）三个步骤：

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

在 HEAD 上提交我们现在想要的

commit 36212a48b0123456789e01a6c174103be9a11e61
Author: 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 master
Your 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 0
To https://github.com/ GitUser bla bla/React-Apps.git
+ e305d21...36212a4 master -> master (forced update)

检查一切正常

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

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

在我自己遇到同样的问题后，我很久以前就写过这个：

如何删除/恢复 Git 提交

基本上你只需要做：

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

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

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

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 reset --hard <commit_hash>

请确保备份您的更改以防万一,因为它是硬复位,这意味着它们会丢失(除非您先前存在)

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

1. git reset HEAD~<n> //我需要撤消的最后提交次数
3. • git add <file names> & git commit -m "message" -m "details"
4. 可选:如果需要,我可以使用checkout将其余文件的更改回滚到之前的状态:
   • git checkout <filename>
5. 如果我已将它推到远程原点,之前:
   • git push origin <branch name> -f //使用-f强制推送.

如果要撤消repo中的第一个提交

你会遇到这个问题:

$ 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 .

如果您只是想删除所有本地更改/提交并使本地分支看起来像您开始的原始分支...

git reset --hard origin/branch-name

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

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

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

git log

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

git revert <commit_id>

用服务器版本替换本地版本（包括所做的更改）。这两行代码将迫使Git拉并覆盖本地。

打开命令提示符，然后导航到Git项目根目录。如果您使用Visual Studio，请单击Team，Sync，然后单击下面的“打开命令提示符”（参见图片）。

在Cmd提示符下，继续执行以下两个说明。

git fetch --all

那你做

git reset --hard origin/master

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

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

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

修改提交的明显价值是对上次提交进行微小改进，而不会用“糟糕，忘记添加文件”或“该死，修复上次提交中的错字”形式的提交消息使存储库历史变得混乱。

2.4 Git 基础 - 撤销操作

最简单的方法是：

$ git reset --soft HEAD~1

根据您需要撤消的次数执行此操作。提交的更改将在最近的更改中，然后您可以向正确的分支左右进行新的提交。

git revert commit

这将从您想要还原的提交中生成相反的更改，然后仅提交更改。我认为这是最简单的方法。

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

如何编辑较早的提交

通常，我不想撤消一堆提交，而是编辑一个更早的提交，使其符合我希望最初提交它的方式。

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

这是工作流程：

1. git commit-edit <commit-hash>
   

   这将使您进入要编辑的提交。

   提交的更改将被取消，可以按您希望的初次进行。

2. （您可能希望使用它git stash save --keep-index来松散所有未提交的文件）

3. git commit --amend
   

4. git rebase --continue
   

致电以下内容git-commit-edit并将其放入您的$PATH：

git commit-edit <commit-hash>

请执行以下步骤。它可能会帮助您。

步骤1

击中 git log

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

第2步

git reset <hash code>

要撤消上一次本地提交，而又不放弃其更改，我在 ~/.gitconfig

[alias]
undo = reset --soft HEAD^

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

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

git log

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

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

git reset --hard {insert long_hash without braces}