it-swarm.cn

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

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

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

19555
Hamza Yerlikaya

撤消提交和重做

$ 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中显示为“未提交的更改”,因此您需要添加他们在提交之前再次)。如果您 only 想要 添加 更多更改前一次提交,或更改提交消息1,你可以使用git reset --soft HEAD~,这就像git reset HEAD~(其中HEAD~HEAD~1相同),但是现有的更改会暂停。
  3. 对工作树文件进行更正。
  4. git add您希望包含在新提交中的任何内容。
  5. 提交更改,重用旧的提交消息。 reset将旧头复制到.git/ORIG_HEAD;带有-c ORIG_HEADcommit将打开一个编辑器,该编辑器最初包含旧提交的日志消息,并允许您编辑它。如果您不需要编辑消息,则可以使用-C选项。

但请注意,如果您已向索引添加任何新更改,则使用commit --amend将它们添加到您之前的提交中。

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

git Push Origin master --force

你也可以看看这个答案: 

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

上面的答案将显示git reflog,它用于找出你希望恢复的SHA-1是什么。一旦找到要撤消的点,就可以使用上面解释的命令序列。


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

20714
Esko Luontola

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

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

   (F)
A-B-C
    ↑
  master

你想 nuke提交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

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

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

不,有仍然一种方法来取回它。输入git reflog,你会看到你已经移动的(部分)提交 shas (即哈希)列表。找到你销毁的提交,并执行以下操作:

git checkout -b someNewBranchName shaYouDestroyed

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

10143
Ryan Lundy

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

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

如何撤消本地提交

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

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 - 撤消事物

1909
Andrew

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

git rm classdir
git add sourcedir

然后修改提交:

git commit --amend

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

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

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

要么

git reset --hard HEAD~1

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

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

933
Lennart Koopmann

要更改上次提交

替换索引中的文件:

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

然后,如果它是一个私有分支, revision commit:

git commit --amend

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

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


改变以前的提交 ,使用awesome interactive rebase


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


要还原提交

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

您可以将git重置为任何提交:

git reset @~N

其中NHEAD之前的提交数,@~重置为上一次提交。

因此,您可以使用以下命令而不是修改提交:

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

查看git help reset,特别是--soft--mixed--hard上的部分,以便更好地理解它的作用。

引用日志

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

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


712
Zaz

使用git revert <commit-id>

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

594
Jaco Pretorius

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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

更多

477
Madhan Ayyasamy

如果你有 Git Extras installed,你可以运行git undo来撤消最新的提交。 git undo 3将撤消最后3次提交。

456
nickf

我想在我们的共享存储库中撤消最新的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 [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>
424
neoneye

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

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

git rebase -i HEAD~3

样品清单

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

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

401
Steven Penny

如何修复以前的本地提交

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

如何撤消先前的本地提交

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

警告词 不小心使用git reset是让你的工作副本进入混乱状态的好方法。我建议Git新手如果可以的话就避免这种情况。

如何撤消公共提交

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

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

git revert --no-edit HEAD

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

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


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

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

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

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

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

git Push Origin (branch_name)

在正常情况下,你可能不必担心你的私有分支提交历史是原始的。只需推送一个后续提交(参见上面的'如何撤消公共提交'),然后再做一个 壁球-merge 隐藏历史。

386
nobar

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

git reset --soft HEAD~1

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

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

OR

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

git revert HEAD

这将创建一个新的提交,以反转意外提交引入的所有内容。

310
santos_mgr

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

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

git log 

然后你可以做 -

git reset --hard <commit_id>

git Push Origin <branch_name> -f
306
poorva

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.
258
Varun Parakh

一个命令:

git reset --soft 'HEAD^' 

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

242
Manish Shrivastava

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

git reset --soft HEAD~1

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

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

How to undo the last commits in Git?

229
Alireza

如何撤消上次Git提交?

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

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

    git reset --hard HEAD^
    
  2. 如果您想保留更改:

    git reset --soft HEAD^
    

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

216
Ranjithkumar Ravi

使用reflog查找正确的状态

git reflog

reflog before 重置前的REFLOG

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

git reset --hard f3cb6e2

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

最后,reflog如下图所示

reflog after REFLOG FINAL

174
Shubham Chaudhary

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

git reset --hard HEAD^ 

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

git clean    

看 - Git快速参考

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

169
Ravi_Parmar

第一次运行: 

git reflog

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

然后做:

git reset --hard ActionIdFromRefLog
152
U. Ali

撤消上次提交:

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

这将撤消上次提交。

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

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


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

git commit --amend -m "message"

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

143
akshay_rahar

其他方式:

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

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

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

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

138
CommaToast

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

git reset <the previous co>
129
user853293

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

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

125
egridasov

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

114
iOS Coder

很简单,在命令行中运行:

git reset --soft HEAD~ 
114
kyo

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

git reset --hard HEAD~1
113
thestar

主要有两种情况

你还没有推送提交

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

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

你已经推送了提交

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

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

113
dseminara

有很多方法可以做到:

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

警告: 如果你不知道你在做什么,请不要使用--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

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

$ git reset --help
113
Upen

对于本地提交

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

112
geoom

怎么用,reset --softreset --hard

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

如果你不确定要使用什么去--soft(我使用这个约定记住它 - s oft为安全)。

为什么?

如果您错误地选择了--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所有。

91
amd

您可以使用:

git reset [email protected]{1}

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

62
Jade Han

认为我们有code.txtfile。[。_____。]我们对它进行了一些修改并提交。[。_____。] 我们可以通过三种方式撤消此提交 ,但首先你应该知道什么是分阶段文件...... 分阶段文件是准备提交的文件,如果你运行git status,这个文件将以绿色显示,如果不是stage for commit将以红色显示:

enter image description here

这意味着如果您提交更改,则不会保存对此文件的更改。[。_____。]您可以使用git add code.txt在此阶段添加此文件,然后提交更改:

enter image description here

撤消上次提交:

  1. 现在,如果我们只想撤销提交而不做任何其他更改,我们可以使用

    git reset --soft HEAD^ 

    enter image description here

  2. 如果我们想要撤销提交及其更改(THIS IS DANGEROUS,因为您的更改将会丢失),我们可以使用

    git reset --hard HEAD^

    enter image description here

  3. 如果我们想要撤销提交并从阶段中删除更改,我们可以使用

    git reset --mixed HEAD^或简短形式git reset HEAD^

    enter image description here

60
Ali Motameni

通常,你想 撤消 一个提交,因为你犯了一个错误而你想要解决它 - 基本上是OP在提出问题时所做的事情。所以,你真的想要 重做 提交。

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

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

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

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

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

只需撤消上次提交: 

git reset --soft HEAD~

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

git reset --soft HEAD~2

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

git reset --soft <commitID>

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

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

git clean

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

53
steven

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

右键单击​​ on提交然后 选择 重置(当前分支)/ master到此commit”和last select “Soft”reset

Enter image description here

53
Alexandr

撤消上次提交

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

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

$ git reset --soft HEAD~1

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

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

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

$ git reset --hard HEAD~1

Enter image description here

51
Mohit

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

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

47
mfathy00

典型的Git循环

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

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

    git clone $project

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

    git pull

  3. 将新的本地文件1添加到$ to_be_committed_list中(想象一下$ to_be_committed_list表示staged区域)

    git add $file1

  4. 从$ to_be_committed_list中删除错误添加的file2(假设file2像步骤3一样添加,我不想要)

    git reset $file2

  5. 提交$ to_be_committed_list中的file1

    git commit -m "commit message description"

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

    git pull --rebase

  7. 解决冲突发生时 先决条件配置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.

41
Sazzad Hissain Khan

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

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

git reset --soft HEAD~1

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

git reset FILE

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

39
FraK

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

如果你不能在Visual Studio中进行同步,因为你不允许像我一样尝试推送到像“开发”这样的分支,在Visual Studio中不需要 _ revert _ NOR _ reset _ (hard或soft)可行。

根据TONS OF VOTES的回答:

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

git reset --hard HEAD~1

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

38
Tom Stickel

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

git checkout commitID .

例:

git checkout 7991072 .

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

35
ioopl

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

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

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

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

git Push --force-with-lease

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

34
KawaiKx

撤消上次提交:

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

这将撤消上次提交。

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

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

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

git commit --amend -m "message"

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

32
Ankit Patidar

你需要做到轻松快捷

    git commit --amend

如果它是一个私人分支或

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

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

32
Yahs Hef

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

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


git reflog

您也可以始终使用reflogname__。
git reflog将显示更新HEADname__的任何更改,并且检出所需的reflog条目会将HEADname__设置回此提交。 

每次修改HEAD时,reflogname__中都会有一个新条目。
reflogname__类似于unix history命令,并在本地保存在您的计算机上。

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

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

enter image description here


git reset HEAD --hard <commit_id>

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

如果这些提交不属于任何其他分支,他们将变得“悬挂”。
“悬挂”内容表示您的本地存储库中存在不可访问的内容,该内容不属于任何其他分支,可以删除或将被gcname__删除。

# 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修改HEADname__。

enter image description here

28
CodeWizard

使用此命令:

git checkout -b old-state number_commit
27
Fadid

使用此命令

git checkout -b old-state 0d1d7fc32
27
Jishnu Sukumaran

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

git Push Origin +(previous good commit id):(branch name)

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

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

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

25
V V

为了摆脱上次提交(所有更改),最后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-小心,因为“硬”选项,它会删除您的仓库中的本地更改并恢复到之前提到的提交。如果你确定你在最后的提交中搞砸了,并且想要回到过去,你应该运行这个。 

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

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

24
Alisa

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

24
shreshta bm

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

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

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

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

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

20
Shwetank

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

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

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

Git Extensions screen shot

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

Revert commit popup

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

18
Ranadheer Reddy

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

16
hubot

我找到了 this site,它描述了如何撤消已提交到存储库的内容。

一些命令:

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

这是网站: 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 :)
15
Eugen Konkov

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

在下图中,我检查了'test'分支(使用Git命令git checkout -b test)作为本地和检查状态(使用Git命令git status)本地分支,没有任何提交。

Enter image description here

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

“-m用于提交消息” /

Enter image description here

在下一个图像中,您可以看到您的提交记录您提交的任何内容(使用Git命令git log)。

Enter image description here

因此,在上面的图像中,您可以看到每次提交的提交ID以及提交消息,现在无论您想要还原的提交还是撤消提交ID的复制并点击下面的Git命令,[。_____。] git revert {"paste your commit id"}。例:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

Enter image description here

我已经恢复了我的最后一次提交。现在,如果你检查你的Git状态,你可以看到修改后的文件是 Filter1.txt 并且还要提交。

Enter image description here

14
Raj S. Rusia

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

git reset HEAD^

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

14
Arun Karnawat

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

13
Krzysztof Walczewski

HEAD:

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

Git commit:

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

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

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

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

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

git reset 0xab3#提交号码

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

这是图形表示:

Enter image description here

13
Mohideen ibn Mohammed

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

先决条件:当对存储库中的现有文件进行修改时,此更改最初被视为未分级。[。_____。]为了进行更改,需要上传,这意味着使用git add将其添加到索引中。在提交操作期间,暂存的文件将添加到索引中。

我们来举个例子: 

- A - B - C (master)

HEAD指向C且索引与C匹配。

- 柔软的

  • 当我们执行git reset --soft B时意图 删除提交C将master/HEAD指向B 。 
  • 主/ HEAD现在指向B,但是 索引仍然从C改变 。 
  • 执行git status时,你可以看到索引的文件 commit C as staged 。 
  • 此时执行git commit将创建一个新的提交 与C相同

--mixed

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

- 硬

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

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

12
Keshan Nageswaran

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

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

git rebase --onto HEAD~1 HEAD

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

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

你想放弃提交'c'

git rebase --onto b c

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

12
Khem

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

git log

然后

git reset <the previous co>
12
Praveen Singh

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

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

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

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

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

11
Dominic Cerisano

enter image description here

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

11
Uchiha Itachi

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

git reset --soft <your_last_good_commit_hash_here> 这里,如果您执行git status,您将看到暂存区域中的文件。您可以选择错误的文件并从暂存区域中删除它们。

如下所示。

git reset wrongFile1 wrongFile2 wrongFile3

您现在可以只添加Push所需的文件,

git add goodFile1 goodFile2

提交他们 

git commit -vgit 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

8
nPcomp

试试这个,硬复位到之前的提交,但没有添加这些文件,然后:

git reset --hard <commit_hash>

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

7
serdarsenay
git reset --soft HEAD~1

重置会将当前的HEAD分支回滚到指定的版本。 注意 --soft标志:这可以确保保留撤消修订中的更改。运行该命令后,您将在工作副本中找到更改为未提交的本地修改。

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

 git reset --hard HEAD~1

撤消多个提交

git reset --hard 0ad5a7a6

但请记住,使用reset命令会撤消返回到的所有提交之后的所有提交: enter image description here

6
Abu Bakr

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

  1. git reset HEAD~<n> //我需要撤消的最后提交次数
  2. git status //可选。所有文件现在都是红色的(未分级)。

  3. 现在,我可以添加和提交我需要的文件:

    • git add <file names> & git commit -m "message" -m "details"
  4. 可选:如果我需要,我可以使用结帐退回其余文件的更改:
    • git checkout <filename>
  5. 如果我已将它推到远程Origin,之前:
    • git Push Origin <branch name> -f //使用-f强制推送。
6
Theo Itzaris

如果要撤消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 .
5
Nicholas

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

git log

获取提交ID(GUID)并运行此命令:

git revert <commit_id>
3
Nalan Madheswaran

如何 编辑 早先的提交

通常我不想撤消一堆提交,而是编辑一个早先的提交,我希望我首先提交它。

我发现自己经常修复过去的提交,因此我为它编写了一个脚本。

这是工作流程:

  1. git commit-edit <commit-hash>
    

    这将使您想要编辑的提交。

    提交的更改将是 un staged,准备好上演,因为您希望这是第一次。

  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 "[email protected]"; 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
2
Tom Hale

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

git reset --hard Origin/branch-name

1
JeremyWeir
git revert commit

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

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

1
Gjorgi Gjorgiev

用服务器版本替换你的本地版本,包括你的更改,这两行代码将强制git拉取并覆盖本地。打开命令提示并导航到git项目根目录。如果您使用VS,请单击Team,Synch并单击下面的“打开命令提示符”(参见图像)。 

Visual Studio

进入Cmd提示后,请继续执行以下两条说明。 

git fetch --all

然后你做

git reset --hard Origin/master

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

0
shiraz
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
0
Omkaar.K