uso - verificar tags git




Desfazer uma mesclagem do Git que ainda não foi enviada (18)

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?


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


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


A resposta mais simples é a dada por odinho - Velmont

Primeiro faça o git reset --merge ORIG_HEAD

Para aqueles que desejam redefinir após as alterações serem feitas, faça isso (porque este é o primeiro post visto para qualquer pergunta de mesclagem de redefinição de git)

git push origin HEAD --force

Isso será redefinido de forma que você não recupere as alterações mescladas após o pull.


Apenas por uma opção extra de olhar, eu tenho seguido o modelo de ramificação descrito aqui: http://nvie.com/posts/a-successful-git-branching-model/ e como tal tenho fundido com --no-ff (sem avanço rápido) normalmente.

Acabei de ler esta página quando eu mesclei acidentalmente uma ramificação de teste em vez da minha ramificação de lançamento com o mestre para implantação (site, mestre é o que é ao vivo). O ramo de testes tem dois outros ramos mesclados e totaliza cerca de seis commits.

Então, para reverter todo o commit, eu precisei apenas de um git reset --hard HEAD^ e ele reverteu toda a mesclagem. Como as mesclagens não foram encaminhadas rapidamente, a mesclagem era um bloco e um passo atrás é "ramificação não mesclada".


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


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


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.


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.


Nesse caso, você desejará redefinir sua ramificação com git reset --hard <branch_name> . Se você quiser salvar suas alterações antes de redefini-las, certifique-se de criar um novo branch e git checkout <branch_name> .

Você pode reconfigurar o estado para um commit específico com git reset --hard <commit_id> também.

Se as alterações foram enviadas, você pode usar o git revert <branch_name> . Certifique-se de verificar como usar git revert e git checkout em outros cenários também.


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

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

Se você não confirmou ainda, você só pode usar

$ git checkout -f

Ele irá desfazer a mesclagem (e tudo o que você fez).


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á

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.


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 .


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!


Você poderia usar o git reflog para encontrar o checkout anterior. Às vezes, esse é um bom estado para o qual você deseja retornar.

Concretamente,

$ git reflog
$ git reset --hard [email protected]{0}

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





git-merge