Como reverter um repositório Git para um commit anterior

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

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:

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

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.

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:

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

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:

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

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.

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

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.

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

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.

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.

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.

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.

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.

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:

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

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

3. Clique no Force Push:

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

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

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.

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.

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 é:

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.

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.

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.