【问题标题】:Undo a Git merge that hasn't been pushed yet撤消尚未推送的 Git 合并
【发布时间】:2011-01-24 06:22:29
【问题描述】:

在我的 master 分支中,我在本地执行了 git merge some-other-branch,但从未将更改推送到 origin master。我不是要合并,所以我想撤消它。在合并后执行git status 时,我收到了以下消息:

# On branch master
# Your branch is ahead of 'origin/master' by 4 commits.

基于一些instructions I found,我尝试运行

git revert HEAD -m 1

但现在我收到了git status 的这条消息:

# On branch master
# Your branch is ahead of 'origin/master' by 5 commits.

我不希望我的分支领先于任何数量的提交。我该如何回到那个时候?

【问题讨论】:

标签: git undo git-merge


【解决方案1】:

如果您正在合并,您可以随时中止它

git merge --abort

【讨论】:

  • 谢谢兄弟,我正要做那些可怕的事情正确答案。幸运的是我向下滚动。我只想删除合并头
【解决方案2】:

如果分支被合并而不被推送,那么下面给出的 git reset 命令将用于撤消合并:

git reset --merge ORIG_HEAD

【讨论】:

  • 示例:git reset --merge origin/master
【解决方案3】:

回答问题“撤消尚未推送的 Git 合并

你可以使用git reset --hard HEAD~1

考虑以下情况,其中有 2 个分支 ma​​sterfeature-1


$ git log --graph --oneline --all

做 Git 合并

$ git merge feature-1

$ git log --graph --oneline --all

撤消 Git 合并

$ git reset --hard HEAD~1

$ git log --graph --oneline --all

【讨论】:

    【解决方案4】:

    只需创建新分支,然后对其进行挑选所需的提交。

    上面的许多答案中描述了它的保护程序和更简单的重置

    【讨论】:

    • 我同意这个建议,特别是如果您对列出的 git 命令并不完全满意。这可能会因更多的“辛劳”而变慢,但如果它不会出现太多并且您担心失去工作,那么值得付出努力。
    【解决方案5】:

    你必须改变你的 HEAD,当然不是你的,而是 git HEAD....

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

    每次修改 HEAD 时,reflog 中都会有一个新条目

    git reflog
    git checkout HEAD@{...}
    

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


    git reset --hard &lt;commit_id&gt;

    “移动”你的 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.
    
    • 注意:(Since Git 2.7)
      您也可以使用git rebase --no-autostash

    git revert &lt;sha-1&gt;

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

    # 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 &amp;&amp; checkout 修改 HEAD

    【讨论】:

    • 这是宝物?‍??‍??‍?
    【解决方案6】:

    它可以通过多种方式完成。

    1) 中止合并

    如果您处于错误合并之间(错误地使用错误的分支完成),并且希望避免合并返回到最新的分支,如下所示:

    git merge --abort
    

    2) 将 HEAD 重置为远程分支

    如果您在远程开发分支上工作,您可以将 HEAD 重置为远程分支上的最后一次提交,如下所示:

    git reset --hard origin/develop
    

    3) 删除当前分支,并从远程仓库再次签出

    考虑到,您正在本地仓库中开发分支,与远程/开发分支同步,您可以执行以下操作:

    git checkout master 
    ##to delete one branch, you need to be on another branch, otherwise you will fall with the branch :) 
    
    git branch -D develop
    git checkout -b develop origin/develop
    

    【讨论】:

    • “1) Abort Merge”已经足够了。点赞。
    • 小心! git merge --abort "只能在合并导致冲突后运行。git merge --abort 将中止合并过程并尝试重建合并前状态"
    • git reset --hard origin/develop 这就是我要找的,谢谢!
    【解决方案7】:
    1. git stash

    2. git branch -d the_local_branch

    3. git checkout -t &lt;name of remote&gt;

    4. git stash apply

    这对我有用..!!

    【讨论】:

      【解决方案8】:

      使用git reflog 检查哪个提交是合并之前的提交(git reflog 将是比git log 更好的选择)。然后您可以使用以下方法重置它:

      git reset --hard commit_sha
      

      还有另一种方式:

      git reset --hard HEAD~1
      

      它会让你恢复 1 次提交。

      请注意,任何已修改和未提交/未存储的文件都将重置为未修改状态。为了让他们保留更改,或者查看下面的--merge 选项。


      正如@Velmont 在他的回答中建议的那样,在这种直接情况下使用:

      git reset --hard ORIG_HEAD
      

      可能会产生更好的结果,因为它应该保留您的更改。 ORIG_HEAD 将直接指向合并发生之前的提交,因此您不必自己寻找它。


      另一个提示是使用--merge 开关而不是--hard,因为它不会不必要地重置文件:

      git reset --merge ORIG_HEAD
      

      --合并

      重置索引并更新工作树中 和 HEAD 之间不同的文件,但保留索引和工作树之间不同的文件(即具有尚未添加的更改)。

      【讨论】:

      • 我不认为这会(总是?)工作 - “合并之前的一个”将是从另一个分支合并的最新提交 - 它不会当前分支上的最新提交。正确的? (这可能只是git log 选择默认显示的结果——也许git loggit reflog 的不同输出可用于此)
      • 我认为这可能取决于你是否压缩合并。
      • @JohnBachir 是对的。在git log 输出中,您想查看两个父提交。一个是您分支中的最新提交,一个是您合并到的分支中的最新提交。你想git reset --hard 到你合并到的分支上的父提交。
      • @JohnBachir:只要“合并”不是真正的快进,它将导致日志顶部的新提交,并且该提交有两个父级(或如果您进行章鱼合并,则超过 2 个)。如果你删除了这个合并提交,那么来自合并的所有旧提交也将消失。不过,为了安全起见,在重置后 git 会告诉你新的 head 在哪里:“HEAD 现在位于 88a04de ”。我总是看着那个,以确保我最终到达了我期望的位置。我的项目使用标准的分支命名方案来保持记忆。
      • 我发现有用的是查看“git reflog”并查找我在 master 中所做的最后一次提交。然后做git reset --hard &lt;commit_sha&gt;
      【解决方案9】:

      我能够通过一个不涉及查找提交 ID 的命令解决此问题。

      git reset --hard remotes/origin/HEAD
      

      接受的答案对我不起作用,但此命令达到了我正在寻找的结果。

      【讨论】:

      • 没错!它将您的更改重置为分支的 HEAD!不一个一个做
      • 对我不起作用。实际上最终将当地分支机构送回一两个月。谢天谢地,这都是本地的,所以我总是可以销毁分支并再次获取它。只是想指出这一点,以防其他人尝试这样做。
      • @MattPengelly 这种方法在很大程度上没有记录在案,如果您的分支在合并之前与远程分支同步,则通常可以使用。您的分支与远程分支同步有几个月了吗?
      • @MattPengelly 它还取决于 HEAD 指向的分支。我在我的一个项目上使用 gitflow,即使我在开发分支上,遥控器/原点/头指向原点/主,所以如果我需要撤消合并,我可能需要重置为遥控器/起源/发展
      【解决方案10】:

      在这种情况下,您需要使用git reset --hard &lt;branch_name&gt; 重置您的分支。如果您想在重置之前保存更改,请务必创建一个新分支和git checkout &lt;branch_name&gt;

      您也可以使用git reset --hard &lt;commit_id&gt; 将状态重置为特定提交。

      如果更改已被推送,您可以改用git revert &lt;branch_name&gt;。请务必查看如何在其他场景中使用git revert and git checkout

      【讨论】:

        【解决方案11】:

        最简单的答案是odinho - Velmont给出的答案

        先做git reset --merge ORIG_HEAD

        对于那些希望在推送更改后重置的用户,请执行此操作 (因为这是任何 git reset 合并问题的第一篇文章)

        git push origin HEAD --force

        这将以一种在拉取后不会再次恢复合并更改的方式重置。

        【讨论】:

          【解决方案12】:

          对于较新的 Git 版本,如果您尚未提交合并并且您有合并冲突,您可以简单地执行以下操作:

          git merge --abort
          

          来自man git merge

          [This] 只能在合并导致冲突后运行。 git merge --abort 将中止合并过程并尝试重建预合并状态。

          【讨论】:

          • 他的合并已提交但未推送(见标题),他已合并,您的命令仅在他仍在合并中时才有效
          【解决方案13】:

          得到这个问题也希望恢复到匹配原点(即,在原点之前没有提交)。进一步研究,发现有一个 reset 命令正是为此:

          git reset --hard @{u}

          注意:@{u}origin/master 的简写。 (当然,您需要远程存储库才能使其工作。)

          【讨论】:

            【解决方案14】:

            策略:从一切都很好的地方创建一个新分支。

            理由:恢复合并很难。有太多的解决方案,取决于许多因素,例如您是否已提交或推送您的合并,或者自合并后是否有新的提交。此外,您仍然需要对 git 有比较深入的了解才能使这些解决方案适应您的情况。如果你盲目地遵循一些指令,你可能会得到一个“空合并”,其中不会合并任何内容,进一步的合并尝试会让 Git 告诉你“已经是最新的”。

            解决方案:

            假设您要将dev 合并到feature-1

            1. 找到您想要接收合并的修订:

              git log --oneline feature-1
              a1b2c3d4 Merge branch 'dev' into 'feature-1' <-- the merge you want to undo
              e5f6g7h8 Fix NPE in the Zero Point Module <-- the one before the merge, you probably want this one
              
            2. 检查一下(回到过去):

              git checkout e5f6g7h8
              
            3. 从那里创建一个新分支并检查它:

              git checkout -b feature-1
              

            现在您可以重新开始合并:

            1. 合并:git merge dev

            2. 修复合并冲突。

            3. 提交:git commit

            4. 对结果满意后,删除旧分支:git branch --delete feature-1

            【讨论】:

              【解决方案15】:
              1. 首先,确保您已提交所有内容。

              2. 然后将您的存储库重置为之前的工作状态:

                $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36
                

                或使用--hard这将删除所有本地的、未提交的更改!):

                $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36 --hard
                

                使用错误合并提交之前的哈希值。

              3. 通过以下方式在上一个正确版本的顶部检查您要重新提交的提交:

                $ git log 4c3e23f529b581c3cbe95350e84e66e3cb05704f
                
                commit 4c3e23f529b581c3cbe95350e84e66e3cb05704f
                
                ...
                
                commit 16b373a96b0a353f7454b141f7aa6f548c979d0a
                
                ...
                
              4. 通过以下方式将您的正确提交应用到您的存储库的正确版本的顶部:

                • 通过使用cherry-pick(一些现有提交引入的更改)

                      git cherry-pick ec59ab844cf504e462f011c8cc7e5667ebb2e9c7
                  
                • 或者通过以下方式挑选提交范围:

                  • 在合并之前首先检查正确的更改:

                    git diff 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
                    
                  • 在合并之前首先检查正确的更改:

                    git cherry-pick 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
                    

                    这是您已提交的正确提交的范围(不包括错误提交的合并)。

              【讨论】:

                【解决方案16】:

                如果您提交了合并:

                git reset HEAD~1
                # Make sure what you are reverting is in fact the merge files
                git add .
                git reset --hard
                

                【讨论】:

                  【解决方案17】:

                  使用现代 Git,您可以:

                  git merge --abort
                  

                  旧语法:

                  git reset --merge
                  

                  老派:

                  git reset --hard
                  

                  但实际上,值得注意的是,git merge --abort 仅等效于 git reset --merge,因为存在 MERGE_HEAD。这可以在合并命令的 Git 帮助中阅读。

                  git merge --abort is equivalent to git reset --merge when MERGE_HEAD is present.
                  

                  合并失败后,当没有MERGE_HEAD时,可以用git reset --merge撤消失败的合并,但不一定用git merge --abort所以它们不仅是相同的新旧语法事情

                  就我个人而言,我发现git reset --merge 在日常工作中更加强大和有用,所以我一直使用它。

                  【讨论】:

                  • 对我来说效果很好。其他所有帖子都说这太复杂了,但这完全符合预期。我想它只是因为存在冲突而起作用,这并不能完全回答最初的问题。
                  • 这个答案没有关注 OP 的情况,并且忽略了重要的上下文。
                  • 谢谢! git reset --mergegit apply --3way 失败后提供了帮助,而其他答案却没有。这似乎是因为没有 MERGE_HEAD。
                  【解决方案18】:

                  如果你想要一个命令行解决方案,我建议只使用 MBO 的答案。

                  如果您是新手,您可能会喜欢图形化方法:

                  1. 启动gitk(从命令行,或在文件浏览器中右键单击,如果有的话)
                  2. 您可以在那里轻松地发现合并提交 - 从顶部算起的第一个节点,有两个父节点
                  3. 点击第一个/左父级的链接(合并前当前分支上的那个,对我来说通常是红色的)
                  4. 在选定的提交上,右键单击“将分支重置到此处”,在此处选择硬重置

                  【讨论】:

                    【解决方案19】:

                    奇怪的是缺少最简单的命令。大多数答案都有效,但要撤消您刚刚所做的合并,这是一种简单安全的方法

                    git reset --merge ORIG_HEAD
                    

                    引用 ORIG_HEAD 将指向合并之前的原始提交。

                    --merge 选项与合并无关。它就像git reset --hard ORIG_HEAD,但更安全,因为它不会触及未提交的更改。)

                    【讨论】:

                    • 如果您此后弄脏了工作树,git reset --merge ORIG_HEAD 会保留这些更改。
                    • 这是 only 正确答案(我并不是说这是最佳答案 - 请注意区别)。假设,在 master 上,我在 t1、t3 和 t5 做了 3 次提交。假设在 branch1 上,我在 t2、t4 和 t6 做了 3 个 cmets(假设 t1、t2、t3、t4、t5 和 t6 按时间顺序排列)。任何类似于git reset --hard HEAD~5 的命令只会重置 HEAD(可能会删除 master 和 branch1 中的提交)。只有--merge 选项会删除merge
                    • @Manu --merge 选项实际上并没有删除合并,您可以使用--hard 它也可以正常工作。此处的线索是参考 ORIG_HEAD,它是在您合并到您所在的位置之前设置的。 :)
                    • @yingted “如果你已经弄脏了你的工作树,那么 git reset --merge ORIG_HEAD 会保留这些更改”是什么意思。您的意思是合并后更改文件吗?无论如何,我做了合并,然后做了一些解决冲突。但是后来我想重置合并并按照此答案中的说明进行操作。一切都很好,它没有保留我在合并后所做的更改。我的本地仓库与我进行合并之前的位置相似。
                    • git reset --hard ORIG_HEAD 命令对我来说非常有效——这可能是因为在我试图撤消本地 git merge 之后我没有对存储库进行任何其他更改。该命令只是将存储库的状态重置为合并之前的状态。感谢您的精彩提示!
                    【解决方案20】:

                    如果您的合并和相应的提交尚未推送,您可以随时切换到另一个分支,删除原始分支并重新创建它。

                    例如,我不小心将一个开发分支合并到 master 中并想撤消它。使用以下步骤:

                    git checkout develop
                    git branch -D master
                    git branch -t master origin/master
                    

                    瞧! Master与origin处于同一阶段,你的错误合并状态被擦除。

                    【讨论】:

                    • 注意:这不仅会撤消合并,还会撤消自最近一次推送到原点后所做的任何本地提交。
                    【解决方案21】:

                    参见chapter 4 in the Git bookthe original post by Linus Torvalds

                    要撤消已被推送的合并

                    git revert -m 1 commit_hash
                    

                    如果您再次提交分支,请务必还原 revert,就像 Linus 所说的那样。

                    【讨论】:

                    • @perfectist 同意 :) 有点希望有办法将此答案迁移到另一个问题——(也许有?)
                    • 有关还原的更多信息:link
                    • 为了确信这个恢复工作,你可以做 git diff hash1 hash2 其中 hash1 是提交的恢复,而 hash2 是你试图恢复其状态的旧提交回到。没有输出==成功!通过多次执行此操作,我能够回滚多个提交,首先是还原最近的合并并向后工作。 git diff 向我展示了我最终达到了我想要的状态。
                    • 请注意,实际上解决了原始发帖人的问题。原发帖人已经使用了git revert -m 1 &lt;commit&gt;。问题是这样做并没有消除他所做的意外合并(并且尚未推送)。涉及硬重置的其他答案更适合原始发布者的问题。
                    • 这是直接来自 Github 的绝佳资源:How to undo (almost) anything with Git
                    【解决方案22】:

                    好的,这里其他人给我的答案很接近,但它不起作用。这就是我所做的。

                    这样做...

                    git reset --hard HEAD^
                    git status
                    

                    ...给了我以下状态。

                    # On branch master
                    # Your branch and 'origin/master' have diverged,
                    # and have 3 and 3 different commit(s) each, respectively.
                    

                    然后我不得不多次输入相同的git reset 命令。每次我这样做时,消息都会改变一个,如下所示。

                    > git reset --hard HEAD^
                    HEAD is now at [...truncated...]
                    > git status
                    # On branch master
                    # Your branch and 'origin/master' have diverged,
                    # and have 3 and 3 different commit(s) each, respectively.
                    > git reset --hard HEAD^
                    HEAD is now at [...truncated...]
                    > git status
                    # On branch master
                    # Your branch and 'origin/master' have diverged,
                    # and have 2 and 3 different commit(s) each, respectively.
                    > git reset --hard HEAD^
                    HEAD is now at [...truncated...]
                    > git status
                    # On branch master
                    # Your branch and 'origin/master' have diverged,
                    # and have 1 and 3 different commit(s) each, respectively.
                    > git reset --hard HEAD^
                    HEAD is now at [...truncated...]
                    > git status
                    # On branch master
                    # Your branch is behind 'origin/master' by 3 commits, and can be fast-forwarded.
                    

                    此时,我看到状态消息发生了变化,所以我尝试了git pull,这似乎奏效了:

                    > git pull
                    Updating 2df6af4..12bbd2f
                    Fast forward
                     app/views/truncated |    9 ++++++---
                     app/views/truncated |   13 +++++++++++++
                     app/views/truncated |    2 +-
                     3 files changed, 20 insertions(+), 4 deletions(-)
                    > git status
                    # On branch master
                    

                    长话短说,我的命令归结为:

                    git reset --hard HEAD^
                    git reset --hard HEAD^
                    git reset --hard HEAD^
                    git reset --hard HEAD^
                    git pull
                    

                    【讨论】:

                    • 或者你可以使用HEAD^^^^
                    • 甚至可以重置为origin/master ;)
                    【解决方案23】:

                    您应该重置为之前的提交。这应该有效:

                    git reset --hard HEAD^
                    

                    甚至HEAD^^ 来恢复该恢复提交。如果您不确定应该退后多少步,您可以随时提供完整的 SHA 参考。

                    如果您遇到问题并且您的主分支没有任何本地更改,您可以重置为origin/master

                    【讨论】:

                    • 最好的答案恕我直言,结合了 OP 自己的一个(假设只有 1 个步骤可以恢复,这在 Q 中似乎是这种情况),以及 randomguy3 的快捷方式一个(当“你的主人分支没有任何本地更改")
                    • 你们这些评论者,@Inger 和@Konstantin,为什么?您是在我的答案创建后来到这里的,而且更正确。仅仅向上走一步通常是错误的,你必须实际计算你需要走多远。 Git 已经为你设置了ORIG_HEAD,为什么不用呢?
                    • 它也会重置本地更改吗? #请更新。
                    • 这对我来说非常有效,像这样重置头部比这里的一半答案更有意义。
                    • HEAD^ 等于在 HEAD 之前提交? ^^ 是之前的两次提交吗?猜测这不适用于快进合并?
                    【解决方案24】:

                    最简单的机会,比这里所说的要简单得多:

                    删除您的本地分支(本地,而不是远程)并再次拉取它。这样,您将撤消主分支上的更改,并且任何人都会受到您不想推送的更改的影响。重新开始。

                    【讨论】:

                      【解决方案25】:

                      如果您发现需要在合并后立即恢复,并且在合并尝试后您没有执行任何其他操作,您可以发出以下命令: git reset --hard HEAD@{1}.

                      基本上,如果合并后没有提交任何其他内容,您的合并 sha 将指向 HEAD@{0},因此 HEAD@{1} 将是合并前的前一点。

                      【讨论】:

                        【解决方案26】:

                        最近,我一直在使用 git reflog 来帮助解决这个问题。这主要只在合并刚刚发生并且它在您的机器上时才有效。

                        git reflog 可能会返回如下内容:

                        fbb0c0f HEAD@{0}: commit (merge): Merge branch 'master' into my-branch
                        43b6032 HEAD@{1}: checkout: moving from master to my-branch
                        e3753a7 HEAD@{2}: rebase finished: returning to refs/heads/master
                        e3753a7 HEAD@{3}: pull --rebase: checkout e3753a71d92b032034dcb299d2df2edc09b5830e
                        b41ea52 HEAD@{4}: reset: moving to HEAD^
                        8400a0f HEAD@{5}: rebase: aborting
                        

                        第一行表示发生了合并。第二行是我合并之前的时间。我只是 git reset --hard 43b6032 强制此分支从合并之前开始跟踪,然后继续。

                        【讨论】:

                        • 很好的答案,谢谢!需要撤消合并,但其他答案只是把它搞砸了,使用 reflog 获取 SHA 并将其传递给 git reset 工作。
                        • 非常感谢 :) 拯救了我的一天。
                        • 这绝对拯救了我的一天,以前从未使用过 git reflog,谢谢一百万
                        【解决方案27】:

                        您只能使用两个命令来恢复合并或通过特定提交重新启动:

                        1. git reset --hard commitHash(你应该使用你想要重启的提交,例如44a587491e32eafa1638aca7738)
                        2. git push origin HEAD --force(发送新的本地master分支到origin/master)

                        祝你好运,继续前进!

                        【讨论】:

                          【解决方案28】:

                          您可以使用git reflog 查找以前的结帐。有时这是您想要回到的良好状态。

                          具体来说,

                          $ git reflog
                          $ git reset --hard HEAD@{0}
                          

                          【讨论】:

                          • 谢谢!你节省了我半天的工作时间。但是我无法使用任何命令退出 reflog 模式。
                          • @Katarzyna 使用“q”键退出 reflog
                          【解决方案29】:

                          如果你还没有提交,你只能使用

                          $ git checkout -f
                          

                          它将撤消合并(以及您所做的一切)。

                          【讨论】:

                          • 试过了,它实际上增加了我的本地分支领先的提交数量。
                          【解决方案30】:

                          你可以使用 git-reset 命令。

                          git-reset - 将当前 HEAD 重置为

                          指定状态。 git reset [--mixed |

                          --软 | --硬 | --merge] [-q] [] git reset [-q] []

                          [--] ... git reset --patch

                          [] [--] […]

                          GIT-Reset

                          【讨论】:

                          • 我尝试了 git resetgit reset --mergegit reset --hard,但我仍然得到相同的消息,即在 origin/master 之前提交 5 次。
                          猜你喜欢
                          • 2011-08-22
                          • 2016-06-02
                          • 1970-01-01
                          • 2012-04-27
                          相关资源
                          最近更新 更多