Como desfazer as confirmações locais mais recentes no Git?

Acidentalmente enviei os arquivos errados para o Git , mas ainda não enviei a confirmação para o servidor.

Como posso desfazer essas confirmações do repositório local?

Desfazer uma confirmação 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. É isso que você deseja desfazer.
2. Isso não faz nada na sua árvore de trabalho (o estado dos seus arquivos no disco), mas desfaz a confirmação e deixa as alterações que você cometeu em etapas (para que elas apareçam como "Alterações não preparadas para a confirmação" git status, então você precisará adicione-os novamente antes de confirmar). Se você única querer adicionar mais mudanças para cometer o anterior, ou mudar a mensagem de commit ¹ , você poderia usar git reset --soft HEAD~em vez disso, que é como git reset HEAD~² , mas deixa as alterações existentes encenado.
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 mensagem de confirmação antiga. resetcopiou a cabeça antiga para .git/ORIG_HEAD; commitO with -c ORIG_HEADabrirá um editor, que inicialmente contém a mensagem de log do commit antigo e permite que você edite. Se você não precisar editar a mensagem, poderá usar a -Copção

Cuidado, no entanto, se você tiver adicionado novas alterações ao índice, o uso commit --amenddelas será adicionado ao seu commit anterior.

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

git push origin master --force

Você também pode olhar para esta resposta:

Como posso mover o HEAD de volta para um local anterior? (Cabeça desanexada) e Desfazer confirma

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

¹ 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(desfazer as alterações feitas desde então) e git commit --amend, em seguida , abrir o editor de mensagens de confirmação padrão preenchido previamente com a última mensagem de confirmação.

² HEAD~ é o mesmo que HEAD~1. Além disso, consulte O que é o HEAD no git? . É útil se você deseja cancelar várias confirmações.

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

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

   (F)
A-B-C
    ↑
  master

Você deseja remover o commit do C e nunca mais vê-lo e perder todas as alterações nos arquivos modificados localmente . Você faz isso:

git reset --hard HEAD~1

O resultado é:

 (F)
A-B
  ↑
master

Agora B é a CABEÇA. Como você usou --hard, seus arquivos são redefinidos para seus estados na confirmação B.

Ah, mas suponha que o commit C não tenha sido um desastre, mas apenas um pouco. Você deseja desfazer o commit, mas mantenha suas alterações um pouco para editar antes de fazer um commit melhor. Começando novamente a partir daqui, com C como sua CABEÇA:

   (F)
A-B-C
    ↑
  master

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

git reset HEAD~1

Nesse caso, o resultado é:

   (F)
A-B-C
  ↑
master

Nos dois casos, HEAD é apenas um ponteiro para o último commit. Quando você faz um git reset HEAD~1, você diz ao Git para mover o ponteiro HEAD de volta para um commit. Mas (a menos que você use --hard), você deixa seus arquivos como estavam. Então agoragit status , mostra as alterações que você registrou no C. Você não perdeu nada!

Para dar um toque mais leve, você pode até desfazer seu commit, mas deixar seus arquivos e seu índice :

git reset --soft HEAD~1

Isso não apenas deixa seus arquivos em paz, mas também deixa seu índice em paz. Ao fazê-lo git status, você verá que os mesmos arquivos estão no índice de antes. De fato, logo após esse comando, você poderia fazer git commite refazer o mesmo commit que acabou de ter.

Mais uma coisa: suponha que você destrua um commit como no primeiro exemplo, mas depois descubra que precisava dele afinal ? Muita sorte, certo?

Não, ainda há uma maneira de recuperá-lo. Digite git refloge você verá uma lista de commit (parcial) shas (ou seja, hashes) nos quais você se mudou. Encontre o commit que você destruiu e faça o seguinte:

git checkout -b someNewBranchName shaYouDestroyed

Agora você ressuscitou esse commit. As confirmações não são realmente destruídas no Git por cerca de 90 dias; portanto, você pode voltar e resgatar uma que você não queria se livrar.

Há duas maneiras de "desfazer" seu último commit, dependendo de você já ter tornado seu commit público ou não (enviado ao repositório remoto):

Como desfazer uma consolidação local

Digamos que eu confirmei 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 estado anterior ao último commit, precisamos resetfazer o commit antes 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 git logmostrará que nosso último commit foi removido.

Como desfazer um commit público

Se você já tornou seus commits públicos, convém criar um novo commit que "reverterá" as alterações feitas no commit anterior (HEAD atual).

git revert HEAD

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

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 obter mais informações, consulte Git Basics - Desfazendo coisas .

Adicione / remova arquivos para obter as coisas da maneira que você deseja:

git rm classdir
git add sourcedir

Em seguida, altere o commit:

git commit --amend

A confirmação incorreta anterior será editada para refletir o novo estado do índice - em outras palavras, será como se você nunca tivesse cometido o erro.

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

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 no .java arquivos (e quaisquer outros arquivos) que você deseja confirmar.

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

Para alterar o último commit

Substitua os arquivos no índice:

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

Em seguida, se for um ramo privado, altere o commit:

git commit --amend

Ou, se for um ramo compartilhado, faça um novo commit:

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

( Para alterar uma confirmação anterior , use a incrível re-interação interativa .)

ProTip ™: adicione *.classa um gitignore para impedir que isso aconteça novamente.

Para reverter uma confirmação

Alterar uma confirmação é a solução ideal se você precisar alterar a última confirmação, mas uma solução mais geral é reset .

Você pode redefinir o Git para qualquer confirmação com:

git reset @~N

Onde Né o número de confirmações anteriores HEADe @~redefine para a confirmação anterior.

Portanto, em vez de alterar o commit, você pode usar:

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

Confira git help reset, especificamente as seções --soft --mixede --hard, para uma melhor compreensão do que isso faz.

Reflogar

Se você errar, sempre poderá usar o reflog para encontrar confirmações descartadas:

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

Use git revert <commit-id>.

Para obter o ID de confirmação, basta usar git log.

Se você está planejando desfazer um commit local completamente, o que quer que você tenha alterado no commit, e se você não se preocupa com nada, basta executar o seguinte comando.

git reset --hard HEAD^1

(Este comando ignorará todo o commit e suas alterações serão perdidas completamente da sua árvore de trabalho local). Se você deseja desfazer sua consolidação, mas deseja suas alterações na área de preparação (antes da consolidação como depois git add), execute o seguinte comando.

git reset --soft HEAD^1

Agora seus arquivos confirmados entram na área de preparação. Suponha que, se você deseja substituir os arquivos, porque precisa editar algum conteúdo errado, execute o seguinte comando

git reset HEAD

Agora, os arquivos confirmados vêm da área preparada para a não preparada. Agora, os arquivos estão prontos para edição; portanto, o que você alterar, você deseja editar e adicioná-lo e fazer um novo / novo commit.

Mais

Se você tiver o Git Extras instalado, poderá executar git undopara desfazer a confirmação mais recente. git undo 3desfaz os três últimos commits.

Queria desfazer os cinco últimos commits em nosso repositório compartilhado. Procurei o ID da revisão para o qual eu queria reverter. Então 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>

Eu prefiro usar git rebase -ipara este trabalho, porque uma boa lista aparece onde eu posso escolher os commits para me livrar. Pode não ser tão direto quanto outras respostas aqui, mas parece certo .

Escolha quantas confirmações você deseja listar e, em seguida, chame assim (para inscrever as últimas três)

git rebase -i HEAD~3

Lista de amostra

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Em seguida, o Git removerá confirmações para qualquer linha que você remover.

Como corrigir a consolidação local anterior

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

Como desfazer a consolidação local anterior

Redefina sua ramificação para o local anterior (por exemplo, usando gitkou git rebase). Em seguida, aplique novamente as 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.

Aviso : O uso descuidado de git reseté uma boa maneira de colocar 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 inseriu outras alterações em seu ramo, pode simplesmente fazer ...

git revert --no-edit HEAD

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

O histórico de consolidação mostrará os dois commit, separadamente .

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

Isso pode ser perigoso - verifique se você tem uma cópia local da ramificação para repush.

Observe também: você não deseja fazer isso se outra pessoa estiver trabalhando na ramificação.

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

Limpe sua filial localmente e repush ...

git push origin (branch_name)

No caso normal, você provavelmente não precisa se preocupar com o histórico de confirmação de ramificação particular. Basta enviar um commit de acompanhamento (consulte 'Como desfazer um commit público' acima) e, posteriormente, fazer uma mescla de squash para ocultar o histórico.

Se você deseja desfazê-lo permanentemente e clonou algum repositório

O ID de confirmação pode ser visto por

git log 

Então você pode fazer -

git reset --hard <commit_id>

git push origin <branch_name> -f

Se você cometeu lixo, mas não empurrou,

git reset --soft HEAD~1

HEAD ~ 1 é uma abreviação para o commit antes do head. Como alternativa, você pode consultar o SHA-1 do hash se desejar redefinir para. A opção --soft excluirá o commit, mas deixará todos os seus arquivos alterados "Alterações a serem confirmadas", conforme o status do git.

Se você quiser se livrar de quaisquer alterações nos arquivos rastreados na árvore de trabalho desde o commit antes do head, use " --hard ".

OU

Se você já empurrou e alguém puxou, o que geralmente é o meu caso, você não pode usar git reset . No entanto, você pode fazer uma reversão do git ,

git revert HEAD

Isso criará um novo commit que reverte tudo o que foi introduzido pelo commit acidental.

No SourceTree (GUI para GitHub), você pode clicar com o botão direito do mouse no commit e fazer um 'Reverse Commit'. Isso deve desfazer suas alterações.

No terminal:

Como alternativa, você pode usar:

git revert

Ou:

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

Um único comando:

git reset --soft 'HEAD^' 

Funciona muito bem para desfazer o último commit local!

Basta redefini-lo usando o comando abaixo usando git:

git reset --soft HEAD~1

Explique: o que git resetfaz, é basicamente resetpara qualquer confirmação que você gostaria de voltar e, se você combiná-la com a --softchave, ela voltará, mas mantenha as alterações no (s) seu (s) arquivo (s), para voltar ao estágio qual o arquivo que acabou de ser adicionado, HEADé o chefe do ramo e, se você combinar com ~1(neste caso, você também usa HEAD^), ele retornará apenas um commit do que você deseja ...

Crio as etapas da imagem abaixo em mais detalhes para você, incluindo todas as etapas que podem ocorrer em situações reais e confirmar o código:

Como desfazer o último commit do Git?

Para restaurar tudo de volta ao estado anterior ao último commit, precisamos redefinir o commit antes do HEAD.

1. Se você não deseja manter as alterações feitas:

   git reset --hard HEAD^
   

2. Se você deseja manter suas alterações:

   git reset --soft HEAD^
   

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

"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 excluirá a confirmação anterior, portanto, use com cuidado! git reset --hardé mais seguro.

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 repo HEAD será redefinido para o HEADid LOG AFTER RESET

Finalmente, o reflog se parece com a imagem abaixo

REFLOG FINAL

Primeira corrida:

git reflog

Ele mostrará todas as ações possíveis que você executou no seu repositório, por exemplo, confirmar, mesclar, puxar, etc.

Então faça:

git reset --hard ActionIdFromRefLog

Desfazer a última confirmação:

git reset --soft HEAD^ ou git reset --soft HEAD~

Isso desfará o último commit.

Aqui --softsignifica redefinir a preparação.

HEAD~ou HEAD^significa mudar para confirmar antes de HEAD.

Substitua a última confirmação por nova confirmação:

git commit --amend -m "message"

Ele substituirá o último commit pelo novo commit.

Outra maneira:

Faça o checkout da filial que você deseja reverter e, em seguida, redefina sua cópia de trabalho local de volta para a confirmação de que você deseja ser a mais recente no servidor remoto (tudo depois que ela se despedir). Para fazer isso, no SourceTree, clique com o botão direito do mouse e selecione "Redefinir BRANCHNAME para este 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á todas as confirmações após a atual em seu repositório local, mas apenas para essa ramificação.

Digite git loge localize o último código hash de confirmação e digite:

git reset <the previous co>

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

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

Simples, execute isso na sua linha de comando:

git reset --soft HEAD~ 

Há muitas maneiras de fazer isso:

Comando Git para desfazer a última confirmação / confirmação anterior:

Aviso: Não use --hard se você não souber o que está fazendo. --hard é muito perigoso e pode excluir seus arquivos.

O comando básico para reverter a confirmação no Git é:

$ git reset --hard <COMMIT -ID>

ou

$ git reset --hard HEAD~<n>

COMMIT-ID : ID do commit

n: é o número das últimas confirmações que você deseja reverter

Você pode obter o ID de confirmação, como mostrado abaixo:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

onde d81d3f1 e be20eb8 são id de confirmação.

Agora vamos ver alguns casos:

Suponha que você queira reverter o último commit 'd81d3f1'. Aqui estão duas opções:

$ git reset --hard d81d3f1

ou

$ git reset --hard HEAD~1

Suponha que você queira reverter o commit 'be20eb8':

$ git reset --hard be20eb8

Para informações mais detalhadas, você pode consultar e experimentar outros comandos também para redefinir a cabeça para um estado especificado:

$ git reset --help

Para uma confirmação local

git reset --soft HEAD~1

ou se você não se lembrar exatamente em qual commit está, poderá usar

git rm --cached <file>

Para uma confirmação por push

A maneira correta de remover arquivos do histórico do repositório está usando git filter-branch. Isso é,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Mas eu recomendo que você use esse comando com cuidado. Leia mais na página de manual do git-filter-branch (1) .

Existem dois cenários principais

Você ainda não enviou o commit

Se o problema foi com arquivos extras que você enviou (e não os deseja no repositório), é possível removê-los usando git rme, em seguida, confirmando com--amend

git rm <pathToFile>

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

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

Após 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 reescreverá sua confirmação local recente, removendo os arquivos extras. Portanto, esses arquivos nunca serão enviados por push e também serão removidos do GC pelo repositório local .git.

Você já enviou o commit

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

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

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

git reset --hard HEAD~1