如何撤消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~(这里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打开您的默认提交消息编辑器,预先填充上一次提交消息.

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的变化.你没有丢失任何东西!

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

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 resetto HEAD-1会将您的工作副本设置为提交状态.

Answer 6

要更改上次提交

替换索引中的文件:

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

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

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

更多

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新手尽可能避免这种情况.

如何撤消公共提交

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

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

git revert --no-edit HEAD

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

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

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

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

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

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

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

git push origin (branch_name)

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

Answer 13

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

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

git log 

然后你可以做 -

git reset --hard <commit_id>

git push origin <branch_name> -f

Answer 14

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

git reset --soft HEAD~1

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

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

要么

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

git revert HEAD

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

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快速参考

注意:此命令将删除您之前的提交,因此请谨慎使用!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 reset --soft HEAD~ 

Answer 27

有很多方法可以做到:

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

Answer 28

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

Answer 29

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

git reset --hard HEAD~1

Answer 30

对于本地提交

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

Answer 31

主要有两种情况

你尚未推送提交

如果问题是您提交的额外文件(并且您不希望存储库中存在这些文件),则可以使用它们将其删除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`:该选项重写最后一次提交的历史记录).

Answer 32

什么用,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所有.

Answer 33

简单的分步指南如下：

• 销毁提交并丢弃任何未提交的更改

  git reset --hard HEAD~1
  

• 撤消提交，但保留更改

  git reset HEAD~1
  

• 保留您的文件，并自动暂存所有更改

  git reset --soft HEAD~1
  

• 恢复你破坏的提交

  git reflog # To find the sh
  

Answer 34

如果您想恢复上次提交，但仍想在本地保留提交中所做的更改，请使用以下命令：

git reset HEAD~1 --mixed

Answer 35

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

您可以使用:

git reset HEAD@{1}

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

Answer 37

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

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

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

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

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

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

Answer 38

撤消上次提交

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

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

$ git reset --soft HEAD~1

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

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

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

$ git reset --hard HEAD~1

Answer 39

只需撤消上次提交:

git reset --soft HEAD~

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

git reset --soft HEAD~2

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

git reset --soft <commitID>

(你可以使用commitID git reflog)

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

git clean

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

Answer 40

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

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

Answer 41

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

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

Answer 42

撤消上次提交:

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

这将撤消上次提交.

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

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

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

git commit --amend -m "message"

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

Answer 43

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

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

git reset --soft HEAD~1

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

git reset FILE

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

Answer 44

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

首先,您需要确定哪些是您希望丢弃的"错误"提交.我们将用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.

Answer 45

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

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

根据TONS OF VOTES的回答:

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

git reset --hard HEAD~1

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

Answer 46

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

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

git reset --hard HEAD~1

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

git push --force

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

Answer 47

典型的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像步骤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.

Answer 48

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

git reset --soft HEAD~1

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

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

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

git reset --hard HEAD~1

Answer 49

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

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

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

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

git push --force-with-lease

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

Answer 50

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

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

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

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

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

Answer 51

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

git checkout commitID .

例:

git checkout 7991072 .

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

Answer 52

你需要做到轻松快捷

    git commit --amend

如果它是一个私人分支或

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

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

Answer 53

撤消一系列本地提交

OP：如何撤消 Git 中最近的本地提交？我不小心提交了错误的文件[作为多次提交的一部分]。

启动案例

有多种方法可以“撤消”一系列提交，具体取决于您所追求的结果。考虑下面的开始情况，reset、rebase和filter-branch都可以用来重写您的历史记录。

如何撤消C1和C2tmp.log以从每次提交中删除文件？

HEAD~2在下面的示例中，使用绝对提交引用，但如果您更习惯相对引用（即或） ，它的工作方式相同HEAD@{n}。

替代方案 1：reset

$ git reset --soft t56pi

使用reset，可以将分支重置到以前的状态，并且任何复合更改都可以恢复到暂存区域，然后可以从那里丢弃任何不需要的更改。

注意：当将reset所有先前的更改聚集到暂存区域时，单个提交元数据将丢失。如果这对您来说不合适，那么您可能会更好地选择rebase或filter-branch。

替代方案 2：rebase

$ git rebase --interactive t56pi

使用交互式方式rebase，可以重写分支中的每个有问题的提交，从而允许您修改和丢弃不需要的更改。在上面的信息图中，右侧的源树说明了状态帖子rebase。

一步步

1. 选择 rebase 应基于哪个提交（例如t56pi）
2. pick通过替换为 来选择您想要更改的提交edit。保存并关闭。
3. 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是如何被重写的，以及日志文件是如何从每次提交中丢弃的。

结论

就像与软件开发相关的任何事情一样，对于给定问题有多种方法可以实现相同（或相似）的结果。您只需选择最适合您的特定情况的一种。

最后——一个友好的建议

请注意，上述所有三种替代方案都完全重写了历史。除非您确切地知道自己在做什么并且在团队内有良好的沟通 - 只重写尚未远程发布的提交！

来源：以上所有例子均借自该博客。

Answer 54

使用此命令

git checkout -b old-state 0d1d7fc32

Answer 55

使用此命令:

git checkout -b old-state number_commit

Answer 56

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

Answer 57

为了摆脱上次提交(所有更改),最后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.

Answer 58

在回答之前，让我们添加一些背景知识，解释一下这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，并检查所需的引用日志条目将设置HEAD回此提交。

每次修改 HEAD 时，都会在 HEAD 中产生一个新条目reflog

git reflog
git checkout HEAD@{...}

这会让你回到你想要的提交

git reset --hard <commit_id>

将您的 HEAD“移”回所需的提交。

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

• 注意：（从 Git 2.7 开始）您也可以使用git rebase --no-autostash。

git revert <sha-1>

“撤消”给定的提交或提交范围。
重置命令将“撤消”给定提交中所做的任何更改。
将提交带有撤消补丁的新提交，而原始提交也将保留在历史记录中。

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

此架构说明了哪个命令执行什么操作。
如您所见，reset && checkout修改HEAD.

Answer 59

您可以通过两种方式撤消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 60

在选择具体的工具（命令）之前，请先选择自己需要的，而不是盲目运行命令。

修改提交

• 如果您想编辑最后一次提交，可以使用一个命令。

• 优点：它允许您更正上次提交的消息并向其添加更多更改。

  git commit --amend
  

重置提交

• 确实想撤消最后一次提交（因为进行了大量更改或者您想全部丢弃）。

• 优点：重置命令将返回到当前修订之前的版本，有效地撤消最后一次提交。

A. 软复位

优点：软旗。它保证保留未完成的修订中所做的修改。运行命令后，更改将作为未提交的本地修改出现在工作副本中。

git reset --soft HEAD~1

B. 硬重置

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

git reset --hard HEAD~1

撤消上次提交但保留对文件所做的更改

优势：

该命令将告诉 Git 将 HEAD 指针向前推进一次提交。不过，文件的修改不会受到影响。现在，如果您运行git status，您应该仍然能够查看本地文件更改。

git reset HEAD~1

根据您的需要使用。

Answer 61

要撤消 Git 中最近的本地提交，您有几个选项，具体取决于您想要执行的操作：

软重置：如果您想保留提交中的更改但只是撤消提交本身，则可以使用软重置。这会将 HEAD 指针移动到先前的提交，而不更改工作目录或暂存区域。

git reset --soft HEAD~1

此命令将从分支中删除最新的提交，但保留暂存区域中该提交的更改。然后您可以进行进一步修改或再次提交。

混合重置：如果您想撤消提交并取消暂存更改（但将它们保留在工作目录中），则可以使用混合重置。

巴什

git reset --hard HEAD~1

注意：使用git reset --hard将不可逆转地删除最近提交中所做的所有更改。在使用此命令之前，请确保您要放弃这些更改。

HEAD~1如果提交次数超过一次，请记住将其替换为您要撤消的提交次数。另外，使用重置命令时要小心，尤其是--hard，因为它可能会不可逆转地放弃更改。

Answer 62

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

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

我们来举个例子:

- 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

Answer 63

为了从 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

Answer 64

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

一些命令:

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

Answer 65

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

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

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

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

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

Answer 66

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

Answer 67

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

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

git reset HEAD^

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

Answer 69

git reset --soft HEAD~1

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

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

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

 git reset --hard HEAD~1

撤消多次提交

git reset --hard 0ad5a7a6

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

Answer 70

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

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

Answer 71

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

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

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

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

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

Answer 72

头:

在重置提交之前,我们应该知道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

这是图形表示:

Answer 73

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 初始存储库提交 \

Answer 74

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

Answer 75

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

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

git rebase --onto HEAD~1 HEAD

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

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

你想放弃提交'c'

git rebase --onto b c

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

Answer 76

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

git log

然后

git reset <the previous co>

Answer 77

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

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

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 78

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

Answer 79

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

如何删除/恢复 Git 提交

基本上你只需要做：

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

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

Answer 80

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

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 81

如果您进行了不喜欢的本地提交，并且它们尚未被推送，您可以将其重置回之前的良好提交。就好像不良提交从未发生过一样。就是这样：

在终端（终端、Git Bash 或 Windows 命令提示符）中，导航到 Git 存储库的文件夹。运行 git status 并确保您有一个干净的工作树。每个提交都有一个唯一的哈希值（看起来像 2f5451f）。您需要找到最后一次良好提交（您想要恢复到的提交）的哈希值。您可以在以下两个位置查看提交的哈希值： 在 GitHub 或 Bitbucket 或网站上的提交历史记录中。在终端（终端、Git Bash 或 Windows 命令提示符）中运行命令 git log --online 一旦您知道了最后一次良好提交（您想要恢复到的提交）的哈希值，请运行以下命令（替换 2f5451f）与你的提交的哈希值）：

git reset 2f5451f
git reset --hard 2f5451f

注意：如果您执行 git reset，提交将被删除，但更改将显示为未提交，使您可以访问代码。这是最安全的选择，因为也许您想要其中一些代码，并且现在可以进行良好的更改和新提交。通常，您会想要撤消提交并丢弃代码，这就是 git reset --hard 的作用。

Answer 82

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

git reset --hard <commit_hash>

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

Answer 83

git reset --soft HEAD~1

Soft：这将仅从本地删除提交，并按原样保留文件中完成的更改。

    git reset --hard HEAD~1
    git push origin master

硬：这将从本地和远程删除该提交，并删除文件中所做的更改。

Answer 84

使用以下命令将存储库重置为特定提交。将 n 替换为您要撤消的提交数。例如，要撤消最后 1 次提交，您可以使用：

git reset --hard HEAD~1

使用以下命令将存储库重置为特定提交。将 n 替换为您要撤消的提交数。例如，要撤消最后 3 次提交，您可以使用：

git reset --hard HEAD~3

或者，您可以使用要重置的提交的提交哈希：

git reset --hard <commit-hash>

Answer 85

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

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

2. git status// 可选的.所有文件现在都是红色的(未分级).

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

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

Answer 86

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

Answer 87

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 88

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

Answer 89

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

git reset --hard origin/branch-name

Answer 90

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

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

Answer 91

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

git log

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

git revert <commit_id>

Answer 92

git reset HEAD@{n}将重置您的最后n 个操作。

对于重置，对于最后一个操作，请使用git reset HEAD@{1}。

Answer 93

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

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

Answer 94

如果您已向 Git 提交更改，但尚未将这些更改推送到远程存储库，则可以使用该命令git reset从本地存储库撤消这些提交。

就是这样：

1. 使用 git log 命令查找要撤消的提交的提交哈希。提交哈希是一长串数字和字母，唯一标识该提交。您可以通过突出显示提交哈希并按Ctrl+ C（Windows 上）或Command+ C（macOS 上）将提交哈希复制到剪贴板。

   git log
   commit 1234567890abcdefg
   Author: Your Name <your.email@example.com>
   Date:   Mon Feb 21 13:42:24 2022 -0500
   
      Commit message goes here
   

2. --hard使用带有选项和要重置为的提交哈希的git reset 命令。这将从本地存储库中删除指定提交之后的所有提交，包括在这些提交中所做的任何更改。

   git reset --hard 1234567890abcdefg
   

   请注意，该--hard选项将永久删除自指定提交以来所做的任何更改。如果您希望将更改保留为工作目录中的未暂存更改，则可以使用该--soft选项而不是--hard.

   git reset --soft 1234567890abcdefg
   

3. 运行该git reset命令后，您可以git log再次使用该命令来验证不需要的提交是否已从本地存储库中删除。

   $ git log
   commit 1234567890abcdefg
   Author: Your Name <your.email@example.com>
   Date:   Mon Feb 21 13:42:24 2022 -0500
   
       Commit message goes here
   

如果日志中不再存在不需要的提交，则您已成功将它们从本地存储库中删除。

Answer 95

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

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

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

git fetch --all

那你做

git reset --hard origin/master

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

Answer 96

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

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

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

2.4 Git 基础 - 撤销操作

Answer 97

最简单的方法是：

$ git reset --soft HEAD~1

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

Answer 98

git revert commit

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

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

Answer 99

如何编辑较早的提交

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

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

这是工作流程：

1. git commit-edit <commit-hash>
   

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

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

2. 首先修复并分阶段提交。

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

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

   git commit --amend
   

4. 完成变基：

   git rebase --continue
   

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

git commit-edit <commit-hash>

Answer 100

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

步骤1

击中 git log

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

第2步

git reset <hash code>

Answer 101

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

[alias]
  undo = reset --soft HEAD^

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

Answer 102

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

git log

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

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

git reset --hard {insert long_hash without braces}

Answer 103

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

如何在本地和远程撤消 Git 中的提交？