git-commit alterações - Como faço para desfazer os commits mais recentes no Git?




revert pull (25)

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?


Answers

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


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>

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.


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.


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


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


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:


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

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.


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


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.


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.


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.


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

git reset <the previous co>

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.


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.

Se você está planejando desfazer um commit local inteiramente, o que quer que você tenha alterado no commit, e se você não se preocupa com isso, apenas faça o seguinte comando.

git reset --hard HEAD^1

(Este comando irá ignorar todo o seu commit e suas alterações serão perdidas completamente da sua árvore de trabalho local). Se você deseja desfazer sua confirmação, mas deseja suas alterações na área temporária (antes de confirmar como após o git add ), faça o seguinte comando.

git reset --soft HEAD^1

Agora seus arquivos comprometidos entram na área de preparação. Suponha que, se você quiser usar os arquivos, porque precisa editar algum conteúdo errado, faça o seguinte comando

git reset HEAD

Arquivos agora comprometidos para vir da área preparada para a área sem estágio. Agora os arquivos estão prontos para edição, então o que quer que você mude, você quer ir editá-lo e adicioná-lo e fazer um novo / novo commit.

More


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



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.


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

git reset --soft HEAD~ 

Há muitas maneiras de fazer isso:

Comando Git para desfazer o último commit / commit anterior:

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

Comando básico para reverter o commit no Git é:

$ git reset --hard <COMMIT -ID>

ou

$ git reset --hard HEAD~<n>

COMMIT-ID : ID para o commit

n: é o número de últimos commits que você deseja reverter

Você pode obter o ID de confirmação conforme 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 se referir e experimentar alguns outros comandos também para redefinir a cabeça para um estado especificado:

$ git reset --help







git git-commit git-reset git-revert