Comment restaurer un repository Git à un commit précédent

Comment puis-je revenir de mon état actuel à un instantané réalisé sur un certain commit?

Si je me git log , j’obtiens la sortie suivante:

 $ git log commit a867b4af366350be2e7c21b8de9cc6504678a61b` Author: Me  Date: Thu Nov 4 18:59:41 2010 -0400 blah blah blah... commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4 Author: Me  Date: Thu Nov 4 05:13:39 2010 -0400 more blah blah blah... commit 0766c053c0ea2035e90f504928f8df3c9363b8bd Author: Me  Date: Thu Nov 4 00:55:06 2010 -0400 And yet more blah blah... commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50 Author: Me  Date: Wed Nov 3 23:56:08 2010 -0400 Yep, more blah blah. 

Comment revenir à la validation du 3 novembre, c’est-à-dire valider 0d1d7fc ?

Cela dépend beaucoup de ce que vous entendez par “revenir”.

Passer temporairement à un autre commit

Si vous voulez y retourner temporairement, tromper, puis revenir à l’endroit où vous vous trouvez, il suffit de vérifier le commit souhaité:

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

Ou si vous voulez faire des commits pendant que vous êtes là, allez-y et créez une nouvelle succursale pendant que vous y êtes:

 git checkout -b old-state 0d1d7fc32 

Pour revenir à l’endroit où vous étiez, il vous suffit de consulter la succursale sur laquelle vous vous trouviez. (Si vous avez apporté des modifications, comme toujours lorsque vous changez de succursale, vous devrez les traiter comme il convient. Vous pourriez les réinitialiser pour les jeter; vous pourriez les ranger, les retirer ou les emporter; vous pourriez les commettre. eux à une twig là-bas si vous voulez une succursale là-bas.)

Supprimez les commits non publiés

Si, par contre, vous voulez vraiment vous débarrasser de tout ce que vous avez fait depuis, il y a deux possibilités. Premièrement, si vous n’avez publié aucun de ces commits, réinitialisez simplement:

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

Si vous vous trompez, vous avez déjà rejeté vos modifications locales, mais vous pouvez au moins revenir à ce que vous étiez auparavant en le réinitialisant.

Annuler publié commits avec de nouveaux commits

D’un autre côté, si vous avez publié le travail, vous ne voudrez probablement pas réinitialiser la twig, car cela réécrit effectivement l’historique. Dans ce cas, vous pourriez en effet annuler les commits. Avec Git, revert a une signification très spécifique: créer un commit avec le patch inverse pour l’annuler. De cette façon, vous ne réécrivez aucune histoire.

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

La page de manuel git-revert couvre en fait beaucoup de choses dans sa description. Un autre lien utile est cette section git-scm.com traitant de git-revert .

Si vous décidez que vous ne voulez pas revenir après tout, vous pouvez annuler le retour (comme décrit ici) ou revenir avant le retour (voir la section précédente).

Vous pouvez également trouver cette réponse utile dans ce cas:
Comment déplacer HEAD vers un emplacement précédent? (Tête détachée)

Rétablissement de la copie de travail sur la validation la plus récente

Pour revenir à une validation précédente, en ignorant les modifications:

 git reset --hard HEAD 

où HEAD est le dernier commit dans votre twig actuelle

Rétablissement de la copie de travail en une version plus ancienne

Pour revenir à une validation antérieure à la validation la plus récente:

 # Resets index to former commit; replace '56e05fced' with your commit code git reset 56e05fced # Moves pointer back to previous HEAD git reset --soft HEAD@{1} git commit -m "Revert to 56e05fced" # Updates working copy to reflect the new commit git reset --hard 

Crédits vont à une question similaire Stack Overflow, Revenez à un commit par un hash SHA dans Git? .

Beaucoup de réponses compliquées et dangereuses ici, mais c’est en fait facile:

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

Cela ramènera tout de la HEAD au hash de validation, ce qui signifie qu’elle recréera cet état de validation dans l’arborescence de travail, comme si chaque validation avait été reculée depuis. Vous pouvez alors valider l’arborescence actuelle, et cela créera une nouvelle validation essentiellement équivalente à la validation à laquelle vous êtes “retourné”.

(L’indicateur --no-commit permet à git de rétablir tous les commits en même temps, sinon vous serez invité à envoyer un message pour chaque commit dans la plage, contenant des nouveaux validations inutiles dans votre historique.)

C’est un moyen simple et sûr de revenir à un état antérieur . Aucun historique n’est détruit, il peut donc être utilisé pour des commits qui ont déjà été rendus publics.

La meilleure option pour moi et probablement pour d’autres est l’option de réinitialisation Git:

 git reset --hard  && git clean -f 

Cela a été la meilleure option pour moi! C’est simple, rapide et efficace!


Remarque: comme mentionné dans les commentaires, ne le faites pas si vous partagez votre twig avec d’autres personnes qui ont des copies des anciens commits.

Aussi à partir des commentaires, si vous vouliez une méthode moins “ballzy”, vous pourriez utiliser

git clean -i

Avant de répondre, ajoutons quelques explications, expliquant ce qu’est cette HEAD .

First of all what is HEAD?

HEAD est simplement une référence au commit actuel (le plus récent) sur la twig en cours. Il ne peut y avoir qu’un seul HEAD à un moment donné (à l’exception de git worktree ).

Le contenu de HEAD est stocké dans .git/HEAD et contient les 40 octets SHA-1 de la validation en cours.


detached HEAD

Si vous n’êtes pas sur le dernier commit – ce qui signifie que HEAD pointe vers une validation antérieure dans l’historique, il est appelé detached HEAD .

Entrez la description de l'image ici

Sur la ligne de commande, cela ressemblera à ceci: SHA-1 au lieu du nom de la twig, car HEAD ne pointe pas vers le bout de la twig en cours:

Entrez la description de l'image ici


Quelques options sur la façon de récupérer d’un HEAD détaché:


git checkout

 git checkout  git checkout -b   git checkout HEAD~X // x is the number of commits t go back 

Cela va extraire la nouvelle twig pointant vers le commit souhaité. Cette commande va extraire un commit donné.

À ce stade, vous pouvez créer une twig et commencer à travailler à partir de là sur:

 # 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  # Create a new branch forked to the given commit git checkout -b  

git reflog

Vous pouvez toujours utiliser le reflog aussi. git reflog affichera tout changement qui a mis à jour le HEAD et extrait l’entrée de reflog désirée pour remettre le HEAD à ce commit.

Chaque fois que le HEAD est modifié, il y aura une nouvelle entrée dans le reflog

 git reflog git checkout HEAD@{...} 

Cela vous ramènera à votre engagement souhaité

Entrez la description de l'image ici


git reset HEAD --hard

“Déplacer” votre tête vers le commit désiré.

 # 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. 
  • Note: ( Depuis Git 2.7 ), vous pouvez également utiliser le git rebase --no-autostash .

Ce schéma illustre quelle commande fait quoi. Comme vous pouvez le voir, reset && checkout modifie le HEAD .

Entrez la description de l'image ici

Si vous souhaitez “annuler”, effacer le dernier message de validation et remettre les fichiers modifiés en mode intermédiaire, vous devez utiliser la commande:

 git reset --soft HEAD~1 
  • --soft indique que les fichiers non --soft doivent être conservés comme des fichiers de travail opposés à --hard qui les éliminerait.
  • HEAD~1 est le dernier commit. Si vous voulez annuler 3 validations, vous pouvez utiliser HEAD~3 . Si vous souhaitez revenir à un numéro de révision spécifique, vous pouvez également le faire en utilisant son hachage SHA.

Ceci est une commande extrêmement utile dans les situations où vous avez commis la mauvaise chose et que vous souhaitez annuler cette dernière validation.

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

J’ai essayé de nombreuses façons de rétablir les modifications locales dans Git, et il semble que cela fonctionne le mieux si vous souhaitez simplement revenir au dernier état de validation.

 git add . && git checkout master -f 

Brève description:

  • Il ne créera pas de commits comme le fait git revert .
  • Il ne détachera pas votre HEAD comme le fait git checkout .
  • Il annulera toutes vos modifications locales et SUPPRIMERA tous les fichiers ajoutés depuis la dernière validation dans la twig.
  • Cela fonctionne seulement avec des noms de twigs, ainsi vous pouvez revenir seulement au dernier commit dans la twig.

J’ai trouvé un moyen beaucoup plus pratique et simple d’atteindre les résultats ci-dessus:

 git add . && git reset --hard HEAD 

où HEAD pointe vers le dernier engagement de votre agence actuelle.

C’est le même code que boulder_ruby, mais j’ai ajouté git add . avant git reset --hard HEAD efface tous les nouveaux fichiers créés depuis le dernier commit car c’est ce que la plupart des gens attendent de moi pour revenir au dernier commit.

Vous pouvez le faire en utilisant les deux commandes suivantes:

 git reset --hard [previous Commit SHA id here] git push origin [branch Name] -f 

Il supprimera votre précédent commit Git.

Si vous souhaitez conserver vos modifications, vous pouvez également utiliser:

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

Ensuite, il enregistrera vos modifications.

Disons que vous avez les commits suivants dans un fichier texte nommé ~/commits-to-revert.txt (j’ai utilisé git log --pretty=oneline pour les obtenir)

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

Créez un script de shell Bash pour inverser chacun d’eux:

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

Cela ramène tout à l’état précédent, y compris les créations de fichiers et de répertoires, et les suppressions, les valide sur votre twig et conserve l’historique, mais vous revenez à la même structure de fichiers. Pourquoi Git n’a pas un git revert --to me dépasse.

Alternatives supplémentaires aux solutions de Jefromi

Les solutions de Jefromi sont sans aucun doute les meilleures, et vous devriez certainement les utiliser. Cependant, dans un souci d’exhaustivité, je voulais également montrer ces autres solutions alternatives qui peuvent également être utilisées pour annuler un commit (dans le sens où vous créez un nouveau commit qui annule les modifications dans un commit précédent , comme ce que fait git revert ) .

Pour être clair, ces alternatives ne sont pas le meilleur moyen de revenir en arrière, les solutions de Jefromi sont , mais je veux juste souligner que vous pouvez également utiliser ces autres méthodes pour réaliser la même chose que git revert .

Alternative 1: Réinitialisations dures et douces

Ceci est une version très légèrement modifiée de la solution de Charles Bailey pour Revenir à un commit par un hash SHA dans Git? :

 # Reset the index to the desired commit git reset --hard  # Move the branch pointer back to the previous HEAD git reset --soft HEAD@{1} # Commit the changes git commit -m "Revert to " 

Cela fonctionne en utilisant le fait que les réinitialisations logicielles laisseront l’état de la validation précédente dans la zone d’indexation / staging, que vous pourrez ensuite valider.

Alternative 2: Supprimer l’arborescence actuelle et la remplacer par la nouvelle

Cette solution provient de la solution svick de Checkout old commit et en fait un nouveau commit :

 git rm -r . git checkout  . git commit 

De même que pour l’alternative n ° 1, cela reproduit l’état de dans la copie de travail en cours. Il est nécessaire de commencer par git rm car git checkout ne supprimera pas les fichiers ajoutés depuis .

Voici un moyen beaucoup plus simple de revenir à un commit précédent (et de l’avoir dans un état non validé, à faire avec ce que vous voulez):

 git reset HEAD~1 

Donc, pas besoin d’id de validation et ainsi de suite 🙂

En supposant que vous parlez de master et de cette twig respective (cela peut être n’importe quelle twig de travail concernée):

 # Revert local master branch to November 3rd commit ID git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50 # Revert remote master branch to November 3rd commit ID git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master 

J’ai trouvé la réponse dans un article de blog.

OK, revenir au commit précédent en git est assez facile …

Revenez en arrière sans conserver les modifications:

 git reset --hard  

Revenez en arrière en gardant les modifications:

 git reset --soft  

Expliquez: en utilisant git reset, vous pouvez réinitialiser à un état spécifique, il est courant de l’utiliser avec un hachage de validation comme vous le voyez ci-dessus.

Mais comme vous voyez, la différence est d’utiliser les deux drapeaux --soft et --hard , par défaut, git reset utilisant --soft flag, mais c’est toujours une bonne pratique d’utiliser le drapeau, j’explique chaque drapeau:


–doux

L’indicateur par défaut, comme expliqué, n’a pas besoin de le fournir, ne modifie pas l’arborescence de travail, mais ajoute tous les fichiers de modifications prêts à être validés. Vous revenez donc au statut de validation dont les modifications apscopes aux fichiers ne sont pas mises en œuvre.


–difficile

Soyez prudent avec cet indicateur, il réinitialise l’arbre de travail et toutes les modifications apscopes aux fichiers suivis et tout sera parti!


J’ai aussi créé l’image ci-dessous qui peut arriver dans une vraie vie en travaillant avec git:

git réinitialisé à un commit

Rien ici n’a fonctionné pour moi à part cette combinaison exacte:

 git reset --hard  git push origin  --force 

La clé ici force le push, aucun commit supplémentaire / message de validation, etc.

Après toutes les modifications, lorsque vous appuyez sur toutes ces commandes, vous devrez peut-être utiliser:

 git push -f ... 

Et pas seulement git push .

Il y a une commande (qui ne fait pas partie du kernel Git, mais elle se trouve dans le paquetage git-extras ) spécifiquement pour le retour et le transfert de vieux commits:

 git back 

Par la page de manuel , il peut également être utilisé comme tel:

 # Remove the latest three commits git back 3 

Sélectionnez votre commit requirejs et vérifiez-le par

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

jusqu’à ce que vous obtenez l’engagement requirejs. Pour faire la tête à cela, faites

 git reset --hard HEAD~1 

ou git reset --hard HEAD~2 ou peu importe.

Revenir à la validation la plus récente et ignorer toutes les modifications locales:

 git reset --hard HEAD 

Je crois que certaines personnes peuvent en venir à cette question en voulant savoir comment annuler les modifications qu’elles ont commises dans leur maître – c’est-à-dire tout jeter et revenir à l’origine / maître, auquel cas faites ceci:

 git reset --hard origin/master 

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

Pour conserver les modifications de la validation précédente dans HEAD et passer à la validation précédente, procédez comme suit:

 git reset  

Si des modifications ne sont pas requirejses lors de la validation précédente dans HEAD et que vous souhaitez simplement supprimer toutes les modifications, procédez comme suit:

 git reset --hard  

Pour nettoyer complètement le répertoire d’un codeur de certains changements accidentels, nous avons utilisé:

 git add -A . git reset --hard HEAD 

Just git reset --hard HEAD va se débarrasser des modifications, mais il ne va pas se débarrasser des “nouveaux” fichiers. Dans leur cas, ils avaient accidentellement traîné un dossier important quelque part au hasard, et tous ces fichiers étaient traités comme nouveaux par Git, donc une reset --hard ne l’a pas reset --hard . En exécutant le git add -A . au préalable, ils les ont tous explicitement suivis avec git, pour être effacés par la réinitialisation.

Ceci est une autre façon de réinitialiser directement à une validation récente

 git stash git stash clear 

Il efface directement toutes les modifications que vous avez apscopes depuis le dernier commit.

PS: il y a un petit problème; Il supprime également tous les changements de stock stockés récemment. Ce que je suppose dans la plupart des cas ne devrait pas avoir d’importance.

Vous pouvez effectuer toutes ces étapes initiales vous-même et repasser en mode repo.

  1. Tirez la dernière version de votre référentiel de Bitbucket à l’aide de la commande git pull --all .

  2. Exécutez la commande git log avec -n 4 depuis votre terminal. Le nombre après le -n détermine le nombre de validations dans le journal à partir de la validation la plus récente de votre historique local.

    $ git log -n 4

  3. Réinitialisez la tête de l’historique de votre repository à l’aide de la commande git reset --hard HEAD~N où N est le nombre de validations que vous souhaitez récupérer. Dans l’exemple suivant, la tête serait rétablie à une validation, à la dernière validation de l’historique du référentiel:

  4. Poussez le changement sur go repo en utilisant git push --force pour forcer le changement.

Si vous souhaitez que git repository à un commit précédent

 git pull --all git reset --hard HEAD~1 git push --force 

Revert est la commande pour annuler les validations.

 git revert   

Échantillon:

git revert 2h3h23233

Il est capable de prendre la distance de la tête comme ci-dessous. Ici 1 dit “annuler le dernier commit”.

git revert HEAD~1..HEAD

et ensuite faire git push

Si la situation est urgente et que vous voulez simplement faire ce que le questionneur a demandé de manière rapide et sale , en supposant que votre projet est sous le répertoire “mon projet”:

  1. Copiez tout le répertoire et appelez-le comme “mon projet – copie”

  2. Faire:

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

Vous disposez alors de deux versions sur votre système … vous pouvez examiner ou copier ou modifier des fichiers intéressants, ou autres, lors de la validation précédente. Vous pouvez complètement supprimer les fichiers sous “mon projet – copie”, si vous avez décidé que le nouveau travail n’allait nulle part …

The obvious thing if you want to carry on with the state of the project without actually discarding the work since this resortingeved commit is to rename your directory again: Delete the project containing the resortingeved commit (or give it a temporary name) and rename your “my project – copy” directory back to “my project”. Then probably do another commit fairly soon.

Git is a brilliant creation but you can’t just “pick it up on the fly”: also people who try to explain it far too often assume prior knowledge of other VCS [Version Control Systems] and delve far too deep far too soon, and commit other crimes, like using interchangeable terms for “checking out” – in ways which sometimes appear almost calculated to confuse a beginner.

To save yourself much stress you have to pretty much have to read a book on Git – I’d recommend “Version Control with Git” . And if you can trust me (or rather my scars) when I say “have to”, it follows that you might as well do it NOW . Much of the complexity of Git comes from branching and then remerging. But from your question there’s no reason why people should be blinding you with science .

Especially if, for example, this is a desperate situation and you’re a newbie with Git!

PS: One other thought: It is (now) actually quite simple to keep the Git repository (“repo”) in a directory other than the one with the working files. This would mean you would not have to copy the entire Git repository using the above quick & dirty solution. See the answer by Fryer using –separate-git-dir here . Be warned , though: If you have a “separate-directory” repository which you don’t copy, and you do a hard reset, all versions subsequent to the reset commit will be lost forever, unless you have, as you absolutely should, regularly backed up your repository, preferably to the cloud (eg Google Drive ) among other places.

As your commits are pushed remotely, you need to remove them. Let me assume your branch is develop and it is pushed over origin.

You first need to remove develop from origin:

 git push origin :develop (note the colon) 

Then you need to get develop to the status you want, let me assume the commit hash is EFGHIJK:

 git reset --hard EFGHIJK 

Lastly, push develop again:

 git push origin develop 

Try resetting to the desired commit –

git reset

(to check COMMIT_ID use git log )

This will reset all changed files to un-added state.

Now you can checkout all un-added files by

git checkout .

Check git log to verify your changes.

METTRE À JOUR

If you have one and only commit in your repo, try

git update-ref -d HEAD

If you want to correct some error in the last commit a good alternative would be using git commit –amend command. If the last commit is not pointed by any reference, this will do the sortingck, as it create a commit with the same parent as the last commit. If there is no reference to the last commit, it will simply be discarded and this commit will be the last commit. This is a good way of correcting commits without reverting commits. However it has its own limitations.

Yet another simplest solution; you have to change branch to do this, but afterwards you can just run:

 git branch -f < > 0d1d7fc32e5a947fbd92ee598033d85bfc445a50 

For rollback (or to revert):

  1. git revert –no-commit “commit-code-to-remove” HEAD (eg git revert –no-commit d57a39d HEAD)
  2. git commit
  3. git push

Try above two steps, and if you find this is what you want then git push.

If you find something wrong do:

git revert –abort