我不小心将错误的文件提交给了Git，但还没有将提交推送到服务器。
如何从本地存储库撤消这些提交？
唯一的方法似乎是在某种 GUI 文本编辑器中复制编辑，然后擦除整个本地克隆，然后重新克隆存储库，然后重新应用编辑。然而，
- 这可能会导致数据丢失。
- 当只运行意外时，很难做到这一点
git commit。
有没有更好的办法？
问问题
10675866 次
98 回答
26050
撤消提交并重做
$ 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)
该命令负责撤消。它将撤消您的最后一次提交，同时保持您的工作树（磁盘上文件的状态）不变。您需要再次添加它们，然后才能再次提交它们）。
更正工作树文件。
git add您想包含在新提交中的任何内容。提交更改，重用旧的提交消息。
reset将旧头复制到.git/ORIG_HEAD；commitwith-c ORIG_HEAD将打开一个编辑器，该编辑器最初包含来自旧提交的日志消息，并允许您对其进行编辑。如果您不需要编辑消息，则可以使用该-C选项。
或者，要编辑先前的提交（或只是其提交消息），commit --amend会将当前索引中的更改添加到先前的提交中。
要删除（不恢复）已推送到服务器的提交，需要重写历史记录git push origin master --force。
延伸阅读
上面的答案将向您显示git reflog，您可以使用它来确定您希望恢复到的提交的 SHA-1。获得此值后，请使用上述命令序列。
HEAD~是一样的HEAD~1。文章什么是 git 中的 HEAD？如果您想取消提交多个提交，这很有帮助。
于 2009-05-29T18:13:42.373 回答
11780
如果您不知道它是如何工作的，那么撤消提交有点可怕。但是，如果您确实了解，这实际上非常容易。我将向您展示撤消提交的 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 只是指向最新提交的指针。当你执行 agit 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并且需要取回该代码
还有一件事：假设您像第一个示例一样销毁了一个提交，但后来发现您毕竟需要它？运气不好，对吧？
不行，还是有办法找回来的。键入git reflog，您将看到已移动的（部分）提交shas（即哈希）列表。找到您销毁的提交，然后执行以下操作：
git checkout -b someNewBranchName shaYouDestroyed
您现在已经恢复了该提交。提交实际上不会在 Git 中被销毁大约 90 天，因此您通常可以返回并拯救一个您不想摆脱的提交。
于 2011-07-28T22:22:20.757 回答
2461
有两种方法可以“撤消”您的最后一次提交，具体取决于您是否已经公开提交（推送到远程存储库）：
如何撤消本地提交
假设我在本地提交，但现在我想删除该提交。
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 基础知识 - 撤消操作。
于 2011-06-16T17:27:23.360 回答
1860
添加/删除文件以按照您想要的方式获取内容：
git rm classdir
git add sourcedir
然后修改提交：
git commit --amend
先前的错误提交将被编辑以反映新的索引状态 - 换句话说，就像您从一开始就没有犯过错误一样。
请注意，只有在尚未推送时才应该这样做。如果您已推送，那么您只需正常提交修复即可。
于 2009-05-29T18:16:26.470 回答
1166
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工作副本设置为错误提交之前的提交状态。
于 2009-05-29T18:13:07.773 回答
881
更改最后一次提交
替换索引中的文件：
git rm --cached *.class
git add *.java
然后，如果它是私有分支，请修改提交：
git commit --amend
或者，如果它是共享分支，则进行新的提交：
git commit -m 'Replace .class files with .java files'
（要更改以前的提交，请使用很棒的交互式变基。）
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
于 2010-07-31T09:39:13.780 回答
781
使用git revert <commit-id>.
要获取提交 ID，只需使用git log.
于 2012-05-25T16:04:29.480 回答
632
如果您打算完全撤消本地提交，无论您在提交上做了什么更改，如果您对此不担心，只需执行以下命令。
git reset --hard HEAD^1
（此命令将忽略您的整个提交，并且您的更改将从您的本地工作树中完全丢失）。如果您想撤消您的提交，但您希望在暂存区域中进行更改（在提交之前就像 after 一样git add），请执行以下命令。
git reset --soft HEAD^1
现在您提交的文件进入暂存区。假设如果你想升级文件，因为你需要编辑一些错误的内容，那么执行以下命令
git reset HEAD
现在提交的文件从暂存区进入非暂存区。现在文件已准备好编辑，所以无论您更改什么，您都想编辑并添加它并进行全新/新提交。
于 2013-01-31T07:06:10.373 回答
577
如果您安装了Git Extras，您可以运行git undo以撤消最新的提交。git undo 3将撤消最后三个提交。
于 2011-12-13T10:18:31.987 回答
538
我想撤消我们共享存储库中最近的五个提交。我查找了要回滚到的修订 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>
于 2012-04-06T13:58:52.667 回答
512
我更喜欢使用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 将删除您删除的任何行的提交。
于 2012-10-25T03:41:20.030 回答
480
如何修复之前的本地提交
使用 git-gui（或类似的）来执行git commit --amend. 在 GUI 中，您可以在提交中添加或删除单个文件。您还可以修改提交消息。
如何撤消先前的本地提交
只需将您的分支重置到以前的位置（例如，使用gitkor 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)
在正常情况下，您可能不必担心您的私有分支提交历史是原始的。只需推送后续提交（请参阅上面的“如何撤消公共提交”），然后执行squash-merge以隐藏历史记录。
于 2013-04-23T17:27:45.043 回答
396
如果您想永久撤消它并且您已经克隆了一些存储库。
提交 ID 可以通过以下方式查看：
git log
然后你可以这样做：
git reset --hard <commit_id>
git push origin <branch_name> -f
于 2013-05-17T13:02:13.293 回答
390
如果你犯了垃圾但没有被推送，
git reset --soft HEAD~1
HEAD~1是 head 之前提交的简写。或者，如果您想重置为，您可以参考哈希的SHA-1 。--soft选项将删除提交，但它将保留所有更改的文件“要提交的更改”，就像 git status 所说的那样。
如果您想摆脱自 head 之前的提交以来对工作树中跟踪文件的任何更改，请改用“ --hard ”。
或者
如果你已经推了有人拉了，这通常是我的情况，你不能使用git reset。但是，您可以执行git revert，
git revert HEAD
这将创建一个新的提交，它会反转由意外提交引入的所有内容。
于 2014-09-03T07:15:30.257 回答
335
在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.
于 2013-06-28T10:18:29.890 回答
309
一个命令：
git reset --soft 'HEAD^'
撤消最后一次本地提交非常有用！
于 2014-03-05T13:55:35.533 回答
290
只需使用以下命令重置它git：
git reset --soft HEAD~1
解释：做什么git reset，它基本上reset是你想要返回的任何提交，然后如果你将它与--softkey 结合，它会返回，但将更改保留在你的文件中，所以你回到舞台刚刚添加的文件是HEAD分支的头，如果你结合~1（在这种情况下你也使用HEAD^），它只会返回一个你想要的提交......
我为您更详细地创建了下图中的步骤，包括在实际情况中可能发生的所有步骤并提交代码：
于 2017-06-21T09:33:19.620 回答
268
如何撤消最后一次 Git 提交？
要将所有内容恢复到上次提交之前的状态，我们需要重置为 HEAD 之前的提交。
如果您不想保留所做的更改：
git reset --hard HEAD^如果您想保留更改：
git reset --soft HEAD^
现在检查你的 git 日志。它将显示我们的最后一次提交已被删除。
于 2014-04-23T11:21:20.787 回答
249
“将工作树重置为最后一次提交”
git reset --hard HEAD^
“从工作树中清除未知文件”
git clean
请参阅 - Git 快速参考
注意：此命令将删除您之前的提交，因此请谨慎使用！git reset --hard更安全。
于 2013-10-03T12:43:57.403 回答
215
使用 reflog 找到正确的状态
git reflog
重置前重新记录
选择正确的 reflog（在我的例子中是 f3cb6e2）并输入
git reset --hard f3cb6e2
之后，repo HEAD 将重置为该 HEADid
LOG AFTER RESET
最后 reflog 如下图所示
重新记录决赛
于 2014-01-06T22:34:06.847 回答
189
第一次运行：
git reflog
它将显示您对存储库执行的所有可能操作，例如，提交、合并、拉取等。
然后做：
git reset --hard ActionIdFromRefLog
于 2013-10-11T14:41:16.647 回答
178
撤消上次提交：
git reset --soft HEAD^或者git reset --soft HEAD~
这将撤消最后一次提交。
这里--soft的意思是重置为登台。
HEAD~或HEAD^表示在 HEAD 之前进行提交。
将上次提交替换为新提交：
git commit --amend -m "message"
它将用新的提交替换最后一次提交。
于 2016-03-06T11:53:22.997 回答
175
另一种方式：
签出您要恢复的分支，然后将本地工作副本重置回您希望成为远程服务器上最新的提交（之后的一切都会再见）。为此，在 SourceTree 中，我右键单击并选择“将 BRANCHNAME 重置为此提交”。
然后导航到存储库的本地目录并运行以下命令：
git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME
这将删除本地存储库中当前提交之后的所有提交，但仅针对那个分支。
于 2013-05-13T17:12:25.717 回答
164
键入git log并找到最后一次提交哈希码，然后输入：
git reset <the previous co>
于 2013-05-15T13:12:29.717 回答
159
就我而言，我不小心提交了一些我不想提交的文件。所以我做了以下事情，它奏效了：
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 验证结果
于 2013-07-18T06:41:16.423 回答
153
很简单，在命令行中运行它：
git reset --soft HEAD~
于 2016-01-06T14:10:12.213 回答
142
主要有两种情况
你还没有推送提交
如果问题是您提交的额外文件（并且您不希望这些文件在存储库中），您可以使用删除它们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 的这一点：该选项会重写上次提交的历史记录）。
于 2014-09-12T14:51:01.113 回答
140
对于本地提交
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) 手册页上阅读更多内容。
于 2014-03-04T04:35:18.140 回答
138
要重置到以前的版本，永久删除所有未提交的更改：
git reset --hard HEAD~1
于 2014-08-28T16:03:04.120 回答
138
用什么，reset --soft或者reset --hard？
我只是为@Kyralessa 的回答加两分钱：
如果你不确定要使用什么--soft（我用这个约定来记住它——为了安全起见）。
为什么 ？
如果您--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。
于 2016-07-28T07:24:22.693 回答
137
有很多方法可以做到：
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是提交 ID。
现在让我们看一些案例：
假设您想恢复最后一次提交“d81d3f1”。这里有两个选项：
$ git reset --hard d81d3f1
或者
$ git reset --hard HEAD~1
假设您要恢复提交“be20eb8”：
$ git reset --hard be20eb8
有关更多详细信息，您可以参考并尝试一些其他命令来将 head 重置为指定状态：
$ git reset --help
于 2016-02-18T03:27:38.440 回答
129
使用SourceTree（Git 的图形工具）查看您的提交和树。您可以通过右键单击它直接手动重置它。
于 2013-08-29T16:18:39.390 回答
98
认为我们有code.txt文件。我们对其进行了一些更改并提交。
我们可以通过三种方式撤消此提交，但首先您应该知道暂存文件是什么...暂存文件是准备提交的文件，如果您运行git status此文件，则该文件将显示为绿色，如果未暂存for commit 将显示为红色：
这意味着如果您提交更改，则不会保存您对此文件的更改。您可以将此文件添加到您的阶段，git add code.txt然后提交您的更改：
撤消上次提交：
现在，如果我们只想撤消提交而不进行任何其他更改，我们可以使用
git reset --soft HEAD^
如果我们想撤消提交及其更改（这很危险，因为您的更改将丢失），我们可以使用
git reset --hard HEAD^
如果我们想撤消提交并从阶段删除更改，我们可以使用
git reset --mixed HEAD^或简写形式git reset HEAD^
于 2016-11-18T08:57:39.593 回答
81
通常，您想要撤消提交，因为您犯了一个错误并且您想要修复它 - 本质上是 OP 在他提出问题时所做的。真的，你真的想重做一个提交。
这里的大多数答案都集中在命令行上。虽然命令行是在您熟悉 Git 时使用它的最佳方式，但对于那些从其他版本控制系统到 Git 的人来说，它可能有点陌生。
以下是使用 GUI 执行此操作的方法。如果您安装了 Git，则您已经拥有了遵循这些说明所需的一切。
注意：我在这里假设您在推送之前意识到提交是错误的。如果你不知道推动是什么意思，那么你可能还没有推动。继续按照说明进行。如果你推送了错误的提交，风险最小的方法就是用一个新的提交来修复错误的提交，就像你在不允许你重写历史的版本控制系统中那样。
也就是说，这里是如何使用 GUI 修复最近的错误提交：
- 在命令行上导航到您的存储库并使用以下命令启动 GUI
git gui - 选择“修改上次提交”。你会看到你最后的提交信息，你暂存的文件和你没有暂存的文件。
- 现在将内容更改为您希望它们的外观，然后单击提交。
于 2014-11-18T19:11:08.957 回答
79
您可以使用：
git reset HEAD@{1}
此命令将在没有 Git 日志的情况下删除您的错误提交。
于 2016-06-29T06:28:26.010 回答
75
撤消最后一次提交
在很多情况下，您真的想撤消对代码的最后一次提交。例如，因为您想对其进行广泛的重组——甚至完全放弃它！
在这些情况下，“reset”命令是你最好的朋友：
$ git reset --soft HEAD~1
上面的命令（reset）会将你当前的 HEAD 分支倒回到指定的版本。在上面的示例中，我们希望返回到当前版本之前的版本——有效地使我们的最后一次提交撤消。
注意--soft标志：这确保保留未完成的修订中的更改。运行命令后，您会在工作副本中发现更改为未提交的本地修改。
如果您不想保留这些更改，只需使用--hard标志。确保仅在确定不再需要这些更改时才执行此操作。
$ git reset --hard HEAD~1
于 2017-09-14T04:33:52.033 回答
68
在回答之前，让我们添加一些背景知识，解释一下这是什么HEAD。
First of all what is HEAD?
HEAD只是对当前分支上的当前提交（最新）的引用。
在任何给定时间只能有一个HEAD。（不包括git worktree）
的内容HEAD存储在里面.git/HEAD，它包含当前提交的 40 字节 SHA-1。
detached HEAD
如果您不在最新提交上 - 意思HEAD是指向历史上的先前提交，则称为detached HEAD.
在命令行上，它看起来像这样 - 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 commit
git checkout -b <branch name>
git reflog
您也可以随时使用reflog。
git reflog将显示更新的任何更改，HEAD并检查所需的 reflog 条目将设置HEAD回此提交。
每次修改 HEAD 都会在reflog
git reflog
git checkout HEAD@{...}
这将使您回到所需的提交
git reset --hard <commit_id>
将您的 HEAD “移动”回所需的提交。
# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32
# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts if you've modified things which were
# changed since the commit you reset to.
- 注意：（从 Git 2.7 开始）
你也可以使用git rebase --no-autostash。
git revert <sha-1>
“撤消”给定的提交或提交范围。
重置命令将“撤消”在给定提交中所做的任何更改。
将提交带有撤消补丁的新提交，而原始提交也将保留在历史记录中。
# add new commit with the undo of the original one.
# the <sha-1> can be any commit(s) or commit range
git revert <sha-1>
这个模式说明了哪个命令做什么。
如您所见，reset && checkout修改HEAD.
于 2017-01-28T00:10:13.057 回答
67
只需撤消最后一次提交：
git reset --soft HEAD~
或者撤销上次提交前的时间：
git reset --soft HEAD~2
或撤消任何先前的提交：
git reset --soft <commitID>
（您可以使用 获取 commitID git reflog）
当您撤消先前的提交时，请记住使用
git clean
更多细节可以在文档中找到：git-reset
于 2015-05-08T08:04:23.427 回答
65
如果您想恢复最后一次提交，但仍想在本地保留在提交中所做的更改，请使用以下命令：
git reset HEAD~1 --mixed
于 2021-08-18T12:35:37.170 回答
64
撤消最后一次提交：
git reset --soft HEAD^ or git reset --soft HEAD~
这将撤消最后一次提交。
这里--soft的意思是重置为登台。
HEAD~ or HEAD^表示在 HEAD 之前移动到提交。
将上次提交替换为新提交：
git commit --amend -m "message"
它将用新的提交替换最后一次提交。
于 2018-02-15T07:08:15.987 回答
61
就我而言，我提交并推送到了错误的分支，所以我想要恢复所有更改，以便我可以将它们提交到新的正确分支，所以我这样做了：
在您提交和推送的同一个分支上，如果您输入“git status”，您将看不到任何新内容，因为您已提交和推送，现在输入：
git reset --soft HEAD~1
这将使您的所有更改（文件）回到舞台区域，现在要将它们恢复到工作目录（unstage）中，您只需键入：
git reset FILE
其中“文件”是您要再次提交的文件。现在，这个 FILE 应该在工作目录中（未暂存），其中包含您所做的所有更改。现在您可以更改到您想要的任何分支并在该分支中提交更改。当然，您提交的初始分支仍然存在所有更改，但在我的情况下没关系，如果它不适合您 - 您可以寻找在该分支中恢复该提交的方法。
于 2015-08-11T14:11:14.850 回答
61
如果您正在使用SourceTree，这将对您有所帮助。
右键单击提交，然后选择“ Reset (current branch)/master to this commit ”，最后选择 “Soft”reset。
于 2016-07-29T10:14:28.000 回答
58
假设您在本地进行了错误的提交并将其推送到远程存储库。您可以使用以下两个命令撤消混乱：
首先，我们需要通过返回到我们想要的提交来更正我们的本地存储库：
git reset --hard <previous good commit id where you want the local repository to go>
现在我们使用以下命令将这个好的提交强制推送到远程存储库：
git push --force-with-lease
force 选项的“with-lease”版本将防止意外删除您不知道的新提交（即自上次拉取后来自另一个来源）。
于 2017-05-07T01:01:06.270 回答
51
视觉工作室用户（2015 年等）
如果您无法在 Visual Studio 中同步，因为您不允许推送到像“开发”这样的分支，那么正如我所尝试的那样，在 Visual Studio 中，REVERT或RESET（硬或软）都不会起作用。
根据大量投票的答案：
在项目根目录的命令提示符下使用它来消除任何试图被推送的东西：
git reset --hard HEAD~1
备份或压缩文件以防万一您不希望丢失任何工作等...
于 2016-04-26T21:35:53.467 回答
50
一个典型的 Git 循环
在谈到之前答案中与 Git 相关的命令时，我想与所有可能有帮助的读者分享我的典型 Git 周期。这是我使用 Git 的方式，
第一次从远程服务器克隆
git clone $project从远程拉取（当我没有待推的本地提交时）
git pull将新的本地文件 1 添加到 $to_be_committed_list 中（想象一下 $to_be_committed_list 表示
staged区域）git add $file1从 $to_be_committed_list 中删除错误添加的 file2 （假设 file2 像第 3 步一样添加，这是我不想要的）
git reset $file2提交 $to_be_committed_list 中的 file1
git commit -m "commit message description"在推送之前将本地提交与远程存储库同步
git pull --rebase解决发生冲突时的先决条件配置合并工具
git mergetool #resolve merging here, also can manually merge添加解决冲突的文件，假设
file1：git add $file1继续我之前的变基命令
git rebase --continue推送就绪且已同步的最后一次本地提交
git push origin head:refs/for/$branch # branch = master, dev, etc.
于 2015-12-31T14:34:25.867 回答
50
每个人都以如此复杂的方式发表评论。
如果要从分支中删除最后一次提交，最简单的方法是：
git reset --hard HEAD~1
现在要真正推动该更改以摆脱您的最后一次提交，您必须
git push --force
就是这样。这将删除您的最后一次提交。
于 2020-01-07T00:26:01.780 回答
48
在这些情况下，“reset”命令是你最好的朋友：
git reset --soft HEAD~1
重置会将您当前的 HEAD 分支倒回到指定的修订版。在上面的示例中，我们希望返回到当前版本之前的版本——有效地使我们的最后一次提交撤消。
请注意 --soft 标志：这可确保保留未完成的修订中的更改。运行命令后，您会在工作副本中发现更改为未提交的本地修改。
如果您不想保留这些更改，只需使用 --hard 标志。确保仅在确定不再需要这些更改时才执行此操作。
git reset --hard HEAD~1
于 2020-06-17T09:32:22.430 回答
45
删除已经推送到 Github 的错误提交
git push origin +(previous good commit id):(branch name)
请指定您想在 Github 中重置的最后一个良好的提交 ID。
例如。如果最新的提交 ID 错误，则在上面的 git 命令中使用分支名称指定上一个提交 ID。
您可以使用获取先前的提交 IDgit log
于 2015-12-04T17:20:50.603 回答
41
为了摆脱（所有更改）最后一次提交、最后 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
小心使用 hard 选项：它也会删除你的 repo 中的本地更改并恢复到前面提到的提交。仅当您确定自己在上次提交中搞砸了并且想及时返回时，才应该运行此命令。
附带说明一下，提交哈希的大约 7 个字母就足够了，但在更大的项目中，您可能需要多达 12 个字母才能使其唯一。如果您愿意，也可以使用整个提交 SHA。
上述命令也适用于 Windows 的 GitHub。
于 2016-11-06T03:38:42.360 回答
40
我从那里得到了提交 ID bitbucket，然后做了：
git checkout commitID .
例子：
git checkout 7991072 .
并将其恢复为该提交的工作副本。
于 2016-03-16T15:41:50.260 回答
38
你需要做的简单快速
git commit --amend
如果它是私人分支机构或
git commit -m 'Replace .class files with .java files'
如果它是共享或公共分支。
于 2015-05-24T21:09:04.653 回答
33
执行以下步骤。
步骤1
打git log
从日志列表中，找到最后一次提交的哈希码，然后输入：
第2步
git reset <hash code>
于 2019-07-05T06:26:14.553 回答
32
使用此命令
git checkout -b old-state 0d1d7fc32
于 2015-07-06T08:30:20.303 回答
31
使用这个命令：
git checkout -b old-state number_commit
于 2016-12-27T18:42:51.433 回答
30
您始终可以执行git checkout <SHA code> 以前的版本，然后使用新代码再次提交。
于 2015-12-10T07:17:15.357 回答
29
您可以通过两种方式撤消 Git 提交：首先，您可以使用git revert，如果您想保留提交历史记录：
git revert HEAD~3
git revert <hashcode of commit>
其次是你可以使用git reset，它会删除你所有的提交历史并把你的头带到你想要的地方。
git reset <hashcode of commit>
git reset HEAD~3
--hard如果其中任何一个开始表现不同，您也可以使用该关键字。但是，我只会推荐它，直到它非常必要。
于 2017-08-02T08:58:34.197 回答
29
git reset --soft HEAD~1
重置会将您当前的 HEAD 分支倒回到指定的修订版。
注意标志：这确保保留未完成的--soft修订中的更改。运行命令后，您会在工作副本中发现更改为未提交的本地修改。
如果您不想保留这些更改，只需使用--hard标志。确保仅在确定不再需要这些更改时才执行此操作。
git reset --hard HEAD~1
撤消多个提交
git reset --hard 0ad5a7a6
但是请记住，使用 reset 命令会撤消您返回到的提交之后的所有提交：
于 2019-03-11T07:19:44.820 回答
26
我发现这个站点描述了如何撤消您已提交到存储库中的内容。
一些命令：
git commit --amend # Change last commit
git reset HEAD~1 --soft # Undo last commit
于 2016-12-15T16:21:28.530 回答
26
您可以从本地存储库撤消提交。请遵循以下场景。
在下图中，我检查了“测试”分支（使用 Git 命令git checkout -b test）作为本地分支，并检查git status本地分支的状态（使用 Git 命令）是否没有要提交的内容。
在下一张图片中，您可以在这里看到我在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尚未提交。
于 2018-03-06T12:26:13.547 回答
26
git reset --mixed、--soft 和--hard 的区别
先决条件：对存储库中的现有文件进行修改时，此更改最初被视为未暂存。为了提交更改，它需要暂存，这意味着使用
git add. 在提交操作期间，暂存的文件被添加到索引中。
举个例子：
- A - B - C (master)
HEAD指向C和索引匹配C。
- 柔软的
- 当我们执行删除提交 C并将master/HEAD 指向 B
git reset --soft B的意图时。 - master/HEAD 现在将指向 B，但索引仍然从 C 更改。
- 执行时
git status，您可以看到在提交 C中索引的文件为staged。 - 此时执行 a将创建一个与C 具有相同更改
git commit的新提交
--混合
- 执行
git reset --mixed B。 - 在执行时，master/HEAD 将指向 B，并且由于使用了混合标志 ，索引也被修改以匹配 B。
- 如果我们此时运行 git commit ，则不会发生任何事情，因为索引匹配 HEAD。
- 我们仍然在工作目录中有更改，但由于它们不在索引中，git status 将它们显示为 unstaged。
- 要提交它们，您需要
git add然后像往常一样提交。
- 难的
- 执行
git reset --hard B - 执行时，master/HEAD 将指向 B并修改您的工作目录
- 在 C 中添加的更改和所有未提交的更改将被删除。
- 工作副本中的文件将匹配提交 B，这将导致永久丢失提交 C 中所做的所有更改以及未提交的更改
于 2018-12-21T02:02:27.650 回答
26
这里是网站：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 :)
于 2018-02-28T08:34:58.993 回答
25
撤消最后一次提交的最简单方法是
git reset HEAD^
这将在您提交之前带来项目状态。
于 2018-12-10T07:05:41.613 回答
24
为了从 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 还原从提交中删除文件
从 Git 2.23 开始，有一种从提交中删除文件的新方法，但您必须确保您使用的 Git 版本大于或等于 2.23。
$ 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
在分支“主人”上
您的分支领先于 '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
在分支“主人”上
您的分支领先于 '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
于 2020-11-22T13:38:12.297 回答
22
头：
在重置提交之前，我们应该了解 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
这是图形表示：
于 2017-07-18T11:05:17.500 回答
22
为了完整起见，我将给出一个明显被先前答案忽略的方法。
由于未推送提交，因此远程未更改，因此：
- 删除本地存储库。
- 克隆远程存储库。
如果您喜欢 Git 客户端再见，这有时是必要的。（例如non-fast-forward错误）
不要忘记重新提交自上次推送以来保存的更改。
于 2017-06-27T21:34:27.600 回答
22
如果您安装了 Git 扩展，您可以轻松撤消/恢复任何提交（您可以从此处下载 Git 扩展）。
打开 Git Extensions，右键单击要还原的提交，然后选择“还原提交”。
将打开一个弹出窗口（请参见下面的屏幕截图）
如果您想直接提交恢复的更改，或者如果您想手动提交恢复的更改，请选择“自动创建提交”，保持未选中该框并单击“恢复此提交”按钮。
于 2017-03-30T20:56:59.483 回答
21
只需用于git reset --hard <last good SHA>重置您的更改并提供新的提交。您也可以使用git checkout -- <bad filename>.
于 2016-05-29T14:21:17.433 回答
18
当您希望在向公共分支等提出补丁时保持历史清洁有用时，重新设置和删除提交是最好的。
如果您必须放弃最顶层的提交，那么以下单行代码会有所帮助
git rebase --onto HEAD~1 HEAD
但是如果你想放弃你确实说过的许多提交中的 1 个
a -> b -> c -> d -> 主
你想放弃提交'c'
git rebase --onto b c
这将使'b'成为'd'消除'c'的新基础
于 2018-05-22T23:52:17.443 回答
18
在 IntelliJ IDEA 中，您只需按Alt+打开 Git 存储库日志9，鼠标右键单击提交列表中的某个标签，然后选择：“将当前分支重置到此处...”。
于 2017-06-20T10:05:21.747 回答
18
git reset --soft HEAD~1
git status
输出
在分支 master
上，您的分支领先于 'origin/master' 1 个提交。
（使用“git push”发布你的本地提交）要提交的更改：（
使用“git restore --staged ...”取消暂存）新文件：file1
git log --oneline --graph
输出
- 90f8bb1 (HEAD -> master) 第二次提交 \
- 7083e29 初始存储库提交 \
于 2020-04-17T06:36:49.350 回答
18
如果您想消除错误的文件，您应该这样做
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
于 2017-03-16T21:20:51.087 回答
17
我验证了一种有效的方法，这是一个使用它的具体示例：
如果您想永久撤消/取消您的最后一次提交（依此类推，一个一个，任意多个）三个步骤：
1：当然，获取您想要到达的提交的 id = SHA
$ git log
2：删除你以前的提交
$ git reset --hard 'your SHA'
3：使用选项强制将新的本地历史记录到您的源 GitHub 上-f（最后的提交轨道将从 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
于 2020-07-31T06:18:58.220 回答
16
撤消一系列本地提交
OP：如何撤消 Git 中最近的本地提交？我不小心提交了错误的文件 [作为几个提交的一部分]。
开始案例
有几种方法可以“撤消”作为一系列提交，具体取决于您所追求的结果。考虑下面的开始情况reset，rebase和filter-branch都可以用来重写你的历史。
如何撤消C1和C2tmp.log以从每次提交中删除文件？
在下面的示例中，使用了绝对提交引用，但如果您更习惯于相对引用（即HEAD~2或HEAD@{n}），它的工作方式相同。
备选方案 1：reset
$ git reset --soft t56pi
使用reset，可以将分支重置为先前的状态，并将任何复合更改还原到暂存区域，然后可以丢弃任何不需要的更改。
注意：由于reset将所有先前的更改聚集到Staging Area中，单个提交元数据会丢失。如果这对您不利，那么您可能会rebase更好filter-branch。
备选方案 2：rebase
$ git rebase --interactive t56pi
使用交互式rebase每个分支中的违规提交都可以重写，允许您修改和丢弃不需要的更改。在上面的信息图中，右侧的源代码树说明了 state post rebase。
一步步
- 选择 rebase 应该基于哪个提交（例如
t56pi） pick通过替换为选择您想要更改的提交edit。保存并关闭。- Git 现在将在每个选定的提交上停止，允许您重置
HEAD、删除不需要的文件并创建全新的提交。
注意：与上面的替代方案rebase相比，保留了大部分提交元数据。reset如果您想保留大部分历史记录但只删除不需要的文件，这很可能是首选选项。
备选方案 3：filter-branch
$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD
./tmp.log上面的命令将从所需范围内的所有提交中过滤掉文件t56pi..HEAD（假设我们从上面开始的初始情况）。为清楚起见，请参见下图。
类似于rebase,filter-branch可用于从分支的子部分擦除不需要的文件。无需通过变基过程手动编辑每个提交，而是filter-branch可以在每个提交上自动执行所需的操作。
注意：就像rebase,filter-branch将保留提交元数据的其余部分，仅丢弃所需的文件。请注意C1和C2是如何被重写的，并且每次提交都丢弃了日志文件。
结论
就像与软件开发相关的任何事情一样，有多种方法可以针对给定问题实现相同（或相似）的结果。您只需要选择最适合您的特定情况的一种。
最后 - 一个友好的建议
请注意，上述所有三个替代方案都完全重写了历史记录。除非您确切地知道自己在做什么并且在团队中进行良好的沟通 - 只重写尚未远程发布的提交！
资料来源：以上所有示例均来自此博客。
于 2021-10-05T13:26:47.930 回答
16
在回答之前，让我们添加一些背景，解释这HEAD是什么。
First of all what is HEAD?
HEAD只是对当前分支上的当前提交（最新）的引用。在任何给定时间
只能有一个（不包括）。HEADgit worktree
的内容HEAD存储在里面.git/HEAD，它包含当前提交的 40 字节 SHA-1。
detached HEAD
如果您不在最新的提交上 - 意思HEAD是指向历史上的先前提交，则称为detached HEAD.
在命令行上，它看起来像这样 - 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 commit
git checkout -b <branch name>
git reflog
您也可以随时使用reflog。
git reflog 将显示更新的任何更改，HEAD并检查所需的 reflog 条目将设置HEAD回此提交。
每次修改 HEAD 都会在reflog
git reflog
git checkout HEAD@{...}
这将使您回到所需的提交
git reset --hard <commit_id>
将您的 HEAD “移动”回所需的提交。
# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32
# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts if you've modified things which were
# changed since the commit you reset to.
- 注意：（从 Git 2.7 开始）你也可以使用
git rebase --no-autostash。
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 range
git revert <sha-1>
这个模式说明了哪个命令做什么。
如您所见，reset && checkout修改HEAD.
于 2021-09-26T17:50:46.827 回答
16
要撤消最后一次本地提交，而不丢弃其更改，我有这个方便的别名~/.gitconfig
[alias]
undo = reset --soft HEAD^
然后我简单地使用git undo它是超级容易记住的。
于 2019-10-23T09:19:37.753 回答
15
通过查看日志找到最后一次提交的哈希码：
git log
然后
git reset <the previous co>
于 2017-06-03T19:32:16.893 回答
14
每次我需要撤消提交/提交时我会做的是：
git reset HEAD~<n>// 我需要撤消的最后一次提交的数量git status// 可选的。所有文件现在都显示为红色（未暂存）。现在，我可以只添加和提交我需要的文件：
git add <file names> & git commit -m "message" -m "details"
- 可选：如果需要，我可以通过结帐将其余文件的更改回滚到以前的状态：
git checkout <filename>
- 如果我之前已经将其推送到远程源：
git push origin <branch name> -f// 使用 -f 强制推送。
于 2018-09-16T08:36:23.923 回答
14
假设您在 Visual Studio 中工作，如果您进入分支历史记录并查看所有提交，只需选择要撤消的提交之前的事件，右键单击它，然后选择Revert. 就这么简单。
于 2016-11-15T21:07:52.260 回答
13
替换您的本地版本，包括您对服务器版本所做的更改。这两行代码将强制 Git 拉取并覆盖本地。
打开命令提示符并导航到 Git 项目根目录。如果您使用 Visual Studio，请单击Team、Sync并单击下面的“打开命令提示符”（见图）。
进入 Cmd 提示符后，继续执行以下两个指令。
git fetch --all
然后你做
git reset --hard origin/master
这将用 Git 服务器上的本地版本覆盖现有的本地版本。
于 2019-02-10T21:25:37.353 回答
12
试试这个，硬重置到未添加这些文件的先前提交，然后：
git reset --hard <commit_hash>
确保备份更改以防万一，因为这是硬重置，这意味着它们会丢失（除非你之前隐藏了）
于 2018-04-17T15:41:15.010 回答
12
在我自己遇到同样的问题之后，我在很久以前写过这个：
基本上你只需要这样做：
git log，获取 SHA 哈希的前七个字符，然后执行 agit revert <sha>后跟git push --force.
您也可以使用 Git revert 命令恢复它，如下所示：git revert <sha> -m -1然后git push.
于 2019-07-08T15:20:23.000 回答
11
如果您想撤消仓库中的第一次提交
你会遇到这个问题：
$ 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 .
于 2018-09-24T11:58:21.127 回答
10
如果您只是想丢弃所有本地更改/提交并使您的本地分支看起来像您开始的原始分支......
git reset --hard origin/branch-name
于 2018-11-29T20:44:46.720 回答
10
使用此命令获取最后一次提交 ID（在顶部的日志中是最新的）：
git log
获取提交 ID (GUID) 并运行以下命令：
git revert <commit_id>
于 2018-11-12T00:49:14.060 回答
8
您可以使用git revert <commit-id>.
而要获取提交 ID，只需使用git log.
于 2019-05-23T09:52:15.273 回答
8
如何编辑较早的提交
一般来说，我不想撤销一堆提交，而是编辑一个较早的提交，以我希望我首先提交它的方式。
我发现自己经常修复过去的提交，以至于我为它编写了一个脚本。
这是工作流程：
git commit-edit <commit-hash>这将使您进入要编辑的提交。
提交的更改将取消暂存，准备好按您希望的第一次暂存。
修复并按您希望的方式暂存提交。
（您可能想用来
git stash save --keep-index存储您未提交的任何文件）用 重做提交
--amend，例如：git commit --amend完成变基：
git rebase --continue
调用以下内容git-commit-edit并将其放入您的$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 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
于 2018-09-27T13:12:11.097 回答
7
于 2018-09-03T13:19:28.480 回答
6
我通常首先找到我最近提交的提交哈希：
git log
它看起来像这样：commit {long_hash}
复制long_hash并重置它（返回到该提交时的相同文件/状态）：
git reset --hard {insert long_hash without braces}
于 2021-01-01T21:47:17.767 回答
6
$ git commit -m 'Initial commit'
$ git add forgotten_file
$ git commit --amend
重要的是要了解，当您修改上一次提交时，与其说是修复它，不如说是用一个新的、改进的提交完全替换它，将旧的提交推到一边，并把新的提交放在它的位置上。实际上，就好像以前的提交从未发生过，并且它不会显示在您的存储库历史记录中。
修改提交的明显价值是对您的上次提交进行微小的改进，而不会因为“糟糕，忘记添加文件”或“该死，修复上次提交中的错字”等形式的提交消息而使您的存储库历史变得混乱。
于 2020-09-03T19:44:51.150 回答
5
#1) $ git commit -m "Something terribly misguided"
#2) $ git reset HEAD~
[根据需要编辑文件]
#3) $ git add .
#4) $ git commit -c ORIG_HEAD
于 2021-07-16T05:16:20.200 回答
4
Visual Studio Code 使这变得非常容易。
于 2021-06-11T21:58:37.820 回答
4
git reset HEAD@{n}将重置您最近的n 个操作。
对于重置，对于最后一个操作，使用git reset HEAD@{1}.
于 2020-11-17T07:50:22.097 回答
4
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
于 2018-05-18T07:00:35.230 回答
4
如果存储库已在本地提交且尚未推送到服务器，则另一种粗略/外行的解决方法是：
- Git 将存储库克隆到另一个位置。
- 将原始存储库中的修改（文件/目录）复制到这个新存储库中。然后提交并推送新的更改。
- 用这个新的替换旧的存储库。
于 2021-01-06T14:42:36.147 回答
2
首先，运行此命令以重置提交：
git reset --hard HEAD~1
其次，运行这个命令来推送新的提交：
git push upstream head -f
于 2021-05-26T07:14:05.547 回答
1
如果您想恢复到最后一次提交并删除日志历史记录
使用下面的命令，假设您想转到具有 commitID SHA - 71e2e57458bde883a37b332035f784c6653ec509 的上一个提交，您可以指向此提交，在此提交之后它不会显示任何日志消息，之后所有历史记录都将被删除。
git 推送来源 +71e2e57458bde883a37b332035f784c6653ec509^:master
于 2021-11-25T11:15:48.613 回答
1
您可以将该git reset unwanted_file命令与您不想暂存的文件一起使用。通过使用此命令，我们可以将更改的文件从暂存区移动到工作目录。
于 2021-06-04T18:00:40.197 回答