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
?
Isso depende muito do que você quer dizer com "reverter".
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á.)
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.
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)
Para reverter para um commit anterior, ignorando quaisquer alterações:
git reset --hard HEAD
onde HEAD é o último commit em sua ramificação atual
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?.
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.
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
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
.
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:
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
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.
git rebase --no-autostash
também.Este esquema ilustra qual comando faz o quê. Como você pode ver, reset && checkout
modifica o HEAD
.
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/
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:
git revert
.git checkout <commithashcode>
.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.
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.
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:
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.
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:
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.
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.
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
.
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.
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>
.
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.
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 :)
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
.
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
Você pode completar todos os passos iniciais e voltar ao git repo.
Puxe a versão mais recente do seu repositório do Bitbucket usando o comando git pull --all
.
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
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:
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
Reverter para mais recente commit e ignorar todas as alterações locais:
git reset --hard HEAD
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.
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.
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>
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.
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
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
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.
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.
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":
Copie todo o diretório e chame de outra coisa, como "meu projeto - copiar"
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.
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
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
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
No GitKraken você pode fazer isso:
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.
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.
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
Para reversão (ou para reverter):
- git revert --no-commit "commit-código-para-remover" HEAD (por exemplo, git revert --no-commit d57a39dHead)
- git commit
- 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
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.
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
Eu não poderia reverter o meu manualmente por algum motivo, então aqui está como eu acabei fazendo isso.
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
A maneira menos complicada de reverter uma ramificação para qualquer commit particular onde você não pode mudar o histórico que encontrei é:
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.
Se você quiser reverter alterações temporariamente porque
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.
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.