Como faço para desfazer os commits mais recentes no Git?




remover commit git (24)

Isso me levou um tempo para descobrir, então talvez isso ajude alguém ...

Existem duas maneiras de "desfazer" seu último commit, dependendo se você já fez seu commit público (enviado para seu repositório remoto):

Como desfazer um commit local

Vamos dizer que eu cometi localmente, mas agora quero remover esse commit.

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

Para restaurar tudo de volta ao modo como estava antes do último commit, precisamos reset para o commit antes de HEAD :

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

Agora o git log mostrará que nosso último commit foi removido.

Como desfazer um commit público

Se você já fez seus commits públicos, você vai querer criar um novo commit que irá "reverter" as mudanças que você fez em seu commit anterior (HEAD atual).

git revert HEAD

Suas alterações agora serão revertidas e estarão prontas para você:

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

Para mais informações, confira Git Basics - Desfazendo as Coisas

Eu acidentalmente enviei os arquivos errados para o Git , mas ainda não enviei o commit para o servidor.

Como posso desfazer esses commits do repositório local?


Desfazer um commit é um pouco assustador se você não sabe como funciona. Mas é realmente incrivelmente fácil se você entender.

Digamos que você tenha isso, onde C é sua CABEÇA e (F) é o estado dos seus arquivos.

   (F)
A-B-C
    ↑
  master

Você quer nuke commit C e nunca mais vê-lo novamente . Você faz isso:

git reset --hard HEAD~1

O resultado é:

 (F)
A-B
  ↑
master

Agora B é a cabeça. Porque você usou --hard , seus arquivos são redefinidos para seu estado no commit B.

Ah, mas suponha que comprometer C não fosse um desastre, mas apenas um pouco fora. Você deseja desfazer o commit, mas mantenha as alterações para um pouco de edição antes de fazer um commit melhor. Começando de novo daqui, com C como sua CABEÇA:

   (F)
A-B-C
    ↑
  master

Você pode fazer isso, deixando o --hard :

git reset HEAD~1

Neste caso, o resultado é:

   (F)
A-B-C
  ↑
master

Em ambos os casos, HEAD é apenas um ponteiro para o commit mais recente. Quando você faz um git reset HEAD~1 , você diz ao Git para mover o ponteiro HEAD para trás um commit. Mas (a menos que você use --hard ) você deixa seus arquivos como estavam. Então agora o git status mostra as mudanças que você registrou no C. Você não perdeu nada!

Para o toque mais leve, você pode até mesmo desfazer seu commit, mas deixar seus arquivos e seu index :

git reset --soft HEAD~1

Isso não apenas deixa seus arquivos em paz, como também deixa seu índice sozinho. Quando você faz o git status , você verá que os mesmos arquivos estão no índice como antes. De fato, logo após este comando, você poderia fazer git commit e você estaria refazendo o mesmo commit que você acabou de fazer.

Mais uma coisa: suponha que você destrua um commit como no primeiro exemplo, mas depois descobre que precisava disso depois de tudo ? Sorte, certo?

Não, ainda há uma maneira de recuperá-lo. Digite git reflog e você verá uma lista de commits (parciais) shas pelos quais você se mudou. Encontre o commit que você destruiu, e faça o seguinte:

git checkout -b someNewBranchName shaYouDestroyed

Você agora ressuscitou esse commit. Compromissos não são realmente destruídos no Git por cerca de 90 dias, então você geralmente pode voltar e resgatar um que você não queria se livrar.


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

ou

git reset --hard HEAD~1

Aviso: O comando acima removerá permanentemente as modificações dos arquivos .java (e de quaisquer outros arquivos) que você deseja confirmar.

O hard reset para HEAD-1 irá definir sua cópia de trabalho para o estado do commit antes de seu commit errado.


Desfazer um commit e refazer

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)
  1. Isto é o que você quer desfazer
  2. Isso deixa a sua árvore de trabalho (o estado de seus arquivos no disco) inalterada, mas desfaz o commit e deixa as alterações que você desatou (então elas aparecerão como "Changes not staged for commit" no git status , e você precisará adicione-os novamente antes de confirmar). Se você quiser apenas adicionar mais alterações ao commit anterior, ou alterar a mensagem de commit 1 , você pode usar git reset --soft HEAD~ invés, que é como git reset HEAD~ (onde HEAD~ é o mesmo que HEAD~1 ), mas deixa as alterações existentes em etapas.
  3. Faça correções nos arquivos da árvore de trabalho.
  4. git add qualquer coisa que você queira incluir em seu novo commit.
  5. Confirme as alterações, reutilizando a antiga mensagem de confirmação. reset copiou a cabeça antiga para .git/ORIG_HEAD ; commit com -c ORIG_HEAD abrirá um editor, que inicialmente contém a mensagem de log do commit antigo e permite editá-lo. Se você não precisar editar a mensagem, poderá usar a opção -C .

Contudo, tenha em atenção que, se tiver adicionado novas alterações ao índice, a utilização do commit --amend irá adicioná-las ao seu commit anterior.

Se o código já foi enviado para o seu servidor e você tem permissões para sobrescrever o histórico (rebase), então:

git push origin master --force

Você também pode olhar para esta resposta:

Como mover o HEAD de volta para um local anterior? (Cabeça destacada)

A resposta acima mostrará o git reflog que é usado para descobrir qual é o SHA-1 que você deseja reverter. Depois de encontrar o ponto para o qual você deseja desfazer, use a sequência de comandos, conforme explicado acima.

1 Observe, no entanto, que você não precisa redefinir para uma confirmação anterior se tiver cometido um erro na sua mensagem de confirmação . A opção mais fácil é git reset (para sobresaltar qualquer mudança que você tenha feito desde então) e então git commit --amend , que abrirá seu editor de mensagens de commit pré-preenchido com a última mensagem de commit.


No meu caso, eu acidentalmente cometi alguns arquivos que eu não queria. Então eu fiz o seguinte e deu certo:

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

Verifique os resultados com gitk ou git log --stat


Apenas redefina o comando abaixo usando o git :

git reset --soft HEAD~1

Explique: o que o git reset faz, ele é basicamente reset para qualquer commit que você gostaria de voltar, então se você combiná-lo com a chave --soft , ele retornará, mas mantenha as mudanças em seu (s) arquivo (s), então você volta ao estágio em que o arquivo acabou de ser adicionado, HEAD é o chefe do branch e se você combinar com ~1 (neste caso você também usa HEAD^ ), ele irá retornar somente um commit que você deseja. ..

Eu crio os passos na imagem abaixo em mais detalhes para você, incluindo todos os passos que podem acontecer em situações reais e comprometendo o código:


Use git revert commit-id

Para obter o ID de commit, apenas use o git log


Um único comando:

git reset --soft 'HEAD^' 

Funciona muito bem para desfazer o último commit local!


Primeira corrida:

git reflog

Ele mostrará todas as ações possíveis que você realizou em seu repositório, por exemplo, commit, merge, pull, etc.

Então faça:

git reset --hard ActionIdFromRefLog

Outra maneira:

Faça check-out da ramificação que você deseja reverter e redefina sua cópia de trabalho local de volta para o commit que você deseja que seja a mais recente no servidor remoto (tudo depois que ele for bye-bye). Para fazer isso, no SourceTree eu cliquei com o botão direito do mouse e selecionei "Reset BRANCHNAME to this commit".

Em seguida, navegue até o diretório local do seu repositório e execute este comando:

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

Isso apagará todos os commits após o atual em seu repositório local, mas apenas para aquele branch.


Se você quiser desfazê-lo permanentemente e clonar algum repositório

O ID de commit pode ser visto por

git log 

Então você pode fazer

git reset --hard <commit_id>

git push origin <branch_name> -f

Se você quiser remover arquivos no último commit, você pode usar isto:

git reset --hard HEAD~1

E se precisar de arquivos no último commit, você pode usar isto:

git reset --soft HEAD~1

Eu queria desfazer os últimos 5 commits em nosso repositório compartilhado. Eu olhei para o id de revisão que queria reverter. Então eu digitei o seguinte.

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 [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Se você tiver o Git Extras instalado, você pode executar o git undo para desfazer o commit mais recente. git undo 3 irá desfazer os últimos 3 commits.


Existem dois cenários principais

Você não empurrou o commit ainda

Se o problema foram arquivos extras que você cometeu (e você não quer aqueles no repositório), você pode removê-los usando git rme então se comprometendo com--amend

git rm <pathToFile>

Você também pode remover diretórios inteiros com -rou até combinar com outros comandos Bash

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Depois de remover os arquivos, você pode confirmar, com a opção --amend

git commit --amend -C HEAD # the -C option is to use the same commit message

Isso irá reescrever sua confirmação local recente removendo os arquivos extras, portanto, esses arquivos nunca serão enviados em push e também serão removidos do seu repositório .git local pelo GC.

Você já empurrou o commit

Você pode aplicar a mesma solução do outro cenário e, em seguida, fazer git pushcom a -fopção, mas isso não é recomendado, pois substitui o histórico remoto por uma alteração divergente (pode atrapalhar seu repositório).

Em vez disso, você tem que fazer o commit sem --amend(lembre-se disso sobre -amend`: Essa opção reescreve o histórico no último commit).


Como corrigir o commit local anterior

Use git-gui (ou similar) para executar um git commit --amend . Na GUI, você pode adicionar ou remover arquivos individuais do commit. Você também pode modificar a mensagem de confirmação.

Como desfazer o commit local anterior

Basta redefinir sua ramificação para o local anterior (por exemplo, usando gitk ou git rebase ). Em seguida, reaplique suas alterações a partir de uma cópia salva. Após a coleta de lixo em seu repositório local, será como se o commit indesejado nunca tivesse acontecido. Para fazer tudo isso em um único comando, use git reset HEAD~1 .

Palavra de aviso : O uso descuidado do git reset é uma boa maneira de deixar sua cópia de trabalho em um estado confuso. Eu recomendo que os novatos do Git evitem isso, se puderem.

Como desfazer um commit público

Execute uma seleção reversa de cereja ( git-revert ) para desfazer as alterações.

Se você ainda não fez outras alterações no seu ramo, você pode simplesmente ...

git revert --no-edit HEAD

Em seguida, envie sua ramificação atualizada para o repositório compartilhado.

O histórico de commits mostrará os dois commits separadamente .

Avançado: Correção de ramificação privada no repositório público

Isso pode ser perigoso - certifique-se de ter uma cópia local do ramo para repassar.

Observe também: você não quer fazer isso se outra pessoa estiver trabalhando no ramo.

git push --delete (branch_name) ## remove public version of branch

Limpe o seu ramo localmente e depois repila ...

git push origin (branch_name)

No caso normal, você provavelmente não precisa se preocupar com o histórico de commits de ramificação privada sendo intocado. Basta apertar um commitup de acompanhamento (veja 'Como desfazer um commit público' acima), e depois, faça um squash-merge para esconder o histórico.


Para alterar o último commit

Substitua os arquivos no índice:

git rm --cached *.class
git add *.java

Então, se for um ramo privado, altere o commit:

git commit --amend

Ou, se for uma ramificação compartilhada, faça um novo commit:

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


( para mudar um commit anterior , use o awesome rebase interativo )

ProTip ™: Adicione *.class a um gitignore para impedir que isso aconteça novamente.

Para reverter um commit

A alteração de um commit é a solução ideal se você precisar alterar o último commit, mas uma solução mais geral é reset .

Você pode resetar o git para qualquer commit com:

git reset @~N

Onde N é o número de confirmações antes de HEAD e @~ redefinido para o commit anterior.

Então, em vez de alterar o commit, você poderia usar:

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

Confira a git help reset , especificamente as seções em --soft --mixed e --hard , para entender melhor o que isso faz.

Reflog

Se você errar, você sempre pode usar o reflog para encontrar commits descartados:

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



Use reflog para encontrar um estado correto

git reflog

REFLOG ANTES DE REINICIAR

Selecione o reflog correto (f3cb6e2 no meu caso) e digite

git reset --hard f3cb6e2

Depois disso, o reporte HEAD será reposto para o HEADid LOG APÓS RESET

Finalmente o reflog parece com a imagem abaixo

REFLOG FINAL


Para redefinir a revisão anterior, exclua permanentemente todas as alterações não confirmadas:

git reset --soft HEAD~ 

"Redefinir a árvore de trabalho para o último commit"

git reset --hard HEAD^ 

"Limpe arquivos desconhecidos da árvore de trabalho"

git clean    

consulte - Referência Rápida do Git

NOTA: Este comando irá deletar seu commit anterior, então use com cuidado! git reset --hard é mais seguro -


Como desfazer o último commit do Git?

Para restaurar tudo de volta ao modo como estava antes do último commit, precisamos redefinir para o commit antes do HEAD.

  1. Se você não quiser manter suas alterações feitas:

    git reset --hard HEAD^
    
  2. Se você quiser manter suas alterações:

    git reset --soft HEAD^
    

Agora verifique seu log git. Isso mostrará que nosso último commit foi removido.


Digite git log e encontre o último código hash de commit e então digite:

git reset <the previous co>

Adicionar / remover arquivos para fazer as coisas do jeito que você deseja:

git rm classdir
git add sourcedir

Em seguida, altere o commit:

git commit --amend

O commit anterior, errôneo, será editado para refletir o novo estado do índice - em outras palavras, será como se você nunca tivesse cometido o erro em primeiro lugar.

Observe que você só deve fazer isso se ainda não tiver pressionado. Se você tiver pressionado, você terá que fazer uma correção normalmente.


Use o SourceTree (ferramenta gráfica para o Git) para ver seus commits e tree. Você pode redefini-lo manualmente clicando com o botão direito nele.





git-revert