voltar - remover commit git




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

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?


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.


Desfazer o último commit:

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

Isso desfará o último commit.

Aqui --soft significa redefinir para teste.

HEAD~ ou HEAD^ significa passar para commit antes de HEAD.

Substituir último commit por novo commit:

git commit --amend -m "message"

Ele substituirá o último commit pelo novo commit.


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.


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


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:


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.


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

Escolha quantos commits você quer listar, então invoque como este (para listar os últimos três)

git rebase -i HEAD~3

Lista de amostras

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

Então o git irá remover os commits de qualquer linha que você remover.


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>

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


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:

Você pode alternativamente 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.

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.


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

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ê tiver cometido lixo, mas não for empurrado,

git reset --soft HEAD~1

HEAD ~ 1 é uma abreviação para o commit antes da cabeça. Alternativamente, você pode se referir ao SHA-1 do hash se você quiser redefinir para. A opção --soft excluirá o commit, mas deixará todos os seus arquivos alterados "Changes to be committed", como o status git colocaria.

Se você quiser se livrar de qualquer alteração 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 o git reset . Você pode no entanto fazer um git reverter ,

git revert HEAD

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


Um único comando:

git reset --soft 'HEAD^' 

Funciona muito bem para desfazer o último commit local!


Use git revert commit-id

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


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


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.


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

git reset --soft HEAD~ 

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




git-revert