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

Question

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

如何撤消本地存储库中的提交？

Answer 1

撤消提交并重做

$ 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~（其中HEAD~与HEAD~1相同），但会暂时保留您现有的更改。
3. 更正工作树文件。
4. git add您希望在新提交中包含的任何内容。
5. 提交更改，重用旧的提交消息。 reset将旧头复制到.git/ORIG_HEAD;带commit的{​​{1}}会打开一个编辑器，该编辑器最初包含旧提交的日志消息，并允许您对其进行编辑。如果您不需要编辑邮件，则可以使用-c ORIG_HEAD选项。

请注意，如果您已对索引添加了任何新更改，则使用-C会将其添加到您之前的提交中。

如果代码已经推送到您的服务器并且您有权覆盖历史记录（rebase），那么：

commit --amend

你也可以看看这个答案：

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

上面的答案将显示git push origin master --force ，用于找出您希望恢复的SHA-1是什么。找到要撤消的点后，使用上述命令序列。

---

¹ 但是，请注意，如果您在提交消息中犯了错误，则无需重置为先前的提交。更简单的选择是git reflog（取消您之后所做的任何更改），然后git commit --amend，这将打开预先填充了最后一次提交消息的默认提交消息编辑器。

Answer 2

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

假设您有这个，其中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的变化。你没有丢失任何东西！

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

git reset --soft HEAD~1

这不仅会使您的文件单独存在，甚至会单独留下您的索引。执行git status时，您会看到索引中的文件与之前一样。实际上，在这个命令之后，您可以执行git commit并且您将重做您刚才提交的相同提交。

还有一件事：假设您在第一个示例中销毁了提交，但后来发现您需要它？运气好，对吧？

不，还有仍然让它回来的方法。键入git reflog，您将看到已经移动过的（部分）提交shas（即哈希）的列表。找到您销毁的提交，并执行以下操作：

git checkout -b someNewBranchName shaYouDestroyed

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

Answer 3

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

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

如何撤消本地提交

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

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

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

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

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

如何撤消公开提交

如果您已将提交公开，则需要创建一个新的提交，它将“还原”您在先前提交中所做的更改（当前HEAD）。

git revert HEAD

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

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

有关详细信息，请查看Git Basics - Undoing Things

Answer 4

添加/删除文件以获得您想要的内容：

git rm classdir
git add sourcedir

然后修改提交：

git commit --amend

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

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

Answer 5

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

或

git reset --hard HEAD~1

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

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

Answer 6

更改上次提交

替换索引中的文件：

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

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

git commit --amend

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

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

（更改以前的提交，使用真棒interactive rebase）

---

ProTip™：将*.class添加到gitignore以再次停止此操作。

---

还原提交

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

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

git reset @~N

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

因此，您可以使用：

，而不是修改提交

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

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

引用日志

如果你陷入困境，你总是可以使用reflog来查找丢弃的提交：

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

Answer 7

使用git revert <commit-id>

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

即可

Answer 8

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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

More

Answer 9

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

Answer 10

我想在我们的共享存储库中撤消最新的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>

Answer 11

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

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

git rebase -i HEAD~3

样本列表

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

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

Answer 12

如何修复先前的本地提交

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

如何撤消先前的本地提交

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

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

如何撤消公开提交

执行reverse cherry pick（git-revert）撤消更改。

如果您还没有将其他更改添加到您的分支上，您可以直接执行...

git revert --no-edit HEAD

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

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

---

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

这可能很危险 - 请确保您有分支的本地副本以进行重新安装。

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

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

在本地清理你的分支，然后重新开始......

git push origin (branch_name)

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

Answer 13

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

git reset --soft HEAD~1

  

HEAD~1 是head之前提交的简写。或者，如果要重置为，则可以参考哈希的 SHA-1 。 - soft 选项将删除提交，但它将保留所有已更改的文件“要提交的更改”，因为git status会将其设置为。

     

如果你想在工作树中删除对工作树中跟踪文件的任何更改，那么在使用“ - hard ”之前提交。

OR

  

如果你已经推了并且有人拉了，这通常是我的情况，你不能使用 git reset 。但是，您可以执行 git revert ，

git revert HEAD

  

这将创建一个新的提交，以撤消意外提交引入的所有内容。

Answer 14

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

可以看到提交ID

git log 

然后你可以做 -

git reset --hard <commit_id>

git push origin <branch_name> -f

Answer 15

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

在终端上：

您也可以使用：

git revert

或者：

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

Answer 16

单个命令：

git reset --soft 'HEAD^' 

撤消上一次本地提交真的很棒！

Answer 17

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

git reset --soft HEAD~1

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

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

Answer 18

如何撤消上次Git提交？

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

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

   git reset --hard HEAD^
   

2. 如果您想保留更改：

   git reset --soft HEAD^
   

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

Answer 19

使用reflog查找正确的状态

git reflog

重置前的 REFLOG

选择正确的reflog（在我的情况下为f3cb6e2）并输入

git reset --hard f3cb6e2

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

最后，reflog如下图所示

REFLOG FINAL

Answer 20

“将工作树重置为上次提交”

git reset --hard HEAD^ 

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

git clean    

请参阅 - Git Quick Reference

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

Answer 21

首先运行：

git reflog

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

然后做：

git reset --hard ActionIdFromRefLog

Answer 22

撤消上次提交：

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

这将撤消上次提交。

此处--soft表示重置为暂存。

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

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

git commit --amend -m "message"

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

Answer 23

另一种方式：

签出要还原的分支，然后将本地工作副本重置回您希望成为远程服务器上最新版本的提交（之后的所有内容将再次出现）。为此，在SourceTree中我右键单击并选择“将BRANCHNAME重置为此提交”。

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

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

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

Answer 24

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

git reset <the previous co>

Answer 25

在我的情况下，我不小心提交了一些我不想要的文件。所以我做了以下工作并且有效：

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

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

Answer 26

有很多方法可以做到：

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。

现在让我们看一些案例：

假设您要还原最后一次提交＆＃39; d81d3f1＆＃39;。以下是两个选项：

$ git reset --hard d81d3f1

或

$ git reset --hard HEAD~1

假设您要还原提交＆＃39; be20eb8＆＃39;：

$ git reset --hard be20eb8

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

$ git reset --help

Answer 27

简单，在命令行中运行：

git reset --soft HEAD~ 

Answer 28

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

git reset --hard HEAD~1

Answer 29

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

Answer 30

主要有两种情况

您尚未推送提交

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

git rm <pathToFile>

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

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

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

进行提交

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

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

您已经推送了提交

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

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

Answer 31

对于本地提交

git reset --soft HEAD~1

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

git rm --cached <file>

对于推送提交

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

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

但我建议您小心使用此命令。请阅读 git-filter-branch(1) Manual Page 。

Answer 32

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

我只是为@Kyralessa的答案增加两美分：

如果您不确定要使用什么，请转到--soft（我使用此惯例记住它 - s oft for safe）。

为什么？

如果您错误地选择了--hard，您将 LOSE 更改，而不是之前的更改。 如果您误选--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。

Answer 33

您可以使用：

git reset HEAD@{1}

如果没有Git日志，此命令将删除错误的提交。

Answer 34

认为我们有 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^

   

Answer 35

通常，您希望撤消提交，因为您犯了一个错误，并且想要修复它 - 基本上是OP在提出问题时所做的事情。实际上，你实际上想要重做提交。

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

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

注意：我会在这里假设您在推送之前意识到提交是错误的。如果你不知道推动意味着什么，那么你可能没有推动。所以继续说明。如果你推动了错误的提交，那么风险最小的方法就是用一个修复事物的新提交来跟进错误的提交，就像你在不允许你重写历史的版本控制系统中那样做。

那就是说，如何使用GUI修复最近的错误提交：

1. 在命令行上导航到您的存储库，并使用git gui
启动GUI
2. 选择＆＃34;修改最后一次提交＆＃34;。您将看到上次提交的消息，您上传的文件以及您没有提交的文件。
3. 现在将内容更改为您希望它们的外观，然后单击“提交”。

Answer 36

撤消上次提交

在很多情况下，您确实要撤消最后一次提交到代码中的内容。例如。因为你想广泛地重组它 - 甚至完全放弃它！

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

$ git reset --soft HEAD~1

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

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

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

$ git reset --hard HEAD~1

Answer 37

如果您正在使用 SourceTree ，这将对您有所帮助。

右键单击然后选择＆＃34; 重置（当前分支）/ master到此提交＆＃34;最后选择 ＆＃34; Soft＆＃34;重置

Answer 38

只需撤消上一次提交：

git reset --soft HEAD~

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

git reset --soft HEAD~2

或撤消之前的任何提交：

git reset --soft <commitID>

（您可以使用git reflog）

获取commitID

撤消之前的提交时，请记得使用

清理工作区

git clean

可以在文档中找到更多详细信息：git-reset

Answer 39

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

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

Answer 40

撤消上次提交：

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

这将撤消上次提交。

此处--soft表示重置为暂存。

HEAD~ or HEAD^表示在HEAD之前提交。

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

git commit --amend -m "message"

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

Answer 41

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

在你提交和推送的同一个分支上，如果输入“git status”，你将看不到任何新内容，因为你提交并推送了，现在输入：

git reset --soft HEAD~1

这会将所有更改（文件）返回到舞台区域，现在将它们放回到您刚刚键入的工作目录（unstage）中：

git reset FILE

其中“File”是您要再次提交的文件。现在，此FILE应位于工作目录（未分级）中，并且您执行了所有更改。现在，您可以更改为所需的任何分支，并在该分支中提交更改。希望这有助于其他人犯了同样的错误。当然，您提交的初始分支仍然存在所有更改，但在我的情况下，如果不适合您，则可以查找在该分支中还原该提交的方法。

Answer 42

典型的Git循环

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

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

   git clone $project

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

   git pull

3. 在$ to_be_committed_list中添加一个新的本地文件1（想象一下$ to_be_committed_list意味着staged区域）

   git add $file1

4. 从$ to_be_committed_list中删除错误添加的file2（假设我添加了file2，就像我不想要的那样）

   git reset $file2

5. 提交$ to_be_committed_list

   中的file1

   git commit -m "commit message description"

6. 在推送

   之前将本地提交与远程存储库同步

   git pull --rebase

7. 解决冲突发生的时间prerequisite configure mergetool

   git mergetool #resolve merging here, also can manually merge

8. 添加冲突解决的文件，让我们说file1：

   git add $file1

9. 继续我以前的rebase命令

   git rebase --continue

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

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

Answer 43

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

git reset --soft HEAD~1

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

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

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

git reset --hard HEAD~1

Answer 44

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

如果您无法在Visual Studio中进行同步，则不允许您推送到像＃34; development＆＃34;这样的分支。然后就像我尝试的那样，在Visual Studio中， REVERT NOR RESET （硬或软）将起作用。

根据TONS OF VOTES的回答：

在项目根目录的命令提示符处使用此命令来修改任何试图被推送的内容：

git reset --hard HEAD~1

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

Answer 45

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

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

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

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

git push --force-with-lease

强制选项的'with-lease'版本，它可以防止意外删除你不知道的新提交（即自你上次拉动后来自其他来源）。

Answer 46

您可以通过多种方式撤消上次提交。 以下是您的一些选项，总结为带有代码片段的单个答案

，首先，您需要确定哪些是您要放弃的“错误”提交。我们将使用git reflog来查找它。

git reflog

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

每次修改HEAD时，reflog 都会有新条目。
reflog类似于Unix历史命令，并保存在您的计算机本地。

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

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

<强> git reset HEAD --hard <commit_id>

“移动”您的头回到所需的提交 Git重置将根据您选择的值--hard/--soft/--mixed检查您的暂存区域和/或工作目录中所需的提交内容。 --hard将使用给定内容更新阶段区域和工作目录，并将在本地分支上“分离”超出此点的任何其他提交。

如果这些提交不属于任何其他分支，它们将变得“悬挂” “悬挂”内容意味着您的本地存储库中存在无法访问的内容，该内容不属于任何其他分支，可以被删除或将被gc删除。

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

Answer 47

我从bitbucket获得了提交ID，然后执行了：

git checkout commitID .

示例：

git checkout 7991072 .

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

Answer 48

You need to do the easy and fast

    git commit --amend

if it's a private branch or

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

if it's a shared or public branch.

Answer 49

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

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

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

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

您可以使用git log

获取以前的提交ID

Answer 50

使用此命令

{
  "Records": [
    {
      "TransID": "902473653",
      "Date": "6/12/2015 10:47:00 AM",
      "ProductID": "90",
      "ItemDes": "test",
      "Amount": "20000",
      "BankTransactionID": "FM60aW33EavtDcYmXbz5vy/UvUAiQF",
      "Banktype": "IPG_SAMAN"
    },
    {
      "TransID": "910920749",
      "Date": "6/11/2015 11:05:00 AM",
      "ProductID": "91",
      "ItemDes": "test",
      "Amount": "20000",
      "BankTransactionID": "mAdWPNY++QdcKYepuIvuC4+UdZnQAa",
      "Banktype": "IPG_SAMAN"
    },
    {
      "TransID": "81131964",
      "Date": "11/24/2014 9:08:00 AM",
      "ProductID": "81",
      "ItemDes": "test",
      "Amount": "90000",
      "BankTransactionID": "123456789012",
      "Banktype": "USSD_InfoTech"
    }
  ]
}

Answer 51

使用此命令：

git checkout -b old-state number_commit

Answer 52

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

Answer 53

为了摆脱上次提交（所有更改），最后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

  

PS：
  1-小心，因为＆＃34;硬＆＃34;选项，它删除本地更改   在你的回购中，并恢复到前面提到的提交。您   应该运行这个，如果你确定你搞砸了你的最后一次提交   并想回到过去。

     

2-通常7个字母＆＃34;提交sha＆＃34;足够了，但更大   项目，您可能需要最多12个字母以保证是唯一的。您   也可以提到整个40个字母sha。

     

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

Answer 54

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

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

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

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

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

Answer 55

参考：How to undo last commit in Git?

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

打开Git Extensions，右键单击要恢复的提交，然后选择＆＃34; Revert commit＆＃34;。

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

选择＆＃34;自动创建提交＆＃34;如果您想直接提交还原的更改，或者如果您想手动提交已还原的更改，请保持该框未被选中，然后单击＆＃34;还原此提交＆＃34;按钮。

Answer 56

我找到了this网站，其中介绍了如何撤消已提交到存储库中的内容。

一些命令：

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

Answer 57

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

Answer 58

git reset --mixed，-soft和--hard

之间的区别

  

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

让我们举个例子：

- A - B - C (master)

HEAD指向C，索引匹配C。

-soft

• 当我们执行git reset --soft B时，目的是删除提交C ，并将主服务器/ HEAD指向B 。
• 主服务器/ HEAD现在将指向B，但是索引仍从C更改为。
• 执行git status时，您可以看到在 commit C 中索引为 staged 的文件。
• 此时执行git commit将使用与C相同的更改创建一个新的提交。

-混合

• 执行git reset --mixed B。
• 在执行时，master / HEAD将指向B，并且由于使用了混合标志，索引也被修改为与B 相匹配。
• 如果此时执行git commit，则由于索引与HEAD匹配，因此不会发生任何事情。
• 我们仍在工作目录中进行更改，但是由于它们不在索引中，因此 git status将其显示为未暂存。
• 要提交它们，您需要先git add，然后照常提交。

-hard

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

希望这种与git reset命令一起使用的标志的比较将帮助某人明智地使用它们。请参阅这些以获取更多详细信息link1和link2

Answer 59

这是网站：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 :)

Answer 60

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

在下面的图片中，我查看了＆＃39;测试＆＃39; branch（使用Git命令git checkout -b test）作为本地分支的本地和检查状态（使用Git命令git status），没有任何内容可以提交。

在下一张图片图片中，您可以看到我在 Filter1.txt 中进行了一些更改，并将该文件添加到了暂存区域，然后使用一些消息提交了我的更改（使用Git命令{{ 1}}）。

＆＃34; -m用于提交消息＆＃34;

在下一张图片中，您可以看到提交日志，无论您提交了什么内容（使用Git命令git commit -m "Doing commit to test revert back"）。

因此，在上面的图像中，您可以看到每次提交的提交ID以及您的提交消息现在无论您想要还原的提交还是撤消提交ID的复制并点击下面的Git命令， git log。例如：

git revert {"paste your commit id"}

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

Answer 61

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

git reset HEAD^

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

Answer 62

在IntelliJ IDEA中，您可以通过按 Alt + 9 打开Git存储库日志，在提交列表中的某个标记处单击鼠标右键，然后选择：< em>＆＃34;将当前分支重置为此处...＆＃34; 。

Answer 63

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

由于没有按下提交，遥控器没有改变，所以：

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

如果您喜欢Git客户端，那么这有时是必要的。 （例如non-fast-forward错误）

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

Answer 64

<强> HEAD

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

Git提交：

在提交下分配的每个更改，由唯一标记表示。提交无法删除。因此，如果您想要上次提交，只需使用LocalDateTime潜入它。

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

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

git reset

方法2：（如果您知道提交只是重置为已知提交）

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

注意：如果您想了解最近的提交，请尝试git reset 0xab3

以下是图形表示：

Answer 65

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

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

git rebase --onto HEAD~1 HEAD

但是如果你想删除许多提交中的一个，你就说

a - ＆gt; b - ＆gt; c - ＆gt; d - ＆gt;主

你要删除提交'c'

git rebase --onto b c

这将使'b'成为'd'消除'c'

的新基础

Answer 66

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

git log

然后

git reset <the previous co>

Answer 67

$ git reset --soft HEAD~1

$ git status

On branch master
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   file1

$ git log --oneline --graph

 * 90f8bb1 (HEAD -> master) Second commit
 * 7083e29 Initial repository commit

Answer 68

explains here

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

Answer 69

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

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

Answer 70

尝试此操作，硬复位到之前的提交，其中未添加这些文件，然后：

git reset --hard <commit_hash>

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

Answer 71

最简单的方法是：

$ git reset --soft HEAD~1

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

Answer 72

git reset --soft HEAD~1

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

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

 git reset --hard HEAD~1

  

撤消多次提交

git reset --hard 0ad5a7a6

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

Answer 73

我验证了一种有效的方法，下面是使用它的具体示例： 如果您要永久撤消/取消上一次提交（依此类推，以1为1的任意数量）3个步骤：

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

=>完成！ ：）

Answer 74

要撤消上一次本地提交而不放弃其更改，我在~/.gitconfig中有这个方便的别名

[alias]
  undo = reset --soft HEAD^

然后我只需使用git undo即可轻松记住它。

Answer 75

如果您要撤消存储库中的第一个提交

您会遇到此问题：

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

Answer 76

我每次需要撤消一次提交/提交时要做的事情是：

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

2. git status //可选。现在，所有文件均为红色（未登台）。

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

   • git add <file names> & git commit -m "message" -m "details"
4. 可选：如果需要，我可以通过检出将其余文件的更改回滚到以前的状态：
   • git checkout <filename>
5. 如果以前我已经将其推送到远程来源：
   • git push origin <branch name> -f //使用-f强制执行推送。

Answer 77

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

git log

看起来像这样：commit {long_hash}

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

git reset --hard {insert long_hash without braces}

Answer 78

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

git log

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

git revert <commit_id>

Answer 79

CMake was unable to find a build program corresponding to "Ninja".  CMAKE_MAKE_PROGRAM is not set.  You probably need to select a different build tool.

[根据需要编辑文件]

run.upload_file("outputs/my_model.pickle", "outputs/my_model.pickle")
print(run.get_file_names())
print(os.getcwd())
model = run.register_model(model_name='simtemp', model_path="outputs/{}".format(model_file_name))

Answer 80

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

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

Answer 81

为了从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开始，有一种从提交中删除文件的新方法，但是您必须确保使用的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

在分支母版上 您的分支比“源/主”提前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

正确解压缩文件后，将“ git rm”命令与“ –cached”选项一起使用，以便从Git索引中删除该文件（这不会删除磁盘上的文件）

$ git rm --cached newfile

rm'newfile'

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

$ git status

在分支母版上 您的分支比“源/主”提前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 Commit删除特定文件 在某些情况下，您不希望所有文件都重新上演：只修改其中一个非常特定的文件。

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

$ git reset HEAD^ -- <file>

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

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

$ git reset HEAD <file>

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

如果要从索引中完全删除文件，则必须将“ git rm”命令与“ -cached”选项一起使用。

$ git reset HEAD <file>

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

$ git ls-files

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

$ git commit --amend

Answer 82

git revert commit

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

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

Answer 83

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

重要的是要了解，当您在修改上一次提交时，您并没有对其进行太多的修复，而是将其完全替换为一个新的改进的提交，从而将旧提交排除在外，并将新提交放入它的位置。实际上，就好像以前的提交从未发生过，也不会显示在您的存储库历史记录中。

修改提交的明显价值是对您的上次提交进行了较小的改进，而不会以“ Oops，忘记添加文件”或“ Darn，在上次提交中修正输入错误”形式的提交消息使您的存储库历史记录混乱”。

https://git-scm.com/book/en/v2/Git-Basics-Undoing-Things

Answer 84

执行以下步骤。可能会对您有帮助。

步骤：1

打git log

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

步骤：2

git reset <hash code>

Answer 85

用服务器版本替换本地版本（包括所做的更改），这两行代码将强制git拉取并覆盖本地。打开命令提示符，然后导航到git项目根目录。如果您使用VS，请单击“团队，同步”，然后单击下面的“打开命令提示符”（参见图片）。

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

git fetch --all

那你做

git reset --hard origin/master

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

Answer 86

首先，运行此命令重置提交：

git reset --hard HEAD~1

其次，运行这个命令来推送新的commit：

git push upstream head -f

Answer 87

Visual Studio Code 让这一切变得非常简单。

Answer 88

如何编辑更早的提交

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

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

这是工作流程：

1. git commit-edit <commit-hash>
   

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

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

2. 按您希望的那样修复并暂存提交。

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

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

   git commit --amend
   

4. 完成rebase：

   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

Answer 89

git reset HEAD @ {n}将重置您的前n个动作。 要重置，请执行最后一个操作git reset HEAD@{1}

Answer 90

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

git reset --hard origin/branch-name

Answer 91

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

How can I undo commits in Git locally and remotely?

Answer 92

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

Answer 93

我很久以前就写过同样的问题，写过关于这个时代的文章：

https://ao.gl/how-to-delete-revert-a-git-commit/

基本上，您只需要这样做：

git revert <sha>，获取SHA的前七个字符，然后依次进行git push --force和git revert <sha> -m -1。

您还可以使用Git还原命令来还原此命令，如下所示：git push，然后# after read.table rownames(another) <- paste0("row_", seq(nrow(another))) 。

Answer 94

您的出租车使用git revert

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