ti-enxame.com

Como reverter um repositório Git para um commit anterior

Como eu reverti do meu estado atual para um instantâneo feito em um certo commit?

Se eu fizer git log, recebo a seguinte saída:

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

Como reverter para o commit a partir de 3 de novembro, ou seja, confirmar 0d1d7fc?

6795
Crazy Serb

Isso depende muito do que você quer dizer com "reverter".

Mudar temporariamente para um commit diferente

Se você quiser voltar temporariamente a ele, brincar e voltar para onde está, tudo o que precisa fazer é verificar o commit desejado:

# This will detach your HEAD, that is, leave you with no branch checked out:
git checkout 0d1d7fc32

Ou se você quiser fazer commits enquanto estiver lá, vá em frente e faça um novo branch enquanto estiver fazendo isso:

git checkout -b old-state 0d1d7fc32

Para voltar para onde você estava, basta verificar o ramo em que estava novamente. (Se você fez alterações, como sempre, ao alternar as ramificações, você terá que lidar com elas da maneira apropriada. Você pode redefinir para jogá-las fora; pode armazenar, fazer check-out, ocultar pop para levá-las com você; eles para um ramo lá se você quiser um ramo lá.)

Difícil excluir commits não publicados

Se, por outro lado, você quiser realmente se livrar de tudo que fez desde então, existem duas possibilidades. Um, se você não publicou nenhum desses commits, simplesmente redefina:

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

Se você errar, você já jogou fora suas alterações locais, mas pode pelo menos voltar para onde estava antes, redefinindo novamente.

Desfazer commits publicados com novos commits

Por outro lado, se você publicou o trabalho, provavelmente não deseja redefinir o ramo, pois isso está efetivamente reescrevendo o histórico. Nesse caso, você poderia de fato reverter os commits. Com o Git, revert tem um significado muito específico: crie um commit com o patch reverso para cancelá-lo. Desta forma você não reescreve nenhum histórico.

# This will create three separate revert commits:
git revert a867b4af 25eee4ca 0766c053

# It also takes ranges. This will revert the last two commits:
git revert HEAD~2..HEAD

#Similarly, you can revert a range of commits using commit hashes:
git revert a867b4af..0766c053 

# Reverting a merge commit
git revert -m 1 <merge_commit_sha>

# To get just one, you could use `rebase -i` to squash them afterwards
# Or, you could do it manually (be sure to do this at top level of the repo)
# get your index and work tree into the desired state, without changing HEAD:
git checkout 0d1d7fc32 .

# Then commit. Be sure and write a good message describing what you just did
git commit

A git-revert manpage realmente cobre muito disso em sua descrição. Outro link útil é esta seção git-scm.com discutindo git-revert .

Se você decidir que não quer reverter, você pode reverter a reversão (como descrito aqui) ou redefinir para antes da reversão (veja a seção anterior).

Você também pode achar essa resposta útil nesse caso:
Como mover HEAD de volta para um local anterior? (Cabeça destacada)

8690
Cascabel

Revertendo a cópia de trabalho para a confirmação mais recente

Para reverter para um commit anterior, ignorando quaisquer alterações:

git reset --hard HEAD

onde HEAD é o último commit em sua ramificação atual

Revertendo a cópia de trabalho para uma confirmação mais antiga

Para reverter para um commit mais antigo que o commit mais recente:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

Os créditos vão para uma pergunta similar do Stack Overflow,Reverter para um commit por um hash SHA no Git?.

1451
boulder_ruby

Muitas respostas complicadas e perigosas aqui, mas na verdade é fácil:

git revert --no-commit 0766c053..HEAD
git commit

Isso irá reverter tudo, de HEAD de volta para o hash de commit, o que significa que ele irá recriar o estado de commit na árvore de trabalho como se every commit desde que foi retornado. Você pode, então, confirmar a árvore atual e criar um novo commit essencialmente equivalente ao commit para o qual você "reverteu".

(O sinalizador --no-commit permite que o git reverta todos os commits de uma só vez - caso contrário, você será solicitado a enviar uma mensagem para cada commit no intervalo, sujando seu histórico com novos commits desnecessários.)

Isto é um maneira segura e fácil de reverter para um estado anterior. Nenhum histórico é destruído, então ele pode ser usado para commits que já foram públicos.

1433
Yarin

A melhor opção para mim e provavelmente para os outros é a opção de reset do Git:

git reset --hard <commidId> && git clean -f

Esta foi a melhor opção para mim! É simples, rápido e eficaz!


Nota: Como mencionado nos comentários, não faça isso se você estiver compartilhando sua ramificação com outras pessoas que tenham cópias dos commits antigos

Também a partir dos comentários, se você quiser um método menos 'ballzy' você pode usar

git clean -i

182
Pogrindis

Antes de responder, vamos adicionar algumas informações explicando o que é este HEAD.

First of all what is HEAD?

HEAD é simplesmente uma referência à confirmação atual (mais recente) na ramificação atual. Só pode haver um único HEAD a qualquer momento (excluindo git worktree).

O conteúdo de HEAD é armazenado dentro de .git/HEAD e contém os 40 bytes SHA-1 da confirmação atual.


detached HEAD

Se você não está no commit mais recente - o que significa que HEAD está apontando para um commit anterior no histórico, ele é chamadodetached HEAD.

Enter image description here

Na linha de comando, ficará assim - SHA-1 em vez do nome da ramificação, pois o HEAD não está apontando para a ponta da ramificação atual:

Enter image description here


Algumas opções sobre como recuperar-se de uma CABEÇA desanexada:


git checkout

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

Isto irá verificar o novo ramo apontando para o commit desejado. Este comando fará o checkout para um determinado commit.

Neste ponto, você pode criar uma ramificação e começar a trabalhar a partir deste ponto:

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

git reflog

Você sempre pode usar o reflog também. git reflog exibirá qualquer mudança que atualizou o HEAD e o check out da entrada desejada do reflog irá setar o HEAD de volta para este commit.

Toda vez que o HEAD é modificado, haverá uma nova entrada no reflog

git reflog
git checkout [email protected]{...}

Isso fará com que você volte ao seu compromisso desejado

Enter image description here


git reset HEAD --hard <commit_id>

"Mova" sua cabeça de volta para o commit desejado.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.
  • Nota: ( desde o Git 2.7 ) você também pode usar o git rebase --no-autostash também.

Este esquema ilustra qual comando faz o quê. Como você pode ver, reset && checkout modifica o HEAD.

Enter image description here

143
CodeWizard

Se você deseja "descomentar", apagar a última mensagem de confirmação e colocar os arquivos modificados novamente no armazenamento temporário, use o comando:

git reset --soft HEAD~1
  • --soft indica que os arquivos não confirmados devem ser mantidos como arquivos de trabalho opostos a --hard, que os descartariam.
  • HEAD~1 é o último commit. Se você quiser reverter 3 commits, poderá usar HEAD~3. Se você quiser reverter para um número de revisão específico, também poderá fazer isso usando o hash SHA.

Este é um comando extremamente útil em situações em que você cometeu a coisa errada e deseja desfazer o último commit.

Fonte: http://nakkaya.com/2009/09/24/git-delete-last-commit/

124
Stephen Ostermiller

Eu tentei muitas maneiras de reverter as mudanças locais no Git, e parece que isso funciona melhor se você quiser reverter para o último estado de confirmação.

git add . && git checkout master -f

Pequena descrição:

  • NÃO irá criar nenhum commit como git revert.
  • NÃO irá separar o seu HEAD como o git checkout <commithashcode>.
  • Substituirá todas as alterações locais e EXCLUIR todos os arquivos adicionados desde o último commit na ramificação.
  • Ele funciona apenas com nomes de ramificações, portanto, você pode reverter apenas para o commit mais recente no branch dessa maneira.

Eu encontrei uma maneira muito mais conveniente e simples de alcançar os resultados acima:

git add . && git reset --hard HEAD

onde HEAD aponta para o commit mais recente em sua ramificação atual.

É o mesmo código de código que boulder_Ruby sugeriu, mas eu adicionei git add . antes de git reset --hard HEAD para apagar todos os novos arquivos criados desde o último commit, pois é o que a maioria das pessoas espera que eu acredite ao reverter para o commit mais recente.

105
Roman Minenok

Você pode fazer isso pelos dois comandos a seguir:

git reset --hard [previous Commit SHA id here]
git Push Origin [branch Name] -f

Ele removerá seu commit anterior do Git.

Se você quiser manter suas alterações, você também pode usar:

git reset --soft [previous Commit SHA id here]

Em seguida, salvará suas alterações.

94
kiran boghra

OK, voltar ao commit anterior no git é bem facil ...

Reverta sem manter as alterações:

git reset --hard <commit>

Reverta mantendo as alterações:

git reset --soft <commit>

Explique: usando git reset, você pode redefinir para um estado específico, é comum usá-lo com um hash de confirmação como você vê acima.

Mas como você vê a diferença está usando os dois sinalizadores --soft e --hard, por padrão git reset usando --soft flag, mas é uma boa prática usar sempre o flag, eu explico cada flag:


--suave

O sinalizador padrão, conforme explicado, não precisa fornecê-lo, não altera a árvore de trabalho, mas inclui todos os arquivos de alterações prontos para serem confirmados, portanto, você retorna ao status de confirmação, que altera os arquivos para serem desfeitos.


--Difícil

Tenha cuidado com esse sinalizador, ele redefine a árvore de trabalho e todas as alterações nos arquivos rastreados e todas desaparecerão!


Eu também criei a imagem abaixo que pode acontecer em uma vida real trabalhando com o git:

git reset to a commit

63
Alireza

Nada aqui funcionou para mim além dessa combinação exata:

git reset --hard <commit_hash>
git Push Origin <branch_name> --force

A chave aqui é forçar o Push, sem commits/commits adicionais, etc.

59
serdarsenay

Digamos que você tenha os seguintes commits em um arquivo de texto chamado ~/commits-to-revert.txt (usei git log --pretty=oneline para obtê-los)

fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

Crie um script Bash Shell para reverter cada um deles:

#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
    git revert $i --no-commit
done

Isso reverte tudo de volta ao estado anterior, incluindo criações de arquivos e diretórios e exclusões, efetua o commit para sua ramificação e você retém o histórico, mas você o reverte para a mesma estrutura de arquivos. Por que o Git não tem um git revert --to <hash> está além de mim.

57
Lance Caraccioli

Alternativas Extra para as Soluções da Jefromi

As soluções do Jefromi são definitivamente as melhores, e você definitivamente deveria usá-las. No entanto, por questão de completude, eu também queria mostrar essas outras soluções alternativas que também podem ser usadas para reverter um commit (no sentido de que você cria um novo commit que desfaz mudanças no commit anterior , apenas como o que git revert faz).

Para ser claro, estas alternativasnão é a melhor maneira de reverter os commits, As soluções do Jefromi são , mas eu só quero ressaltar que você também pode usar esses outros métodos para conseguir o mesmo que git revert.

Alternativa 1: redefinições rígidas e suaves

Esta é uma versão ligeiramente modificada da solução de Charles Bailey para Reverter para um commit por um hash SHA no Git? :

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft [email protected]{1}

# Commit the changes
git commit -m "Revert to <commit>"

Isso basicamente funciona usando o fato de que resets soft deixarão o estado do commit anterior testado na área de índice/staging, que você pode então confirmar.

Alternativa 2: Excluir a Árvore Atual e Substituir pela Nova

Esta solução vem da solução do svick para Checkout commit antigo e faz dele um novo commit :

git rm -r .
git checkout <commit> .
git commit

Similarmente à alternativa # 1, isso reproduz o estado de <commit> na cópia de trabalho atual. É necessário fazer git rm primeiro porque git checkout não irá remover os arquivos que foram adicionados desde <commit>.

56
user456814

Supondo que você esteja falando sobre o mestre e sobre o respectivo ramo (isso dito, pode ser qualquer ramo em que você esteja preocupado):

# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Reset remote master branch to November 3rd commit ID
git Push -f Origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

Eu encontrei a resposta em uma postagem no blog (agora não existe mais)

Note que isto é Resetar e Forçar a mudança para o controle remoto, de modo que se os outros membros de sua equipe já tiverem sido puxados, você causará problemas para eles. Você está destruindo o histórico de mudanças, que é uma razão importante pela qual as pessoas usam o git em primeiro lugar.

Melhor usar reverter (veja outras respostas) do que redefinir. Se você é um time de um homem, provavelmente não importa.

55
markreyes

Aqui está um muito mais simples maneira de voltar a um commit anterior (e tê-lo em um estado não comprometido, para fazer com o que você quiser):

git reset HEAD~1

Então, não há necessidade de cometer ids e assim por diante :)

51
Paul Walczewski

Depois de todas as alterações, quando você pressiona todos esses comandos, talvez seja necessário usar:

git Push -f ...

E não apenas git Push.

34
sivi

Existe um comando (não uma parte do Git principal, mas está no pacote git-extras ) especificamente para reverter e testar os commits antigos:

git back

Pela página man , ele também pode ser usado como tal:

# Remove the latest three commits
git back 3
33
Shadow Man

Você pode completar todos os passos iniciais e voltar ao git repo.

  1. Puxe a versão mais recente do seu repositório do Bitbucket usando o comando git pull --all.

  2. Execute o comando git log com -n 4 do seu terminal. O número após o -n determina o número de confirmações no log a partir do commit mais recente em seu histórico local.

    $ git log -n 4

  3. Redefina a cabeça do histórico do seu repositório usando o git reset --hard HEAD~N, onde N é o número de commits que você quer levar a cabeça para trás. No exemplo a seguir, o cabeçalho seria retrocedido em um commit, para o último commit no histórico do repositório:

  4. Empurre a mudança para o git repo usando git Push --force para forçar Pressione a mudança.

Se você quiser o repositório git para um commit anterior

git pull --all
git reset --hard HEAD~1
git Push --force
29
Nanhe Kumar

Reverter para mais recente commit e ignorar todas as alterações locais:

git reset --hard HEAD
27
Mohammed Irfan Tirupattur

Selecione seu commit requerido e verifique-o

git show HEAD
git show HEAD~1
git show HEAD~2 

até você obter o commit requerido. Para fazer o HEAD apontar para isso, faça

git reset --hard HEAD~1

ou git reset --hard HEAD~2 ou qualquer outra coisa.

26
tonythomas01

Esta é mais uma maneira de redefinir diretamente para um commit recente

git stash
git stash clear

Ele limpa diretamente todas as alterações que você fez desde o último commit.

PS: Tem um pequeno problema; Ele também exclui todas as alterações stash armazenadas recentemente. O que eu acho que na maioria dos casos não importa.

20
Point Networks

Para manter as alterações do commit anterior para HEAD e passar para o commit anterior, faça:

git reset <SHA>

Se as alterações não forem necessárias a partir do commit anterior para HEAD e apenas descartar todas as alterações, faça o seguinte:

git reset --hard <SHA>
20
Vishnu Atrai

Para limpar completamente o diretório de um codificador de algumas alterações acidentais, usamos:

git add -A .
git reset --hard HEAD

Apenas git reset --hard HEAD vai se livrar de modificações, mas não vai se livrar de "novos" arquivos. No caso deles, eles acidentalmente arrastaram uma pasta importante para algum lugar aleatório, e todos esses arquivos estavam sendo tratados como novos pelo Git, então um reset --hard não resolveu isso. Ao executar o git add -A . de antemão, ele rastreou explicitamente todos eles com o git, para ser apagado pelo reset.

20
Chris Moschini

Acredito que algumas pessoas possam vir a essa questão querendo saber como reverter as mudanças comprometidas que fizeram em seu mestre - isto é, jogar tudo fora e voltar para a Origem/mestre, e nesse caso, faça o seguinte:

git reset --hard Origin/master

https://superuser.com/questions/273172/how-to-reset-master-to-Origin-master

19
nevster

Reverter é o comando para reverter os commits.

git revert <commit1> <commit2> 

Amostra:

git revert 2h3h23233

É capaz de tirar alcance do HEAD como abaixo. Aqui 1 diz "reverter último commit".

git revert HEAD~1..HEAD

e então git Push

16
Sireesh Yarlagadda

Reverter a confirmação mais recente:

git reset --hard HEAD

HEAD é simplesmente uma referência à confirmação atual (mais recente) na ramificação atual. Só pode haver um único HEAD a qualquer momento.

Reverter para uma confirmação mais antiga: A maneira mais rápida de restaurar uma versão antiga é usar o comando reset:

# Resets index to former commit
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

# Updates working copy to reflect the new commit
git reset --hard

Isso rebobinará sua ramificação HEAD para a versão especificada. Todos os commits que vieram depois desta versão são efetivamente desfeitos; seu projeto é exatamente como era naquele momento.

O comando reset vem com algumas opções, uma das mais interessantes sendo a flag --soft. Se você usá-lo em vez de --hard, o Git manterá todas as alterações nos commits "desfeitas" como modificações locais.

Restaurando uma revisão em um Novo Ramificação Local

Como foi dito, usar o comando reset em sua ramificação HEAD é uma ação bastante drástica: ele removerá quaisquer commits (nesta ramificação) que vieram após a revisão especificada. Se você tem certeza de que é isso que você quer, está tudo bem.

No entanto, há também um método mais seguro caso você prefira deixar sua ramificação atual HEAD intocada. Como os "branches" são tão baratos e fáceis no Git, podemos facilmente criar um novo branch que começa naquela revisão antiga:

git checkout -b old-project-state 0ad5a7a6

Normalmente, o comando checkout é usado apenas para alternar as ramificações. No entanto, fornecendo o parâmetro -b, você também pode permitir que ele crie uma nova ramificação (denominada old-project-state neste exemplo). Se você não quer que ele comece na revisão atual HEAD, você também precisa fornecer um hash de commit - a revisão do projeto que queremos restaurar.

Agora você tem uma nova ramificação chamada old-project-state refletindo a versão antiga do seu projeto - sem tocar ou até mesmo remover quaisquer outros commits ou ramificações.

16
Lyes CHIOUKH

Se a situação é um um urgente, e você só quer fazer o que o questionador pediu em um rápido e sujocaminho, supondo que seu projeto está sob o diretório "meu projeto":

  1. Copie todo o diretório e chame de outra coisa, como "meu projeto - copiar"

  2. Faz:

    git reset --hard [first-4-letters&numbers-of-commit's-SHA]
    

Você então tem duas versões em seu sistema ... você pode examinar ou copiar ou modificar arquivos de interesse, ou o que for, do commit anterior. Você pode descartar completamente os arquivos em "meu projeto - copiar", se você decidiu que o novo trabalho estava indo a lugar nenhum ...

O mais óbvio é se você quiser continuar com o estado do projeto sem descartar o trabalho, já que esse commit recuperado é renomear seu diretório novamente: Apague o projeto que contém o commit recuperado (ou dê um nome temporário) e renomeie o seu " meu projeto - copie "diretório de volta para" meu projeto ". Então, provavelmente, faça outro commit em breve.

Git é uma criação brilhante, mas você não pode simplesmente "pegar em tempo real": também as pessoas que tentam explicá-la muitas vezesassumem conhecimento prévio de outros VCS [Sistemas de Controle de Versão] e se aprofundam muito profundamente muito cedo, e cometer outros crimes, como usar termos intercambiáveis ​​para "check-out" - de maneiras que às vezes parecem quase calculadas para confundir um iniciante.

Para poupar muito estresse você tem que praticamente ler um livro sobre o Git - eu recomendaria "Version Control with Git" . E se você pode confiar em mim (ou melhor, minhas cicatrizes) quando digo "tenho que", segue-se que você também pode fazê-lo NOW. Grande parte da complexidade do Git vem de ramificação e depois reminging.Mas a partir de sua pergunta há nenhuma razão pela qual as pessoas devem estar cegando você com ciência.

Especialmente se, por exemplo, esta é uma situação desesperada e você é um novato no Git!

PS: Um outro pensamento: é (agora) realmente muito simples manter o repositório Git ("repo") em um diretório diferente daquele com os arquivos de trabalho. Isso significaria que você não teria que copiar todo o repositório Git usando a solução rápida e suja acima. Veja a resposta por Fryer usando --separate-git-dir aqui . Seja avisado, no entanto: Se você tiver um repositório de "diretório separado" que não copia e fizer uma reinicialização a frio, todas as versões subseqüentes à confirmação de redefinição serão perdidas para sempre, a menos que você tenha, como você deveria, regularmente, fazer backup do seu repositório, de preferência para a nuvem (por exemplo Google Drive ) entre outros lugares.

13
mike rodent

Tente redefinir para o commit desejado

git reset <COMMIT_ID>

(para verificar COMMIT_ID use git log)

Isso redefinirá todos os arquivos alterados para o estado não adicionado.

Agora você pode checkout todos os arquivos não adicionados por

git checkout .

Verifique git log para confirmar suas alterações.

UPDATE

Se você tiver um e somente commit em seu repositório, tente

git update-ref -d HEAD

13
optimistanoop

Cuidado! Este comando pode causar perda de histórico de confirmação, se o usuário colocar o commit errado por engano. Tenha sempre um backup extra do seu git em algum outro lugar, apenas no caso de você cometer erros, do que você é um pouco mais seguro. :)

Eu tive problema semelhante e queria reverter para Commit anterior. No meu caso, eu não estava intencionado para manter o commit mais recente, por isso usei Hard.

Foi assim que eu fiz:

git reset --hard CommitId && git clean -f

Isso irá reverter no repositório local, aqui depois de usar git Push -f irá atualizar o repositório remoto.

git Push -f
11
maytham-ɯɐɥʇʎɐɯ

Como seus commits são enviados remotamente, você precisa removê-los. Deixe-me supor que sua ramificação está desenvolvida e é empurrada sobre a Origem.

Você primeiro precisa remover desenvolver da origem:

git Push Origin :develop (note the colon)

Então você precisa se desenvolver para o status que você quer, deixe-me assumir que o commit hash é EFGHIJK:

git reset --hard EFGHIJK

Por último, Push desenvolver novamente:

git Push Origin develop
11
George Ninan

No GitKraken você pode fazer isso:

  1. Clique com o botão direito do mouse na confirmação que você deseja redefinir, escolha: Redefinir para este commit/Hard:

enter image description here

  1. Clique com o botão direito no commit novamente, escolha: Nome atual da ramificação/Push:

enter image description here

  1. Clique no Force Push:

enter image description here

obs. : Você precisa ser cauteloso porque todo o histórico de commit após o hard reset é perdido e esta ação é irreversível. Você precisa ter certeza do que está fazendo.

10
Ângelo Polotto

Se você quiser corrigir algum erro no último commit, uma boa alternativa seria usar git commit --amend command. Se o último commit não for apontado por nenhuma referência, isso fará o truque, pois ele cria um commit com o mesmo pai do último commit. Se não houver referência ao último commit, ele será simplesmente descartado e este commit será o último commit. Esta é uma boa maneira de corrigir commits sem reverter commits. No entanto, tem suas próprias limitações.

10
Upul Doluweera

Primeiro, pegue a string que identifica o commit em alguma data, fazendo:

git rev-list -n 1 --before="2009-07-27 13:37" Origin/master

ele imprime o identificador de commit, pega a string (por exemplo XXXX) e faz:

git checkout XXXX
9
Luca C.

Para reversão (ou para reverter):

  1. git revert --no-commit "commit-código-para-remover" HEAD (por exemplo, git revert --no-commit d57a39dHead)
  2. git commit
  3. git Push

Tente acima de dois passos, e se você achar que é isso que você quer, então git Push.

Se você encontrar algo errado, faça:

git revert --abort

9
Jagraj Singh

Isso pode ser feito muito mais facilmente com SourceTree . Basta clicar com o botão direito do mouse para confirmar e escolher 'Checkout' no menu.

 enter image description here

8
Marcin Szymczak

Ainda outra solução mais simples; você tem que mudar o ramo para fazer isso, mas depois você pode simplesmente executar:

git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
8
Aif

Eu não poderia reverter o meu manualmente por algum motivo, então aqui está como eu acabei fazendo isso.

  1. Verifiquei o ramo que queria, copiei.
  2. Confira o último ramo.
  3. Copiei o conteúdo da ramificação que queria para o diretório da ramificação mais recente, sobrescrevendo as alterações e confirmando isso.
7
Demodave
git reflog

Escolha o número da (s) CABEÇA (s) do reflit git, onde você quer reverter e fazer (para este exemplo eu escolho 12):

git reset [email protected]{12} --hard
7
Sérgio

A maneira menos complicada de reverter uma ramificação para qualquer commit particular onde você não pode mudar o histórico que encontrei é:

  1. checkout o commit ou branch seu desejo de reverter.
  2. Edite .git/HEAD e mude o ref para o ramo para o qual você deseja reverter.

Tal como:

echo 'ref: refs/heads/example' > .git/HEAD

Se você fizer o status git, deverá ver todas as mudanças entre o ramo em que você está e o que você deseja reverter.

Se tudo parece bem, você pode se comprometer. Você também pode usar o git diff revert..example para garantir que seja o mesmo.

6
jgmjgm

Se você quiser reverter alterações temporariamente porque

  • alguém cometeu um código que quebra a construção ou quebra a funcionalidade na qual você está trabalhando

Você pode procurar o último commit de trabalho usando o git log então rodar

git rebase --onto <commitId>

Quando o ramo remoto está funcionando novamente, você pode

git pull --rebase

Este método é melhor que o git checkout para mudanças temporárias, porque você não está em um estado desconectado.

5
joseph

Redefinindo alterações e confirmações organizadas

O comando git reset permite que você altere o HEAD - o último commit de seus pontos da árvore de trabalho para o seu repositório. Ele modifica a área de preparação ou a área de preparação e a árvore de trabalho. A habilidade do Git de criar commits exatamente como você quer significa que às vezes você precisa desfazer mudanças nas mudanças que você fez com o git add. Você pode fazer isso chamando git reset HEAD <file to change>. Você tem duas opções para se livrar completamente das alterações. git checkout HEAD <file(s) or path(s)> é uma maneira rápida de desfazer alterações na área de preparação e na árvore de trabalho. Tenha cuidado com esse comando, no entanto, porque ele remove todas as alterações na sua árvore de trabalho. O Git não sabe sobre essas mudanças, uma vez que elas nunca foram confirmadas. Não há como recuperar essas alterações depois de executar este comando. Outro comando à sua disposição é git reset --hard. É igualmente destrutivo para a sua árvore de trabalho - quaisquer alterações não confirmadas ou alterações em etapas são perdidas após a execução. Executar git reset -hard HEAD faz o mesmo que git checkout HEAD. simplesmente não requer um arquivo ou caminho para o trabalho. Você pode usar --soft com git reset. Ele redefine o repositório para o commit especificado por você e realiza todas essas mudanças. Quaisquer alterações que você já tenha preparado não são afetadas, nem as alterações na sua árvore de trabalho. Finalmente, você pode usar o --mixed para redefinir a árvore de trabalho sem testar quaisquer alterações. Isso também desassocia as alterações que são testadas.

Revertendo Commits

Às vezes cometemos erros. Um commit que não deveria ser compartilhado é enviado para um repositório público, um commit tem um bug que não pode ser corrigido e precisa ser desfeito, ou talvez você simplesmente não precise mais desse código.Estes casos todos chame git revert O comando git revert faz exatamente o que você poderia esperar. Ele reverte uma única consolidação aplicando um commit reverso ao histórico. Às vezes, é necessário reverter várias confirmações para desfazer completamente uma alteração. Você pode usar -no-commit, ou você pode usar -n para dizer ao Git para realizar a reversão, mas pare de confirmar a mudança. Isso permite combinar todas as confirmações de reversão em uma confirmação, o que é útil se você precisar reverter um recurso que abrange várias confirmações. Certifique-se de reverter os commits em ordem reversa - o mais novo commit primeiro. Caso contrário, você pode confundir o Git tentando reverter o código que ainda não existe.

2
SAIguru011