繁体   English   中英

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

How do I undo the most recent local commits in Git?

提示:本站收集StackOverFlow近2千万问答,支持中英文搜索,鼠标放在语句上弹窗显示对应的参考中文或英文, 本站还提供   中文繁体   英文版本   中英对照 版本,有任何建议请联系yoyou2525@163.com。

我不小心将错误的文件提交到Git ,但还没有将提交推送到服务器。 如何从本地存储库撤消这些提交?

100 个回复

撤消提交并重做

$ 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)
  1. git reset是负责撤消的命令。 它将撤消您的最后一次提交,同时保持您的工作树(磁盘上文件的状态)不变。 您需要再次添加它们,然后才能再次提交它们)。
  2. 更正工作树文件。
  3. git add任何你想包含在你的新提交中的东西。
  4. 提交更改,重用旧的提交消息。 reset将旧头复制到.git/ORIG_HEAD 使用-c ORIG_HEAD commit将打开一个编辑器,该编辑器最初包含来自旧提交的日志消息,并允许您对其进行编辑。 如果您不需要编辑消息,则可以使用-C选项。

或者,要编辑先前的提交(或只是其提交消息)commit --amend会将当前索引中的更改添加到先前的提交。

要删除(不恢复)已推送到服务器的提交,需要使用git push origin main --force[-with-lease]重写历史记录。 使用--force几乎总是一个坏主意; 更喜欢--force-with-lease代替,并且如git 手册中所述

如果您 [rewrite history] ​​已经出版,您应该了解重写历史的含义。


延伸阅读

您可以使用git reflog来确定您希望恢复到的提交的 SHA-1 获得此值后,请使用上述命令序列。


HEAD~HEAD~1相同。 文章什么是 git 中的 HEAD? 如果您想取消提交多个提交,这很有帮助。

如果您不知道它是如何工作的,那么撤消提交有点可怕。 但是,如果您确实了解,这实际上非常容易。 我将向您展示撤消提交的 4 种不同方式。

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

   (F)
A-B-C
    ↑
  master

选项 1: git reset --hard

您想销毁提交 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 只是指向最新提交的指针。 当您执行git 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 天,因此您通常可以返回并拯救一个您不想摆脱的提交。

有两种方法可以“撤消”您的最后一次提交,具体取决于您是否已经公开提交(推送到远程存储库):

如何撤消本地提交

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

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.

要将所有内容恢复到上次提交之前的状态,我们需要resetHEAD之前的提交:

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 基础知识 - 撤消操作

添加/删除文件以按照您想要的方式获取内容:

git rm classdir
git add sourcedir

然后修改提交:

git commit --amend

先前的错误提交将被编辑以反映新的索引状态 - 换句话说,就像您从一开始就没有犯过错误一样。

请注意,只有在尚未推送时才应该这样做。 如果您已推送,那么您只需正常提交修复即可。

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

或者

git reset --hard HEAD~1

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

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

更改最后一次提交

替换索引中的文件:

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

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

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

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

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

重新登录

如果你搞砸了,你总是可以使用 reflog 来查找丢弃的提交:

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

使用git revert <commit-id>

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

如果您打算完全撤消本地提交,无论您在提交上做了什么更改,如果您对此不担心,只需执行以下命令。

git reset --hard HEAD^1

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

git reset --soft HEAD^1

现在您提交的文件进入暂存区。 假设如果你想升级文件,因为你需要编辑一些错误的内容,那么执行以下命令

git reset HEAD

现在提交的文件从暂存区进入非暂存区。 现在文件已准备好编辑,所以无论您更改什么,您都想编辑并添加它并进行全新/新提交。

更多(链接断开)存档版本

如果你安装了Git Extras ,你可以运行git undo来撤销最新的提交。 git undo 3将撤消最后三个提交。

我想撤消我们共享存储库中最近的五个提交。 我查找了要回滚到的修订 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>

我更喜欢使用git rebase -i来完成这项工作,因为会弹出一个不错的列表,我可以在其中选择要摆脱的提交。 它可能不像这里的其他一些答案那么直接,但感觉是对的

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

git rebase -i HEAD~3

样品清单

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

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

如何修复之前的本地提交

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

如何撤消先前的本地提交

只需将您的分支重置到以前的位置(例如,使用gitkgit 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以隐藏历史记录。

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

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

git log 

然后你可以这样做:

git reset --hard <commit_id>

git push origin <branch_name> -f

如果你犯了垃圾但没有被推送,

git reset --soft HEAD~1

HEAD~1是 head 之前提交的简写。 或者,如果您想重置为,您可以参考哈希的SHA-1 --soft选项将删除提交,但它将保留所有更改的文件“要提交的更改”,就像 git status 所说的那样。

如果您想摆脱自 head 之前的提交以来对工作树中跟踪文件的任何更改,请改用“ --hard ”。

或者

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

git revert HEAD

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

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

在终端上:

您也可以使用:

git revert

或者:

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

一个命令:

git reset --soft 'HEAD^' 

撤消最后一次本地提交非常有用!

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

git reset --soft HEAD~1

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

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

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

“将工作树重置为最后一次提交”

git reset --hard HEAD^ 

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

git clean    

请参阅 - Git 快速参考

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

如何撤消最后一次 Git 提交?

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

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

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

     git reset --soft HEAD^

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

使用 reflog 找到正确的状态

git reflog

重新登录之前 重置前重新记录

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

git reset --hard f3cb6e2

之后,repo HEAD 将重置为该 HEADid重置效果 复位后记录

最后 reflog 如下图所示

重新登录后重新记录决赛

第一次运行:

git reflog

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

然后做:

git reset --hard ActionIdFromRefLog

撤消上次提交:

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

这将撤消最后一次提交。

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

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


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

git commit --amend -m "message"

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

另一种方式:

签出您要恢复的分支,然后将您的本地工作副本重置回您希望成为远程服务器上最新版本的提交(之后的一切都会再见)。 为此,在 SourceTree 中,我右键单击并选择“将 BRANCHNAME 重置为此提交”。

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

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

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

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

git reset <the previous co>

就我而言,我不小心提交了一些我不想提交的文件。 所以我做了以下事情,它奏效了:

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

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

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

git reset --soft HEAD~ 

主要有两种情况

你还没有推送提交

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

你已经推送了提交

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

相反,您必须在没有--amend的情况下进行提交(请记住关于 -amend 的这一点:该选项会重写上次提交的历史记录)。

对于本地提交

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) 手册页上阅读更多内容。

使用什么, reset --softreset --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。

要重置到以前的版本,永久删除所有未提交的更改:

git reset --hard HEAD~1

有很多方法可以做到:

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

其中d81d3f1be20eb8是提交 ID。

现在让我们看一些案例:

假设您想恢复最后一次提交“d81d3f1”。 这里有两个选项:

$ git reset --hard d81d3f1

或者

$ git reset --hard HEAD~1

假设您要恢复提交“be20eb8”:

$ git reset --hard be20eb8

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

$ git reset --help

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

认为我们有code.txt文件。 我们对其进行了一些更改并提交。 我们可以通过三种方式撤消此提交,但首先您应该知道暂存文件是什么...暂存文件是准备好提交的文件,如果您运行git status该文件将显示为绿色,如果这是not staged for commit 将显示为红色:

在此处输入图像描述

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

在此处输入图像描述

撤消上次提交:

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

    git reset --soft HEAD^

    在此处输入图像描述

  2. 如果我们想撤消提交及其更改(这很危险,因为您的更改将丢失),我们可以使用

    git reset --hard HEAD^

    在此处输入图像描述

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

    git reset --mixed HEAD^或简称git reset HEAD^

    在此处输入图像描述

通常,您想要撤消提交,因为您犯了一个错误并且您想要修复它 - 本质上是 OP 在他提出问题时所做的。 真的,你真的想重做一个提交。

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

以下是使用 GUI 执行此操作的方法。 如果您安装了 Git,那么您已经拥有了遵循这些说明所需的一切。

注意:我在这里假设您在推送之前意识到提交是错误的。 如果你不知道推动是什么意思,那么你可能还没有推动。 继续按照说明进行。 如果你推送了错误的提交,风险最小的方法就是用一个新的提交来修复错误的提交,就像你在不允许你重写历史的版本控制系统中那样。

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

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

您可以使用:

git reset HEAD@{1}

此命令将在没有 Git 日志的情况下删除您的错误提交。

如果您想恢复最后一次提交,但仍想在本地保留在提交中所做的更改,请使用以下命令:

git reset HEAD~1 --mixed

撤消最后一次提交

在很多情况下,您真的想撤消对代码的最后一次提交。 例如,因为您想对其进行广泛的重组——甚至完全放弃它!

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

$ git reset --soft HEAD~1

上面的命令(reset)会将你当前的 HEAD 分支倒回到指定的版本。 在上面的示例中,我们希望返回到当前版本之前的版本——有效地使我们的最后一次提交撤消。

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

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

$ git reset --hard HEAD~1

在此处输入图像描述

只需撤消最后一次提交:

git reset --soft HEAD~

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

git reset --soft HEAD~2

或撤消任何先前的提交:

git reset --soft <commitID>

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

当您撤消先前的提交时,请记住使用

git clean

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

在回答之前,让我们添加一些背景知识,解释一下这个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 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

在此处输入图像描述

就我而言,我提交并推送到了错误的分支,所以我想要恢复所有更改,以便我可以将它们提交到新的正确分支,所以我这样做了:

在您提交和推送的同一个分支上,如果您输入“git status”,您将看不到任何新内容,因为您已提交和推送,现在输入:

    git reset --soft HEAD~1

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

git reset FILE

其中“文件”是您要再次提交的文件。 现在,这个 FILE 应该在工作目录中(未暂存),其中包含您所做的所有更改。 现在您可以更改到您想要的任何分支并在该分支中提交更改。 当然,您提交的初始分支仍然存在所有更改,但在我的情况下没关系,如果它不适合您 - 您可以寻找在该分支中恢复该提交的方法。

撤消最后一次提交:

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

这将撤消最后一次提交。

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

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

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

git commit --amend -m "message"

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

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

右键单击提交,然后选择Reset (current branch)/master to this commit ”,最后选择“Soft”reset

在此处输入图像描述

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

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

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

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

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

现在我们使用以下命令将这个好的提交强制推送到远程存储库:

git push --force-with-lease

force 选项的“with-lease”版本将防止意外删除您不知道的新提交(即,自上次拉取后来自另一个来源)。

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

如果您无法在 Visual Studio 中同步,因为您不允许推送到像“开发”这样的分支,那么正如我所尝试的那样,在 Visual Studio 中, REVERTRESET (硬或软)都不会起作用。

根据大量投票的答案:

在项目根目录的命令提示符下使用它来消除任何试图被推送的东西:

git reset --hard HEAD~1

备份或压缩文件以防万一您不希望丢失任何工作等...

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

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

git reset --hard HEAD~1

现在要真正推动该更改以摆脱您的最后一次提交,您必须

git push --force

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

一个典型的 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. 解决发生冲突时的先决条件配置合并工具

    git mergetool #resolve merging here, also can manually merge

  8. 添加已解决冲突的文件,例如file1

    git add $file1

  9. 继续我之前的变基命令

    git rebase --continue

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

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

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

git reset --soft HEAD~1

重置会将您当前的 HEAD 分支倒回到指定的修订版。 在上面的示例中,我们希望返回到当前版本之前的版本——有效地使我们的最后一次提交撤消。

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

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

git reset --hard HEAD~1

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

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

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

例如。 如果最新的提交 ID 错误,则在上面的 git 命令中使用分支名称指定上一个提交 ID。

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

为了摆脱(所有更改)最后一次提交、最后 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。

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

git checkout commitID .

例子:

git checkout 7991072 .

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

你需要做的简单快速

    git commit --amend

如果它是私人分支机构或

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

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

执行以下步骤。

步骤1

点击git log

从日志列表中,找到最后一次提交的哈希码,然后输入:

第2步

git reset <hash code>

使用此命令

git checkout -b old-state 0d1d7fc32

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

使用这个命令:

git checkout -b old-state number_commit

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

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

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

其次是你可以使用git reset ,它会删除你所有的提交历史并把你的头带到你想要的地方。

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

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

git reset --soft HEAD~1

重置会将您当前的 HEAD 分支倒回到指定的修订版。

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

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

 git reset --hard HEAD~1

撤消多个提交

git reset --hard 0ad5a7a6

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

在此处输入图像描述

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

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

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

Git 扩展屏幕截图

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

恢复提交弹出窗口

如果您想直接提交恢复的更改,或者如果您想手动提交恢复的更改,请选择“自动创建提交”,保持该框未选中并单击“恢复此提交”按钮。

我发现这个站点描述了如何撤消您已提交到存储库中的内容。

一些命令:

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

这是网站: Oh shit, git! .

这里有很多关于如何在 Git 中撤消操作的方法。 他们中有一些:

哦,该死,我需要在上次提交时更改消息!

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

哦该死,我不小心提交了一些应该在一个全新分支上的东西!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

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

在下图中,我检查了“测试”分支(使用 Git 命令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尚未提交。

在此处输入图像描述

git reset --mixed、--soft 和--hard 的区别

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

举个例子:

- A - B - C (master)

HEAD指向C并且索引匹配C

- 柔软的

  • 当我们执行git reset --soft B删除提交 C并将master/HEAD 指向 B 时
  • master/HEAD 现在将指向 B,但索引仍然从 C 更改
  • 执行git status时,您可以看到在提交 C中索引的文件为staged
  • 此时执行git commit将创建一个新的提交,其更改与 C 相同

--混合

  • 执行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 中所做的所有更改以及未提交的更改

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

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

git reset HEAD^

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

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

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

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

如果你喜欢的 Git 客户端再见(看着你,egit),这有时是必要的。

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

撤消一系列本地提交

OP:如何撤消 Git 中最近的本地提交? 我不小心提交了错误的文件 [作为几个提交的一部分]。

开始案例

有几种方法可以“撤消”作为一系列提交,具体取决于您所追求的结果。 考虑到下面的 start case, resetrebasefilter-branch都可以用来重写你的历史。

明星案例

如何撤消C1C2以从每次提交中删除tmp.log文件?

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

备选方案 1: reset

$ git reset --soft t56pi

使用重置

使用reset ,可以将分支重置为先前的状态,并且将任何复合更改还原到暂存区域,然后可以丢弃任何不需要的更改。

注意:由于reset所有先前的更改聚集到Staging Area中,因此单个提交元数据会丢失。 如果这对您不利,那么您可能最好使用rebasefilter-branch代替。

备选方案 2: rebase

$ git rebase --interactive t56pi

使用变基

使用交互式rebase可以重写分支中的每个违规提交,从而允许您修改和丢弃不需要的更改。 在上面的信息图中,右侧的源代码树说明了状态 post rebase

一步步

  1. 选择 rebase 应该基于哪个提交(例如t56pi
  2. 通过将pick替换为edit来选择您要更改的提交。 保存并关闭。
  3. Git 现在将在每个选定的提交上停止,允许您重置HEAD 、删除不需要的文件并创建全新的提交。

注意:与上面的reset选项相比,使用rebase会保留大部分提交元数据。 如果您想保留大部分历史记录但只删除不需要的文件,这很可能是首选选项。

备选方案 3: filter-branch

$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD

上面的命令将从所需范围t56pi..HEAD内的所有提交中过滤掉文件./tmp.log (假设我们从上面开始的初始情况)。 为清楚起见,请参见下图。

使用过滤器分支

rebase类似, filter-branch可用于从分支的子部分中清除不需要的文件。 filter-branch可以自动对每个提交执行所需的操作,而不是通过 rebase 过程手动编辑每个提交。

注意:就像rebase一样, filter-branch将保留提交元数据的其余部分,只丢弃所需的文件。 请注意C1C2是如何被重写的,并且每次提交都丢弃了日志文件。

结论

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

最后 - 一个友好的建议

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

资料来源:以上所有示例均来自此博客

头:

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

Git 提交:

在由唯一标记表示的提交下分配的每个更改。 不能删除提交。 因此,如果您想要最后一次提交,您可以简单地使用git reset进行深入研究。

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

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

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

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

git reset 0xab3 # 提交号

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

这是图形表示:

在此处输入图像描述

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

我验证了一种有效的方法,这是一个使用它的具体示例:

如果您想永久撤消/取消您的最后一次提交(依此类推,一个一个,任意多个)三个步骤:

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

如果您想消除错误的文件,您应该这样做

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

像下面这样。

git reset wrongFile1 wrongFile2 wrongFile3

你现在可以只添加你需要推送的文件,

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

git reset --soft HEAD~1

git status

输出

在分支主
您的分支领先于 'origin/master' 1 次提交。
(使用“git push”发布你的本地提交)

要提交的更改:
(使用“git restore --staged ...”取消暂存)新文件:file1

git log --oneline --graph

输出

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

在回答之前,让我们添加一些背景知识,解释一下这个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 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

在此处输入图像描述

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

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

如果您必须放弃最顶层的提交,那么以下单行代码会有所帮助

git rebase --onto HEAD~1 HEAD

但是如果你想放弃你确实说过的许多提交中的 1 个

a -> b -> c -> d -> 主

你想放弃提交'c'

git rebase --onto b c

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

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

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

  2. git status // 可选的。 所有文件现在都显示为红色(未暂存)。

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

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

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

[alias]
  undo = reset --soft HEAD^

然后我简单地使用git undo ,它超级容易记住。

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

git log

然后

git reset <the previous co>

在此处输入图像描述

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

替换您的本地版本,包括您对服务器版本所做的更改。 这两行代码将强制 Git 拉取并覆盖本地。

打开命令提示符并导航到 Git 项目根目录。 如果您使用 Visual Studio,请单击TeamSync并单击下面的“打开命令提示符”(见图)。

视觉工作室

进入 Cmd 提示符后,继续执行以下两个指令。

git fetch --all

然后你做

git reset --hard origin/master

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

在我自己遇到同样的问题之后,我在很久以前写过这个:

如何删除/恢复 Git 提交

基本上你只需要这样做:

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

您也可以使用 Git revert 命令恢复它,如下所示: git revert <sha> -m -1然后git push

试试这个,硬重置到未添加这些文件的先前提交,然后:

git reset --hard <commit_hash>

确保备份更改以防万一,因为这是硬重置,这意味着它们会丢失(除非你之前隐藏了)

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

git reset --hard origin/branch-name

如果您想撤消仓库中的第一次提交

你会遇到这个问题:

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

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

git log

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

git revert <commit_id>

如何编辑较早的提交

一般来说,我不想撤销一堆提交,而是编辑一个较早的提交,以我希望我首先提交它的方式。

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

这是工作流程:

  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

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

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

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

Visual Studio Code 使这变得非常容易。

VS 代码

#1) $ git commit -m "Something terribly misguided" 
#2) $ git reset HEAD~                              

[根据需要编辑文件]

 #3) $ git add .
#4) $ git commit -c ORIG_HEAD  
git revert commit

这将从您想要恢复的提交中生成相反的更改,然后只需提交该更改。 我认为这是最简单的方法。

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

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

重要的是要了解,当您修改上一次提交时,与其说是修复它,不如说是用一个新的、改进的提交完全替换它,将旧的提交推到一边,并把新的提交放在它的位置上。 实际上,就好像以前的提交从未发生过,并且它不会显示在您的存储库历史记录中。

修改提交的明显价值是对您的最后一次提交进行微小的改进,而不会因为“糟糕,忘记添加文件”或“该死,修复最后一次提交中的错字”等形式的提交消息而弄乱您的存储库历史记录。

2.4 Git 基础——撤消操作

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

git log

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

复制这个long_hash并重置它(返回到相同的文件/状态,它是在那个提交上):

git reset --hard {insert long_hash without braces}

最简单的方法是:

$ git reset --soft HEAD~1

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

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

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

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

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

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

首先,运行此命令以重置提交

git reset --hard HEAD~1

其次,运行这个命令来推送新的提交

git push upstream head -f

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

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

如果您想恢复到最后一次提交并删除日志历史记录

使用下面的命令,假设您想转到具有 commitID SHA - 71e2e57458bde883a37b332035f784c6653ec509的上一个提交,您可以指向此提交,在此提交之后它不会显示任何日志消息,之后所有历史记录都将被删除。

git 推送来源 +71e2e57458bde883a37b332035f784c6653ec509^:master

git reset --soft HEAD~1

软:这将仅从本地删除提交,并保持文件中的更改原样。

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

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

如果您使用的是GitHub 桌面,则左侧蓝色Commit to BRANCH_NAME按钮下方将有一个撤消按钮

在此处输入图片说明

如果您想在完成更多工作后保留您的工作并提交,那么您可以使用--amend<\/code>标志覆盖上次提交。

例子 :-<\/h3>
注意事项:-<\/h3> 
      
  1. 如果要保留提交消息,请使用--no-edit<\/code>标志而不是-m<\/code><\/li>
  2. 如果您已经推送了错误的提交,那么您将不得不--force<\/code>推送更正的提交<\/li><\/ol>"

如果你做了你不喜欢的本地提交,并且它们还没有被推送,你可以将事情重置回之前的良好提交。 就好像错误的提交从未发生过一样。 就是这样:

在您的终端(终端,Git Bash 或 Windows 命令提示符)中,导航到 Z0BCC50105AD2479506 存储库的文件夹。 运行 git status 并确保你有一个干净的工作树。 每个提交都有一个唯一的 hash(看起来像 2f5451f)。 您需要找到 hash 以获得最后一次良好的提交(您想要恢复的那个)。 这里有两个地方可以看到 hash 提交:在 GitHub 或 Bitbucket 或网站的提交历史记录中。 In your terminal (Terminal, Git Bash, or Windows Command Prompt) run the command git log --online Once you know the hash for the last good commit (the one you want to revert back to), run the following command (replacing 2f5451f与您的提交的哈希):

git reset 2f5451f
git reset --hard 2f5451f

注意:如果您执行 git 重置,提交将被删除,但更改将显示为未提交,让您可以访问代码。 这是最安全的选择,因为也许您想要一些代码,并且您现在可以进行更改和新的提交。 通常,尽管您希望撤消提交并丢弃代码,这就是 git reset --hard 所做的。

1 在Git中撤消本地提交

我知道这个问题已经被问了数千次了,我尝试了所有解决方案,但都没有成功。 我提交了本地2-3个文件,现在我想撤消提交。 我该怎么做:这也是有史以来的第一次提交。 更新: 更新2: ...

2017-11-17 12:11:23 3 249   git
2 如何在GIT中撤消6次本地提交?

我是GIT的新手。 我尝试将代码提交到自己的分支机构。 commit可以正常工作,但push会失败,因为我没有遵循标准的 push注释(此处不是问题)。 现在,我有6个失败的提交。 git status表示: 您的分支比“ branchX”领先6次提交。 如何撤消所有失败的提交? ...

2015-07-29 12:02:13 2 45   git
3 Git:如何撤消本地提交和添加文件?

我错误地将文件添加到master和承诺中。 否则我必须在分支feature_x 现在我知道有像git reset这样的命令。 我的问题是,如果我重置一下,它会撤消我的代码还是只撤消文件并在master提交? 如何在不丢失代码的情况下避免重置事物? 更新 代码还没有被推 ...

4 如何撤消git本地和远程提交而不丢失更改

我们在远程存储库中有一个项目。 最近,我创建了一个新分支“ Feature7”,进行了巨大的更改,两次提交,两次提交。 幸运的是,没有人从那个分支中撤出。 之后,有很多提交和推送到master分支中,但是没有人在Feature7分支上工作。 现在,我想撤消Feature7分支的两个提 ...

5 当我检查最近的提交时,为什么 Git 会撤消变基过程?

亲爱的, 我想删除 git 存储库上的一个非常旧的提交,但是在执行变基过程并对我的存储库的最后一个分支进行签出之后,该过程正在被撤消。 所以,这就是我正在做的事情: 更改 HEAD,只是为了便于阅读: 此时,我编辑 rebase 显示的待办事项,将文本从选择更改为编辑。 现在我正在修改提交中的文件 ...

6 Git如何撤消最近的合并提交,然后更改为变基

提交历史在远程和本地上看起来像这样: 我犯了一个错误,因此将“ b”和“ c”合并到“合并”点。 我真正想做的是创造a-b-c之类的历史。 我知道我应该使用rebase而不是merge,现在我已将合并结果推送到服务器。 我想知道如何修改遥控器上的历史记录。 谢谢! ...

2018-10-17 02:39:22 2 20   git
7 如何永久撤消git remote的最近提交,但将其保存在本地?

我做了一个git repo(只有一个master分支),其中有一个远程和一个本地。 没有其他用户克隆了它,但是远程路径可以由几个用户克隆。 我的本地克隆在提交#17处,而我将直到提交#12推送到远程。 我已经意识到,不应该共享#6之后的每个提交,并且远程需求(目前)仍保持在#6。 ...

8 撤消Git拉取而不会丢失以前未提交的本地文件

我刚刚从Master分支进行了一次git pull。 但是,我丢失了所有本地更改和文件。 我没有提交更改。 自从我提交以来已经很长时间了。 有没有办法撤销我最近执行的git pull的操作,而又不会丢失本地文件(现在不存在了)? ...

9 Git-如何撤消在错误的本地分支中的提交?

我的Git设置使我可以在本地“功能”分支中工作,并在我工作时将更改提交到该分支。 代码准备就绪后,我将合并到本地的“ develop”分支中。 然后,我将本地“开发”分支中的更改推送到远程“开发”分支。 我对文件进行了一些更改,并提交了这些更改,却没有意识到自己在本地的“ develo ...

2019-03-01 21:42:56 3 92   git
10 如何撤消对Git的近期提交

假设我掌握了此日志: 提交6(头) 提交5 提交4 提交3 提交2 提交1 我想撤消提交3,以便获得此日志: 提交6(头) 提交5 提交4 提交2 提交1 如果我使用还原提交3来执 ...

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2022 STACKOOM.COM