verificar Desfazer uma mesclagem do Git que ainda não foi enviada




verificar tags git (21)

Eu acho que você pode fazer git rebase -i [hash] [branch_name] onde [hash] é o hash de identificação para o quão longe você quiser voltar mais um (ou quantos commits voltar você quer ir) e, em seguida, excluir as linhas para os commits no editor que você não quer mais. Salve o arquivo. Saída. Orar. E deve ser rebobinado. Você pode ter que fazer um git reset --hard , mas deve ser bom neste momento. Você também pode usar isso para extrair commits específicos de uma pilha, se você não quiser mantê-los em seu histórico, mas isso pode deixar seu repositório em um estado que você provavelmente não deseja.

Dentro da minha ramificação mestre, eu fiz um git merge some-other-branch localmente, mas nunca enviei as mudanças para o master de origem. Eu não queria me fundir, então eu gostaria de desfazer isso. Ao fazer um git status após minha mesclagem, recebi esta mensagem:

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

Com base em algumas instruções que encontrei , tentei correr

git revert HEAD -m 1

mas agora estou recebendo esta mensagem com git status :

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

Não quero que minha filial esteja à frente com qualquer número de commits. Como eu volto a esse ponto?


Com as versões mais recentes do Git, se você ainda não tiver feito a mesclagem e tiver um conflito de mesclagem , basta fazer:

git merge --abort

De man git merge :

[Isto] só pode ser executado depois que a mesclagem resultar em conflitos. git merge --abort irá abortar o processo de mesclagem e tentar reconstruir o estado de pré-mesclagem.


Consegui resolver esse problema com um único comando que não envolve a procura de um ID de confirmação.

git reset --hard remotes/origin/HEAD

A resposta aceita não funcionou para mim, mas esse comando alcançou os resultados que eu estava procurando.


Se você quiser uma solução de linha de comando, sugiro apenas ir com a resposta da MBO.

Se você é um novato, pode gostar da abordagem gráfica:

  1. Kick off gitk (a partir da linha de comando, ou clique direito no navegador de arquivos, se você tem isso)
  2. Você pode identificar facilmente o commit da mesclagem lá - o primeiro nó do topo com dois pais
  3. Siga o link para o primeiro / pai da esquerda (o que está no seu ramo atual antes da fusão, geralmente vermelho para mim)
  4. No commit selecionado, clique com o botão direito do mouse em "Redefinir ramificação para aqui", escolha o hard reset lá

Ok, as respostas que outras pessoas aqui me deram eram próximas, mas não funcionou. Aqui está o que eu fiz.

Fazendo isso...

git reset --hard HEAD^
git status

... me deu o seguinte status.

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

Eu então tive que digitar o mesmo comando de git reset várias vezes. Cada vez que eu fiz isso, a mensagem mudou por um, como você pode ver abaixo.

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

Neste ponto, vi a mensagem de status alterada, então tentei fazer um git pull e isso pareceu funcionar:

> 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

Tão longa história curta, meus comandos se resumiram a isso:

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

Com o moderno Git, você pode:

git merge --abort

Sintaxe mais antiga:

git reset --merge

Moda antiga:

git reset --hard

Mas, na verdade, vale a pena notar que git merge --abort é apenas equivalente a git reset --merge dado que MERGE_HEAD está presente. Isso pode ser lido na ajuda do Git para o comando merge.

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

Após uma falha de mesclagem, quando não há MERGE_HEAD , a mesclagem com falha pode ser desfeita com git reset --merge , mas não necessariamente com git merge --abort , então eles não são apenas a sintaxe antiga e nova para a mesma coisa .

Pessoalmente acho git reset --merge muito mais poderoso e útil no trabalho diário, então é esse que eu sempre uso.


Estratégia: Crie um novo ramo de onde tudo estava bem.

Justificativa: A reversão de uma fusão é difícil. Existem muitas soluções, dependendo de muitos fatores, como se você confirmou ou enviou sua mesclagem ou se houve novos commits desde sua mesclagem. Além disso, você ainda precisa ter um entendimento relativamente profundo do git para adaptar essas soluções ao seu caso. Se você seguir cegamente algumas instruções, você pode acabar com uma "mesclagem vazia" onde nada será mesclado, e outras tentativas de mesclagem farão com que o Git lhe diga "Já está atualizado".

Solução:

Digamos que você queira mesclar o dev no feature-1 .

  1. Encontre a revisão que você deseja receber a mesclagem:

    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. Confira (volte no tempo):

    git checkout e5f6g7h8
    
  3. Crie um novo branch a partir daí e confira:

    git checkout -b feature-1
    

Agora você pode reiniciar sua mesclagem:

  1. Mesclar: git merge dev

  2. Corrigir seus conflitos de mesclagem.

  3. Commit: git commit

  4. Quando estiver satisfeito com os resultados, exclua a ramificação antiga: git branch --delete feature-1


Você deve redefinir para o commit anterior. Isso deve funcionar:

git reset --hard HEAD^

Ou até HEAD^^ para reverter esse commit de reverter. Você sempre pode fornecer uma referência SHA completa se não tiver certeza de quantos passos deve dar.

Caso você tenha problemas e sua ramificação principal não tenha alterações locais, você pode redefinir para origin/master .


Se a sua mesclagem e os commits correspondentes ainda não foram enviados, você pode alternar para outra ramificação, excluir a original e recriá-la.

Por exemplo, eu acidentalmente mesclei uma ramificação de desenvolvimento em mestre e queria desfazer isso. Usando as seguintes etapas:

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

Voila! O mestre está no mesmo estágio da origem e seu estado mal fundido é apagado.


  1. Primeiro, certifique-se de que você tenha comprometido tudo.

  2. Em seguida, redefina seu repositório para o estado de funcionamento anterior:

    $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36
    

    ou usando --hard ( isso removerá todas as mudanças locais, não confirmadas! ):

    $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36 --hard
    

    Use o hash que estava lá antes do commit errado.

  3. Verifique quais commits você gostaria de confirmar novamente no topo da versão correta anterior:

    $ git log 4c3e23f529b581c3cbe95350e84e66e3cb05704f
    
    commit 4c3e23f529b581c3cbe95350e84e66e3cb05704f
    
    ...
    
    commit 16b373a96b0a353f7454b141f7aa6f548c979d0a
    
    ...
    
  4. Aplique o seu direito na parte superior da versão correta do seu repositório:

    • Usando cherry-pick (as alterações introduzidas por alguns commits existentes)

          git cherry-pick ec59ab844cf504e462f011c8cc7e5667ebb2e9c7
      
    • Ou escolhendo o intervalo de commits por:

      • Primeiro, verificar as alterações corretas antes de mesclá-las:

        git diff 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
        
      • Primeiro, verificar as alterações corretas antes de mesclá-las:

        git cherry-pick 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
        

        onde este é o intervalo dos commits corretos que você cometeu (excluindo a junção comprometida incorretamente).


Se você cometeu a mesclagem:

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


Você pode usar o comando git-reset.

git-reset - Redefine a CABEÇA atual para o

estado especificado. git reset [--mixed |

--soft | --hard | --merge] [-q] [] git reset [-q] []

[-]… git reset --patch

[] [-] […]

GIT-Reset


A mais simples das chances mais simples, muito mais simples do que qualquer outra coisa aqui:

Remova o seu ramo local (local, não remoto) e puxe-o novamente. Dessa forma, você desfaz as alterações na sua ramificação principal e qualquer pessoa será afetada pela alteração que você não deseja enviar. Comece de novo.


Ultimamente, tenho usado o git reflog para ajudar nisso. Isso geralmente só funciona se a junção JUST aconteceu, e foi na sua máquina.

git reflog pode retornar algo como:

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

A primeira linha indica que uma mesclagem ocorreu. A segunda linha é a hora antes da minha fusão. Eu simplesmente git reset --hard 43b6032 para forçar esta ramificação a rastrear antes da mesclagem e carry-on.


Se você perceber que precisa reverter imediatamente após a mesclagem e não fez mais nada após a tentativa de mesclagem, pode simplesmente emitir este comando: git reset --hard [email protected]{1} .

Essencialmente, seu merge sha estará apontando para [email protected]{0} se nada mais foi confirmado após a mesclagem e, portanto, [email protected]{1} será o ponto anterior antes da mesclagem.


É estranho que o comando mais simples estivesse faltando. A maioria das respostas funciona, mas desfazendo a fusão que você acabou de fazer, esta é a maneira mais fácil e segura :

git reset --merge ORIG_HEAD

O ORIG_HEAD ref ORIG_HEAD para o commit original antes da mesclagem.

(A opção --merge não tem nada a ver com a mesclagem. É como o git reset --hard ORIG_HEAD , mas é mais seguro porque não toca em alterações não confirmadas.)


Você pode usar apenas dois comandos para reverter uma mesclagem ou reiniciar por um commit específico:

  1. git reset --hard commitHash (você deve usar o commit que deseja reiniciar, por exemplo, 44a587491e32eafa1638aca7738)
  2. git push origin HEAD --force (Enviando a nova ramificação mestre local para origem / master)

Boa sorte e vá em frente!


Com git reflog verifique qual commit é um antes da merge (git reflog será uma opção melhor que git log). Então você pode redefini-lo usando:

git reset --hard commit_sha

Há também outro jeito

git reset --hard HEAD~1

te levará de volta 1 commit.

Esteja ciente de que quaisquer arquivos modificados e não confirmados / não recuperados serão redefinidos para o estado não modificado . Para mantê-los ou esconder as alterações ou ver a opção --merge abaixo.

Como @Velmont sugeriu abaixo em sua resposta, neste caso direto usando:

git reset --hard ORIG_HEAD

pode produzir melhores resultados, pois deve preservar suas alterações. ORIG_HEAD apontará para um commit diretamente antes que a mesclagem tenha ocorrido, então você não precisa caçar sozinho.

Outra dica é usar a opção --merge vez de --hard já que ela não restaura os arquivos desnecessariamente:

--merge

Redefine o índice e atualiza os arquivos na árvore de trabalho que são diferentes entre <commit> e HEAD, mas mantém aqueles que são diferentes entre o índice e a árvore de trabalho (isto é, que possuem alterações que não foram adicionadas).


Cheguei a esta questão também olhando para reverter para coincidir com a origem (ou seja, não cometer antes da origem). Pesquisando mais, descobri que há um comando de reset exatamente para isso:

git reset --hard @{u}

Nota: @{u} é uma abreviação para origin/master . (E, claro, você precisa desse repositório remoto para isso funcionar.)


Assumindo que o seu mestre local não estava à frente da origem / mestre, você deve ser capaz de fazer

git reset --hard origin/master

Então, seu ramo master local deve ser idêntico à origin/master .





git-merge