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

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

Existem duas formas de "desfazer" o seu último commit, dependendo se você já fez o seu commit público (enviado para o 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 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 no commit anterior (HEAD atual).

git revert HEAD

Suas alterações serão revertidas e 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 Coisas

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.

Note que você só deve fazer isso se você ainda não empurrou. Se você empurrou, então você só tem que cometer 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 nos arquivos .Java (e 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 do commit errado.

Para alterar o último commit

Substitua os arquivos no índice:

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

Então, se é um ramo privado, emendar 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 alterar um commit anterior, use o incrível interativo rebase )

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 @~ redefine 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 git help reset, especificamente as seções --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 git revert <commit-id>

Para obter o ID de commit, apenas use git log

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, 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 depois de 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 melhorar os arquivos, porque precisa editar algum conteúdo errado, faça o seguinte comando

git reset HEAD

Agora arquivos comprometidos vêm 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.

Mais

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

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>

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

Escolha quantos commits você quer listar, então invoque assim (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.

Como corrigir o commit local anterior

Use git-gui (ou similar) para executar um git commit --amend. A partir da 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 filial 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 de git reset é uma boa maneira de deixar sua cópia de trabalho confusa. Recomendo que os novatos do Git evitem isso, se puderem.

Como desfazer um commit público

Realize um cherry pick reverso ( git-revert ) para desfazer as alterações.

Se você ainda não puxou outras alterações para o seu ramo, você pode simplesmente fazer ...

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 da ramificação privada no repositório público

Isso pode ser perigoso - certifique-se de ter uma cópia local da ramificação para repassar

Observe também: você não quer fazer isso se alguém pode estar trabalhando no ramo.

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

Limpe a sua filial 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 primitivo. Apenas pressione uma subseqüente confirmação (veja 'Como desfazer um commit público' acima), e depois, faça um squash -merge para esconder o histórico.

Se você tiver cometido lixo, mas não for empurrado,

git reset --soft HEAD~1

HEAD ~ 1 é um atalho para o commit antes da cabeça. Alternativamente, você pode consultar o SHA-1 do hash se você deseja 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 que o commit antes do head use "--hard".

OR

Se você já empurrou e alguém puxou o que geralmente é meu caso, você não pode usar git reset. Você pode no entanto fazer um git revert,

git revert HEAD

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

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

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

Um único comando:

git reset --soft 'HEAD^' 

Funciona muito bem para desfazer o último commit local!

Apenas redefina o comando abaixo usando git:

git reset --soft HEAD~1

Explique: o que git reset faz, é 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 para o estágio em que o arquivo acabou de ser adicionado, HEAD é o cabeçalho do branch e se você combinar com ~1 (neste caso você também usa HEAD^), ele irá retornar apenas 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:

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.

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 APÓS RESET

Finalmente o reflog parece com a imagem abaixo

REFLOG FINAL

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

git reset --hard HEAD^ 

"Limpe arquivos desconhecidos da árvore de trabalho"

git clean    

veja - Referência Rápida do Git

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

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

Anular o último commit:

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

Isto irá desfazer o último commit.

Aqui --soft significa redefinir para teste.

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

Substituir último commit por novo commit:

git commit --amend -m "message"

Ele substituirá o último commit pelo novo commit.

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

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

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

git reset <the previous co>

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

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

Simples, execute isto na sua linha de comando:

git reset --soft HEAD~ 

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

git reset --hard HEAD~1

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 rm e, em seguida, confirmar com --amend

git rm <pathToFile>

Você também pode remover diretórios inteiros com -r, ou até mesmo combinar com outros Bash comandos

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

Isto irá reescrever seu recente commit local removendo os arquivos extras, então, esses arquivos nunca serão enviados no 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 Push com a opção -f, mas é not recommended, 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).

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 is too dangerous, e pode deletar 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 consultar e testar alguns outros comandos também para redefinir a cabeça para um estado especificado:

$ git reset --help

Para um commit local

git reset --soft HEAD~1

ou se você não se lembra exatamente em qual commit é, você pode usar

git rm --cached <file>

Para um commit empurrado

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

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

Mas eu recomendo que você use este comando com cuidado. Leia mais em git-filter-branch (1) Página Manual.

Você pode usar:

git reset [email protected]{1}

Este comando irá deletar seu commit errado sem um log do Git.

Acho que temos o arquivo code.txt. Fazemos algumas mudanças e nos comprometemos. Podemos desfazer esse commit de três maneiras, mas primeiro você deve saber o que é o arquivo de teste ... Um arquivo de teste é um arquivo pronto para commitar e se você executar git status este arquivo será mostrado com a cor verde e se isso não for testado será mostrado com cor vermelha:

Isso significa que, se você confirmar sua alteração, suas alterações nesse arquivo não serão salvas. Você pode adicionar esse arquivo em seu estágio com git add code.txt e, em seguida, confirmar sua alteração:

Anular o último commit:

1. Agora, se quisermos apenas desfazer o commit sem outras mudanças, podemos usar

   git reset --soft HEAD^ 

2. Se quisermos desfazer o commit e suas alterações (ISTO IS PERIGOSO, porque sua alteração perderá), podemos usar

   git reset --hard HEAD^

3. E se quisermos desfazer o commit e remover as mudanças do palco, podemos usar

   git reset --mixed HEAD^ ou em formato abreviado git reset HEAD^

Normalmente, você quer desfazer um commit porque você cometeu um erro e quer consertá-lo - essencialmente o que o OP fez quando ele fez a pergunta. Então você realmente quer refazer um commit.

A maioria das respostas aqui se concentra na linha de comando. Enquanto a linha de comando é a melhor maneira de usar o Git quando você está confortável com ele, é provavelmente um pouco estranho para aqueles que vêm de outros sistemas de controle de versão para o Git. 

Veja como fazer isso usando uma GUI. Se você tem o Git instalado, você já tem tudo o que precisa para seguir estas instruções.

NOTA: Vou assumir aqui que você percebeu que o commit estava errado antes de você pressioná-lo. Se você não sabe o que é empurrar, você provavelmente não empurrou, então continue com as instruções. Se você tiver pressionado o commit defeituoso, a maneira menos arriscada é apenas seguir o commit defeituoso com um novo commit que conserte as coisas, da maneira que você faria em um sistema de controle de versão que não permite reescrever o histórico. 

Dito isso, aqui está como corrigir seu commit mais recente usando uma GUI:

1. Navegue até o seu repositório na linha de comando e inicie o gui com git gui
2. Escolha "Amend last commit". Você verá sua última mensagem de commit, os arquivos que você colocou e os arquivos que você não fez.
3. Agora mude as coisas para como você quer que elas pareçam e clique em Confirmar. 

Apenas desfaça o último commit: 

git reset --soft HEAD~

Ou desfaça o tempo antes do último commit: 

git reset --soft HEAD~2

Ou desfaça qualquer commit anterior: 

git reset --soft <commitID>

(você pode obter o commitID usando git reflog)

Quando você desfizer um commit anterior, lembre-se de limpar o local de trabalho com

git clean

Mais detalhes podem ser encontrados nos documentos: git-reset

Desfazer o último commit

Existem várias situações em que você realmente deseja desfazer esse último commit em seu código. Por exemplo. porque você gostaria de reestruturá-lo extensivamente - ou mesmo descartá-lo completamente!

Nestes casos, o comando "reset" é seu melhor amigo:

$ git reset --soft HEAD~1

O comando acima (reset) irá rebobinar sua atual ramificação HEAD para a revisão especificada. Em nosso exemplo acima, gostaríamos de retornar ao anterior à revisão atual - efetivamente tornando nosso último commit desfeito.

Observe o sinalizador --soft: isso garante que as alterações nas revisões desfeitas sejam preservadas. Depois de executar o comando, você encontrará as alterações como modificações locais não confirmadas em sua cópia de trabalho.

Se você não quiser manter essas alterações, basta usar o sinalizador --hard. Certifique-se de fazer isso apenas quando tiver certeza de que não precisa mais dessas alterações.

$ git reset --hard HEAD~1

Para desfazer seu commit local, você usa git reset <commit>. Também esse tutorial é muito útil para mostrar como funciona.

Alternativamente, você pode usar git revert <commit>: reverting deve ser usado quando você quer adicionar outro commit que reverte as mudanças (mas as mantém no histórico do projeto).

Um ciclo típico de Git

Ao falar de comandos relacionados ao Git nas respostas anteriores, gostaria de compartilhar meus ciclos típicos do Git com todos os leitores que podem ser úteis. Aqui está como eu trabalho com o Git,

1. Clonando pela primeira vez a partir do servidor remoto

   git clone $project

2. Puxando do remoto (quando eu não tenho um commit local pendente para Push)

   git pull

3. Adicionando um novo file1 local em $ to_be_committed_list (apenas imagine $ to_be_committed_list significa staged area)

   git add $file1

4. Removendo, por engano, o arquivo2 de $ to_be_committed_list (suponha que o arquivo2 seja adicionado como o passo 3, que eu não queria)

   git reset $file2

5. Confirmando o arquivo1 que está em $ to_be_committed_list

   git commit -m "commit message description"

6. Sincronizando a confirmação local com o repositório remoto antes de pressionar

   git pull --rebase

7. Resolvendo quando ocorre conflito pré-requisito configure o mergetool

   git mergetool #resolve merging here, also can manually merge

8. Adicionando arquivos resolvidos por conflitos, digamos file1:

   git add $file1

9. Continuando meu comando rebase anterior

   git rebase --continue

10. Empurrando pronto e já sincronizado último commit local

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

No meu caso eu cometi e empurrei para o ramo errado, então o que eu queria era ter todas as minhas alterações de volta para que eu pudesse enviá-las para um novo branch correto, então eu fiz isso:

No mesmo ramo que você cometeu e empurrou, se você digitar "git status" você não verá nada novo porque você cometeu e empurrou, agora digite:

git reset --soft HEAD~1

Isso fará com que todas as alterações (arquivos) sejam recuperadas na área do palco, agora para recuperá-las no diretório de trabalho (unstage) que você acabou de digitar:

git reset FILE

Onde "Arquivo" é o arquivo que você deseja confirmar novamente. Agora este FILE deve estar no diretório de trabalho (unstaged) com todas as mudanças que você fez. Agora você pode mudar para qualquer ramificação que desejar e confirmar as alterações nesse ramo. Espero que isso ajude outras pessoas que cometeram o mesmo erro que eu fiz. É claro que o branch inicial que você cometeu ainda está lá com todas as alterações, mas no meu caso isso foi ok, se não for para você, você pode procurar maneiras de reverter o commit naquele branch.

USUÁRIOS DO VISUAL STUDIO (2015, etc.)

Se você não pode sincronizar no Visual Studio como você não tem permissão para empurrar para um ramo como "desenvolvimento", então, tanto quanto eu tentei, no Visual Studio nem o REVERTER NOR o REDEFINIR (duro ou macio) funcionaria.

Pela resposta com TONELADAS DE VOTOS:

Use isto no comando Prompt da raiz do seu projeto para descobrir qualquer coisa que tente ser pressionada:

git reset --hard HEAD~1

Backup ou Zip seus arquivos apenas no caso de você não deseja perder nenhum trabalho, etc ...

Eu obtive o ID de commit de bitbucket e então fiz:

git checkout commitID .

Exemplo:

git checkout 7991072 .

E foi revertido para aquela cópia de trabalho desse commit.

Suponha que você tenha cometido um commit errado localmente e o tenha enviado para um repositório remoto. Você pode desfazer a bagunça com esses dois comandos:

Primeiro, precisamos corrigir nosso repositório local voltando ao commit que desejamos:

git reset --hard <previous good commit id where you want the local repository  to go>

Agora nós forçadamente Empurrar este bom commit no repositório remoto usando este comando:

git Push --force-with-lease

A versão 'with-lease' da opção force impedirá a exclusão acidental de novos commits que você não conhece (ou seja, vindo de outra fonte desde o último pull).

Anular o último commit:

git reset --soft HEAD^ or git reset --soft HEAD~

Isso desfará o último commit.

Aqui --soft significa redefinir para teste.

HEAD~ or HEAD^ significa mover para commit antes de HEAD.

Substituir último commit por novo commit:

git commit --amend -m "message"

Ele substituirá o último commit pelo novo commit.

Você precisa fazer o mais fácil e rápido

    git commit --amend

se é um ramo privado ou

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

se é um ramo compartilhado ou público.

Use este comando:

git checkout -b old-state number_commit

Use este comando

git checkout -b old-state 0d1d7fc32

Remover um commit errado que já foi enviado para o Github

git Push Origin +(previous good commit id):(branch name)

Por favor especifique o último id de confirmação que gostaria de repor no Github.

Por exemplo. Se o id de commit mais recente estiver errado, especifique o ID de commit anterior no comando git acima com o nome do branch. 

Você pode obter o ID de confirmação anterior usando git log

Para se livrar de (todas as mudanças) último commit, last 2 commits e last n commits:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

E, para se livrar de qualquer coisa depois de um commit específico:

git reset --hard <commit sha>

por exemplo., 

git reset --hard 0d12345

PS:
1- Tenha cuidado, porque a opção "hard", elimina as alterações locais No seu repo e reverte para o commit mencionado anteriormente. Você deve executar isto se tiver certeza de que errou em sua (s) última (s) confirmação (ões) E gostaria de voltar no tempo. 

2- Normalmente, 7 letras de "commit sha" são suficientes, mas em projetos maiores , Você pode precisar de até 12 letras para garantir uma exclusividade. Você Também pode mencionar as 40 letras inteiras sha.

3- Os comandos acima funcionam no Github for Windows também.

Você sempre pode fazer um git checkout <SHA code> da versão anterior e, em seguida, confirmar novamente com o novo código.

Você pode desfazer seus commits do Git de duas maneiras: Primeiro você pode usar git revert, se você quiser manter seu histórico de commits:

git revert HEAD~3
git revert <hashcode of commit>

Em segundo lugar, você pode usar git reset, que excluiria todo o seu histórico de commits e traria sua cabeça para commit onde quiser.

git reset <hashcode of commit>
git reset HEAD~3

Você também pode usar a palavra-chave --hard se alguma delas começar a se comportar de outra forma. Mas, eu recomendaria apenas até que seja extremamente necessário.

Referência: Como desfazer último commit no Git?

Se você tiver o Git Extensions instalado, você pode facilmente desfazer/reverter qualquer commit (você pode baixar extensões git de here ).

Abra as extensões do Git, clique com o botão direito do mouse no commit que você deseja reverter e selecione "Reverter confirmação". 

Um pop-up será aberto (veja a imagem abaixo)

Selecione "Criar automaticamente um commit" se você quiser confirmar diretamente as alterações revertidas ou se quiser confirmar manualmente as alterações revertidas, mantenha a caixa desmarcada e clique no botão "Reverter este commit".

Apenas use git reset --hard <last good SHA> para redefinir suas alterações e dar um novo commit. Você também pode usar git checkout -- <bad filename>.

Eu encontrei o this site que descreve como desfazer coisas que você cometeu no repositório.

Alguns comandos:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Aqui está o site: Oh shit, git! .

Aqui estão muitas receitas como desfazer as coisas no Git. Alguns deles:

Oh merda, eu preciso mudar a mensagem no meu último commit!

git commit --amend
# follow prompts to change the commit message

Oh merda, eu acidentalmente cometi algo para dominar que deveria ter sido em um novo ramo!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

Você pode desfazer seus commits do repositório local. Por favor, siga o cenário abaixo.

Na imagem abaixo eu verifico a ramificação 'test' (usando o comando Git git checkout -b test) como um local e verifico o status (usando o comando Git git status) da ramificação local que não há nada para confirmar.

Na próxima imagem da imagem você pode ver aqui Eu fiz algumas alterações em Filter1.txt e adicionei esse arquivo à área de preparação e então confirmei minhas alterações com alguma mensagem (usando o comando Git git commit -m "Doing commit to test revert back").

"-m é para a mensagem de confirmação"

Na próxima imagem você pode ver o seu log de commits o que você fez commits (usando o comando Git git log).

Portanto, na imagem acima você pode ver o ID de commit com cada commit e com sua mensagem de commit agora qualquer consolidação que você queira reverter ou desfazer cópia que comete id e aperte o comando abaixo do Git, git revert {"paste your commit id"}. Exemplo:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

Eu reverti meu último commit. Agora, se você verificar o status do seu Git, você pode ver o arquivo modificado que é Filter1.txt e ainda para confirmar.

A maneira mais simples de desfazer o último commit é

git reset HEAD^

Isso trará o estado do projeto antes de você ter feito o commit.

No IntelliJ IDEA você pode simplesmente abrir o registro do repositório Git pressionando Alt+9, clique com o botão direito do mouse em alguma tag da lista de commits e selecione: "Redefinir ramificação atual para aqui ...".

HEAD:

Antes de reset commit devemos saber sobre HEAD ... HEAD não é nada além do seu estado atual em seu diretório de trabalho. É representado por um número de confirmação.

Git commit:

Cada alteração atribuída sob um commit é representada por uma tag exclusiva. Confirmações não podem ser excluídas. Então, se você quiser o seu último commit, você pode simplesmente mergulhar nele usando git reset.

Você pode mergulhar no último commit usando dois métodos:

Método 1: (se você não souber o número de commit, mas quiser passar para o primeiro)

git reset HEAD~1  # It will move your head to last commit

Método 2: (se você souber o commit, simplesmente reconfigure seu commit conhecido)

git reset 0xab3 # Commit number

Nota: se você quiser saber uma tentativa de commit recente git log -p -1

Aqui está a representação gráfica:

A diferença entre o git reset --mixed, --soft e --hard

Pré-requisito: Quando uma modificação em um arquivo existente em seu repositório É feita, essa mudança é inicialmente considerada não-organizada. Para confirmar as alterações, é necessário encenar o que significa adicionando-o ao índice usando git add. Durante uma operação de consolidação, os arquivos Que são testados são adicionados a um índice.

Vamos dar um exemplo: 

- A - B - C (master)

HEAD aponta para C e o índice corresponde a C.

--suave

• Quando executamos git reset --soft B com a intenção de remover o commit C e apontando o master/HEAD para B. 
• O mestre/HEAD agora apontará para B, mas o index ainda mudou de C. 
• Ao executar git status você pode ver os arquivos indexados em commit C como staged. 
• Executar um git commit nesse ponto criará uma nova confirmação com as mesmas alterações que C

--misturado

• Execute git reset --mixed B. 
• Na execução, master/HEAD apontará para B e o index também será modificado para corresponder a B por causa do sinalizador misto usado. 
• Se executarmos git commit neste momento, nada acontecerá, pois o index corresponde a HEAD.
• Ainda temos as alterações no diretório de trabalho, mas como elas não estão no índice, o status git mostra-as como não organizadas. 
• Para cometê-los, você deve git add e depois confirmar como de costume.

--Difícil

• Execute git reset --hard B
• Na execução, master/HEAD apontará para B e modificará seu diretório de trabalho
• As alterações adicionadas em C e todas as alterações não confirmadas serão removed.
• Os arquivos na cópia de trabalho corresponderão à confirmação B, isso resultará na perda permanente de todas as alterações feitas na confirmação C, além das alterações não confirmadas

Espero que esta comparação de sinalizadores disponíveis para uso com o comando git reset ajude alguém a usá-los com sabedoria. Refira-os para mais detalhes link1 & link2

Rebasing e drop commits são os melhores quando você quer manter o histórico limpo Útil ao propor patches para um branch público etc.

Se você tiver que largar o commit mais alto, o seguinte one-liner ajuda

git rebase --onto HEAD~1 HEAD

Mas se você quiser perder 1 de muitos commits, você disse

a -> b -> c -> d -> mestre

e você quer soltar commit 'c'

git rebase --onto b c

Isso fará com que 'b' seja a nova base de 'd' eliminando 'c'

Encontre o último código de hash de commit, vendo o log por:

git log

Então

git reset <the previous co>

Para completar, darei um método obviamente óbvio que foi negligenciado pelas respostas anteriores.

Como o commit não foi enviado, o controle remoto não foi alterado, então:

1. Exclua o repositório local.
2. Clone o repositório remoto.

Isso às vezes é necessário se o seu cliente Git for bye-bye. (por exemplo, erros non-fast-forward)

Não se esqueça de voltar a confirmar suas saved changes desde o último Push.

Supondo que você esteja trabalhando no Visual Studio, se você entrar no seu histórico de filiais e examinar todos os seus commits, simplesmente selecione o evento antes do commit que você deseja desfazer, clique com o botão direito nele e selecione Revert. Fácil assim.

Se você gostaria de eliminar os arquivos errados, você deve fazer 

git reset --soft <your_last_good_commit_hash_here> Aqui, se você fizer git status, você verá os arquivos na área de preparação. Você pode selecionar os arquivos errados e retirá-los da área de preparação.

Como o seguinte.

git reset wrongFile1 wrongFile2 wrongFile3

Agora você pode apenas adicionar os arquivos que você precisa para empurrar,

git add goodFile1 goodFile2

cometê-los 

git commit -v ou git commit -am "Message"

e empurre

git Push Origin master

No entanto, se você não se importa com os arquivos alterados, poderá fazer um hard reset para um bom commit anterior e enviar tudo para o servidor.

por 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

Se você já publicou seus arquivos errados no servidor, pode usar o sinalizador --force para enviar para o servidor e editar o histórico.

git Push --force Origin master

Tente isso, hard reset para commit anterior onde esses arquivos não foram adicionados, então:

git reset --hard <commit_hash>

Certifique-se de que você tenha um backup de suas alterações apenas para o caso de ser uma reinicialização forçada, o que significa que elas serão perdidas (a menos que você tenha escondido antes)

git reset --soft HEAD~1

A redefinição irá rebobinar sua ramificação HEADatual para a revisão especificada. Nota o sinalizador --soft: isso garante que as alterações nas revisões desfeitas sejam preservadas. Depois de executar o comando, você encontrará as alterações como modificações locais não confirmadas em sua cópia de trabalho.

Se você não quiser manter essas alterações, basta usar o sinalizador --hard. Certifique-se de fazer isso apenas quando tiver certeza de que não precisa mais dessas alterações.

 git reset --hard HEAD~1

Desfazendo Múltiplos Commits

git reset --hard 0ad5a7a6

lembre-se, no entanto, que usar o comando reset desfaz todos os commits que vieram depois daquele que você retornou:

O que eu faço toda vez que eu preciso desfazer um commit/commits são:

1. git reset HEAD~<n> // o número de últimos commits que eu preciso desfazer

2. git status // opcional. Todos os arquivos estão agora em vermelho (sem emendas).

3. Agora, eu posso adicionar e confirmar apenas os arquivos que eu preciso:

   • git add <file names> & git commit -m "message" -m "details"
4. Opcional: posso reverter as alterações dos arquivos restantes, se necessário, para sua condição anterior, com checkout:
   • git checkout <filename>
5. se eu já tivesse empurrado para a remota Origin, anteriormente:
   • git Push Origin <branch name> -f // use -f para forçar o Push.

Se você quiser desfazer o primeiro commit em seu repo

Você encontrará esse problema:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

O erro ocorre porque se o último commit é o commit inicial (ou nenhum pais) do repositório, não há HEAD ~.

Solução

Se você deseja redefinir o único commit na ramificação "master"

$ git update-ref -d HEAD
$ git rm --cached -r .

Obtenha o último ID de confirmação usando este comando (no log um no topo é o mais recente):

git log

Obtenha o ID de confirmação (GUID) e execute este comando:

git revert <commit_id>

Como edit um commit anterior

Geralmente eu não quero desfazer um monte de commits, mas sim editar um commit anterior para como eu gostaria de tê-lo comprometido em primeiro lugar.

Eu me encontrei consertando um commit passado com frequência suficiente para que eu escrevesse um roteiro para ele.

Aqui está o fluxo de trabalho:

1. git commit-edit <commit-hash>
   

   Isso vai te deixar no commit que você quer editar.

   As alterações do commit serão un staged, prontas para serem colocadas como você gostaria que fosse a primeira vez.

2. Corrigir e organizar o commit como você gostaria que tivesse sido em primeiro lugar.

   (Você pode usar o git stash save --keep-index para remover qualquer arquivo que não esteja sendo confirmado)

3. Refaça o commit com --amend, por exemplo:

   git commit --amend
   

4. Complete o rebase:

   git rebase --continue
   

Chame isso de git-commit-edit seguinte e coloque-o em seu $PATH:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

Se você simplesmente quer destruir todas as alterações/commits locais e fazer com que sua filial local pareça com a ramificação Origin da qual você começou ...

git reset --hard Origin/branch-name

git revert commit

Isso gerará as alterações opostas da confirmação que você deseja reverter e, em seguida, apenas confirmará essas alterações. Eu acho que esse é o jeito mais simples.

https://git-scm.com/docs/git-revert

substituir sua versão local, incluindo suas alterações com a versão do servidor, estas duas linhas de código forçará git para puxar e substituir local. Abra o comando Prompt e navegue até a raiz do projeto git. Se você usar o VS, clique em Team, Synch e clique em "Open Command Prompt" (veja imagem) abaixo. 

Uma vez no prompt do Cmd, siga em frente com as duas instruções a seguir. 

git fetch --all

então você faz

git reset --hard Origin/master

isso sobrescreverá a versão local existente com a do servidor git

git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back