voltar - remover commit github




Como reverter um repositório Git para um commit anterior (20)

Como eu reverti do meu estado atual para um instantâneo feito em um certo commit?

Se eu fizer git log , então eu recebo a seguinte saída:

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

Como reverter para o commit de 3 de novembro, ou seja, commit 0d1d7fc ?


Cuidado! Esse comando pode causar perda de histórico de confirmação, se o usuário colocar o commit errado por engano. Tenha sempre um backup extra do seu git em algum outro lugar apenas no caso de você cometer erros, do que você está um pouco mais seguro. :)

Eu tive problema semelhante e queria reverter para Commit anterior. No meu caso, eu não estava intencionado para manter o novo commit, portanto, eu usei Hard.

Foi assim que eu fiz:

git reset --hard CommitId && git clean -f

Isto irá reverter no repositório local, aqui depois de usar git push -firá atualizar o repositório remoto.

git push -f

Alternativas Extra para as Soluções da Jefromi

As soluções da Jefromi são definitivamente as melhores, e você definitivamente deveria usá-las. No entanto, por questão de completude, eu também queria mostrar essas outras soluções alternativas que também podem ser usadas para reverter um commit (no sentido de que você cria um novo commit que desfaz mudanças no commit anterior , assim como o git revert faz) .

Para ser claro, essas alternativas não são a melhor maneira de reverter os commits , as soluções da Jefromi são , mas eu só quero ressaltar que você também pode usar esses outros métodos para obter a mesma coisa que o git revert .

Alternativa 1: redefinições rígidas e suaves

Esta é uma versão ligeiramente modificada da solução de Charles Bailey para Reverter para um commit por um hash SHA no Git? :

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft [email protected]{1}

# Commit the changes
git commit -m "Revert to <commit>"

Isso basicamente funciona usando o fato de que resets soft deixarão o estado do commit anterior testado na área de índice / staging, que você pode então confirmar.

Alternativa 2: Excluir a Árvore Atual e Substituir pela Nova

Esta solução vem da solução do svick para o Checkout commit antigo e faz dele um novo commit :

git rm -r .
git checkout <commit> .
git commit

Similarmente à alternativa # 1, isso reproduz o estado de <commit> na cópia de trabalho atual. É necessário fazer git rm primeiro porque o git checkout não irá remover arquivos que foram adicionados desde <commit> .


Revertendo a cópia de trabalho para a confirmação mais recente

Para reverter para um commit anterior, ignorando quaisquer alterações:

git reset --hard HEAD

onde HEAD é o último commit em sua filial atual

Revertendo a cópia de trabalho para uma confirmação mais antiga

Para reverter para um commit mais antigo que o commit mais recente:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

Os créditos vão para uma pergunta semelhante do , Reverter para um commit por um hash SHA no Git? .


A melhor opção para mim e provavelmente para os outros é a opção de reset do Git:

git reset --hard <commidId> && git clean -f

Esta foi a melhor opção para mim! É simples, rápido e eficaz!

Observação: conforme mencionado nos comentários, não faça isso se você estiver compartilhando sua filial com outras pessoas que tenham cópias dos commits antigos.

Também a partir dos comentários, se você quiser um método menos 'ballzy' você pode usar

git clean -i


Aqui está uma maneira muito mais simples de voltar a um commit anterior (e tê-lo em um estado não comprometido, para fazer com o que você quiser):

git reset HEAD~1

Então, não há necessidade de cometer ids e assim por diante :)


Depois de todas as alterações, quando você pressiona todos esses comandos, talvez seja necessário usar:

git push -f ...

E não apenas git push .


Eu tentei muitas maneiras de reverter as mudanças locais no Git, e parece que isso funciona melhor se você quiser apenas reverter para o último estado de confirmação.

git add . && git checkout master -f

Pequena descrição:

  • NÃO irá criar nenhum commit como git revert faz.
  • NÃO irá desanexar o seu HEAD como o git checkout <commithashcode> .
  • Substituirá todas as alterações locais e EXCLUIR todos os arquivos adicionados desde o último commit na ramificação.
  • Ele funciona apenas com nomes de ramificações, portanto, você pode reverter apenas para o commit mais recente no branch dessa maneira.

Eu encontrei uma maneira muito mais simples e conveniente de alcançar os resultados acima:

git add . && git reset --hard HEAD

onde HEAD aponta para o commit mais recente em sua filial atual.

É o mesmo código de código que boulder_ruby sugeriu, mas eu adicionei git add . antes de git reset --hard HEAD para apagar todos os novos arquivos criados desde o último commit, já que é nisso que a maioria das pessoas espera acreditar ao reverter para o commit mais recente.


Existe um comando (não uma parte do Git principal, mas está no pacote git-extras ) especificamente para reverter e testar commits antigos:

git back

Pela página man , também pode ser usado como tal:

# Remove the latest three commits
git back 3

Muitas respostas complicadas e perigosas aqui, mas na verdade é fácil:

git revert --no-commit 0766c053..HEAD
git commit

Isso reverterá tudo, do HEAD de volta ao hash de commit, o que significa que ele irá recriar o estado de commit na árvore de trabalho como se todo commit tivesse sido retornado. Você pode, então, confirmar a árvore atual e criar um novo commit essencialmente equivalente ao commit para o qual você "reverteu".

(O sinalizador --no-commit permite que o git reverta todos os commits de uma só vez - caso contrário, você será solicitado a enviar uma mensagem para cada commit no intervalo, sujando seu histórico com novos commits desnecessários.)

Esta é uma maneira segura e fácil de reverter para um estado anterior . Nenhum histórico é destruído, portanto, ele pode ser usado para commits que já foram tornados públicos.


Nada aqui funcionou para mim além dessa combinação exata:

git reset --hard <commit_hash>
git push origin <branch_name> --force

A chave aqui é forçar o push, sem commits / commits adicionais, etc.


Selecione seu commit requerido e verifique-o

git show HEAD
git show HEAD~1
git show HEAD~2 

até você obter o commit requerido. Para fazer o HEAD apontar para isso, faça

git reset --hard HEAD~1

ou git reset --hard HEAD~2 ou qualquer outra coisa.


Supondo que você esteja falando sobre o mestre e sobre o ramo em questão (isso dito, pode ser qualquer ramo em que você esteja preocupado):

# Revert local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Revert remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

Eu encontrei a resposta de no post do blog Excluir reit Git remoto para commit específico .


OK, voltar ao commit anterior no git é bem fácil ...

Reverta sem manter as alterações:

git reset --hard <commit>

Reverta com as alterações:

git reset --soft <commit>

Explique: usando o git reset, você pode redefinir para um estado específico, é comum usá-lo com um hash de confirmação como você vê acima.

Mas como você vê a diferença está usando as duas flags --soft e --hard , por padrão git reset usando --soft flag, mas é uma boa prática sempre usando o flag, eu explico cada flags:

--suave

O sinalizador padrão, conforme explicado, não precisa fornecê-lo, não altera a árvore de trabalho, mas inclui todos os arquivos de alterações prontos para serem confirmados, portanto, você retorna ao status de confirmação, que altera os arquivos para serem desfeitos.

--Difícil

Tenha cuidado com esse sinalizador, ele redefine a árvore de trabalho e todas as alterações nos arquivos rastreados e todas desaparecerão!

Eu também criei a imagem abaixo que pode acontecer em uma vida real trabalhando com o git:



Para manter as alterações do commit anterior para HEAD e passar para o commit anterior, faça:

git reset <SHA>

Se as mudanças não forem necessárias no commit anterior para HEAD e apenas descartar todas as alterações, faça:

git reset --hard <SHA>

Para reversão (ou para reverter):

  1. git revert --no-commit "commit-code-to-remove" HEAD (por exemplo, git revert --no-commit d57a39dHead)
  2. git commit
  3. git push

Tente acima de dois passos, e se você achar que é isso que você quer, então git push.

Se você encontrar algo errado, faça:

git revert --abort


Tente redefinir para o commit desejado

git reset <COMMIT_ID>

(para verificar o uso do COMMIT_ID git log)

Isso redefinirá todos os arquivos alterados para o estado não adicionado.

Agora você pode checkouttodos os arquivos não adicionados por

git checkout .

Verifique git logpara verificar suas alterações.

ATUALIZAR

Se você tem um e apenas se compromete em seu repo, tente

git update-ref -d HEAD


Você pode completar todos os passos iniciais e voltar ao git repo.

  1. Puxe a versão mais recente do seu repositório do Bitbucket usando o git pull --allcomando.

  2. Execute o comando git log com -n 4 do seu terminal. O número após o -n determina o número de confirmações no log a partir do commit mais recente em seu histórico local.

    $ git log -n 4

  3. Redefina a cabeça do histórico do seu repositório usando o git reset --hard HEAD~Nonde N é o número de commits que você quer levar a cabeça para trás. No exemplo a seguir, o cabeçalho seria retrocedido em um commit, para o último commit no histórico do repositório:

  4. Empurre a mudança para git repo usando git push --forcepara forçar a mudança.

Se você quiser o repositório git para um commit anterior

git pull --all
git reset --hard HEAD~1
git push --force

Reverta para a confirmação mais recente e ignore todas as alterações locais:

git reset --hard HEAD

Se a situação é urgente , basta fazer o que o questionador fez de maneira rápida e suja , assumindo que seu projeto está no diretório "meu projeto":

  1. Copie todo o diretório e chame de outra coisa, como "meu projeto - copiar"

  2. Faz:

    git reset --hard [first-4-letters&numbers-of-commit's-SHA]
    

Você então tem duas versões em seu sistema ... você pode examinar ou copiar ou modificar arquivos de interesse, ou o que quer, do commit anterior. Você pode descartar completamente os arquivos em "meu projeto - cópia", se você decidiu que o novo trabalho estava indo a lugar nenhum ...

O mais óbvio é se você quiser continuar com o estado do projeto sem descartar o trabalho, já que esse commit recuperado é renomear seu diretório novamente: Apague o projeto que contém o commit recuperado (ou dê um nome temporário) e renomeie o seu " meu projeto - copie "diretório de volta para" meu projeto ". Então, provavelmente, faça outro commit em breve.

Git é uma criação brilhante, mas você não pode simplesmente "pegar em tempo real": também as pessoas que tentam explicá-lo com muita freqüência assumem conhecimento prévio de outros VCS [Sistemas de Controle de Versão] e se aprofundam muito profundamente muito cedo, e cometer outros crimes, como usar termos intercambiáveis ​​para "check-out" - de formas que às vezes parecem quase calculadas para confundir um iniciante.

Para poupar muito estresse você tem que praticamente ler um livro sobre o Git - eu recomendaria o "Version Control with Git" . E se você pode confiar em mim (ou melhor, minhas cicatrizes) quando digo "tenho que", segue-se que você também pode fazê-lo agora . Grande parte da complexidade do Git vem da ramificação e, depois, da remineração. Mas a partir da sua pergunta, não há motivo para as pessoas estarem cegando você com a ciência .

Especialmente se, por exemplo, esta é uma situação desesperada e você é um novato no Git!

PS: Um outro pensamento: é (agora) realmente muito simples manter o repositório Git ("repo") em um diretório diferente daquele com os arquivos de trabalho. Isso significaria que você não teria que copiar todo o repositório Git usando a solução rápida e suja acima. Veja a resposta por Fryer usando --separate-git-dir here . Esteja avisado : Se você tiver um repositório de "diretório separado" que você não copia e fizer uma reinicialização a frio, todas as versões subseqüentes à confirmação de redefinição serão perdidas para sempre, a menos que você tenha, como deveria, regularmente backup do seu repositório, de preferência para a nuvem (por exemplo, Google Drive ), entre outros lugares.





git-revert