Comment annuler les derniers commits locaux dans Git?

J'ai accidentellement validé les mauvais fichiers dans Git , mais je n'ai pas encore poussé la validation sur le serveur.

Comment annuler ces validations à partir du référentiel local?

Annuler un commit et refaire

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)

1. C'est ce que vous voulez annuler.
2. Cela ne fait rien à votre arborescence de travail (l'état de vos fichiers sur le disque), mais annule la validation et laisse les modifications que vous avez validées non mises en scène (elles apparaîtront donc comme "Modifications non mises en scène pour la validation" dans git status, vous devrez donc ajoutez-les à nouveau avant de valider). Si vous souhaitez uniquement ajouter d' autres modifications à la validation précédente ou modifier le message de validation ¹ , vous pouvez utiliser à la git reset --soft HEAD~place, ce qui est comme git reset HEAD~² mais laisse vos modifications existantes par étapes.
3. Apportez des corrections aux fichiers d'arborescence de travail.
4. git add tout ce que vous souhaitez inclure dans votre nouveau commit.
5. Validez les modifications en réutilisant l'ancien message de validation. resetcopié la vieille tête .git/ORIG_HEAD; commitavec -c ORIG_HEADouvrira un éditeur, qui contient initialement le message du journal de l'ancien commit et vous permet de le modifier. Si vous n'avez pas besoin de modifier le message, vous pouvez utiliser l' -Coption.

Attention, cependant, si vous avez ajouté de nouvelles modifications à l'index, l'utilisation commit --amendles ajoutera à votre commit précédent.

Si le code est déjà envoyé à votre serveur et que vous avez les autorisations pour écraser l'historique (rebase), alors:

git push origin master --force

Vous pouvez également consulter cette réponse:

Comment puis-je déplacer HEAD vers un emplacement précédent? (Tête détachée) & Annuler les validations

La réponse ci-dessus vous montrera ce git reflog,qui est utilisé pour savoir quel est le SHA-1, que vous souhaitez annuler. Une fois que vous avez trouvé le point auquel vous souhaitez annuler l'utilisation de la séquence de commandes comme expliqué ci-dessus.

¹ Notez, cependant, que vous n'avez pas besoin de rétablir une validation antérieure si vous venez de faire une erreur dans votre message de validation . L'option la plus simple consiste à git reset(pour annuler toute modification que vous avez apportée depuis), puis à git commit --amendouvrir votre éditeur de message de validation par défaut prérempli avec le dernier message de validation.

² HEAD~ est le même que HEAD~1. Voir aussi Qu'est - ce que la tête dans git? . Il est utile si vous souhaitez annuler plusieurs validations.

Annuler une validation est un peu effrayant si vous ne savez pas comment cela fonctionne. Mais c'est en fait incroyablement facile si vous comprenez.

Supposons que vous ayez ceci, où C est votre HEAD et (F) est l'état de vos fichiers.

   (F)
A-B-C
    ↑
  master

Vous voulez nuke commit C et ne plus jamais le voir et perdre toutes les modifications dans les fichiers modifiés localement . Tu fais cela:

git reset --hard HEAD~1

Le résultat est:

 (F)
A-B
  ↑
master

Maintenant, B est la TÊTE. Parce que vous l'avez utilisé --hard, vos fichiers sont réinitialisés à leur état lors de la validation B.

Ah, mais supposons que le commit C n'était pas un désastre, mais juste un peu décalé. Vous souhaitez annuler la validation mais conserver vos modifications pour un peu de modification avant de faire une meilleure validation. À partir d'ici, avec C comme TÊTE:

   (F)
A-B-C
    ↑
  master

Vous pouvez le faire en laissant de côté --hard:

git reset HEAD~1

Dans ce cas, le résultat est:

   (F)
A-B-C
  ↑
master

Dans les deux cas, HEAD n'est qu'un pointeur vers le dernier commit. Lorsque vous effectuez un git reset HEAD~1, vous dites à Git de reculer le pointeur HEAD d'un commit. Mais (sauf si vous l'utilisez --hard), vous laissez vos fichiers tels qu'ils étaient. Affiche maintenant git statusles modifications que vous avez enregistrées dans C. Vous n'avez rien perdu!

Pour le toucher le plus léger, vous pouvez même annuler votre commit mais laisser vos fichiers et votre index :

git reset --soft HEAD~1

Cela laisse non seulement vos fichiers seuls, mais laisse également votre index seul. Lorsque vous le ferez git status, vous verrez que les mêmes fichiers sont dans l'index que précédemment. En fait, juste après cette commande, vous pourriez le faire git commitet vous referiez le même commit que vous venez d'avoir.

Encore une chose: supposons que vous détruisiez un commit comme dans le premier exemple, mais que vous découvriez ensuite que vous en aviez besoin après tout ? Pas de chance, non?

Non, il y a encore un moyen de le récupérer. Tapez git refloget vous verrez une liste de shas de validation (partiels) (c'est-à-dire des hachages) dans lesquels vous vous êtes déplacé. Trouvez le commit que vous avez détruit, et procédez comme suit :

git checkout -b someNewBranchName shaYouDestroyed

Vous avez maintenant ressuscité ce commit. Les commits ne sont pas réellement détruits dans Git pendant environ 90 jours, vous pouvez donc généralement revenir en arrière et en sauver un dont vous ne vouliez pas vous débarrasser.

Il existe deux façons d'annuler votre dernier commit, selon que vous avez déjà rendu votre commit public (poussé vers votre référentiel distant):

Comment annuler un commit local

Disons que je me suis engagé localement, mais maintenant je veux supprimer ce commit.

git log
    commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
    commit 100: good commit   # Second to last commit. This is the one we want.

Pour restaurer tout ce qu'il était avant le dernier commit, nous devons resetle faire avant HEAD:

git reset --soft HEAD^     # Use --soft if you want to keep your changes
git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made

Maintenant git log, montrera que notre dernier commit a été supprimé.

Comment annuler un commit public

Si vous avez déjà rendu vos commits publics, vous souhaiterez créer un nouveau commit qui "reviendra" sur les modifications que vous avez apportées dans votre commit précédent (HEAD actuel).

git revert HEAD

Vos modifications seront désormais annulées et prêtes à être validées:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Pour plus d'informations, consultez Git Basics - Undoing Things .

Ajoutez / supprimez des fichiers pour obtenir les choses comme vous le souhaitez:

git rm classdir
git add sourcedir

Modifiez ensuite le commit:

git commit --amend

Le commit erroné précédent sera modifié pour refléter le nouvel état d'index - en d'autres termes, ce sera comme si vous n'aviez jamais fait l'erreur en premier lieu.

Notez que vous ne devez le faire que si vous n'avez pas encore poussé. Si vous avez poussé, vous n'aurez qu'à valider un correctif normalement.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

ou

git reset --hard HEAD~1

Avertissement: La commande ci-dessus supprimera définitivement les modifications des .javafichiers (et de tout autre fichier) que vous vouliez valider.

Le hard resetto HEAD-1mettra votre copie de travail à l'état de la validation avant votre mauvaise validation.

Pour modifier le dernier commit

Remplacez les fichiers dans l'index:

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

Ensuite, s'il s'agit d'une branche privée, modifiez le commit:

git commit --amend

Ou, si c'est une branche partagée, faites un nouveau commit:

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

( Pour modifier une validation précédente , utilisez la redéfinition interactive impressionnante .)

ProTip ™: Ajoutez *.classà un gitignore pour arrêter que cela se reproduise.

Pour annuler un commit

La modification d'un commit est la solution idéale si vous devez modifier le dernier commit, mais une solution plus générale l'est reset.

Vous pouvez réinitialiser Git à n'importe quel commit avec:

git reset @~N

Où Nest le nombre de validations avant HEADet @~revient à la validation précédente.

Ainsi, au lieu de modifier le commit, vous pouvez utiliser:

git reset @~
git add *.java
git commit -m "Add .java files"

Consultez git help reset, en particulier les sections sur --soft --mixedet --hard, pour une meilleure compréhension de ce que cela fait.

Reflog

Si vous vous trompez, vous pouvez toujours utiliser le reflog pour trouver les commits supprimés:

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Utilisez git revert <commit-id>.

Pour obtenir l'ID de validation, utilisez simplement git log.

Si vous prévoyez d'annuler entièrement une validation locale, quelle que soit la modification que vous avez apportée à la validation, et si vous ne vous inquiétez de rien à ce sujet, exécutez simplement la commande suivante.

git reset --hard HEAD^1

(Cette commande ignorera l'intégralité de votre commit et vos modifications seront complètement perdues de votre arborescence de travail locale). Si vous souhaitez annuler votre validation, mais que vous souhaitez apporter vos modifications dans la zone de transfert (avant la validation comme après git add), exécutez la commande suivante.

git reset --soft HEAD^1

Vos fichiers validés arrivent maintenant dans la zone de transfert. Supposons que si vous souhaitez mettre à niveau les fichiers, car vous devez modifier un contenu incorrect, exécutez la commande suivante

git reset HEAD

Maintenant, les fichiers validés doivent provenir de la zone intermédiaire dans la zone non intermédiaire. Les fichiers sont maintenant prêts à être modifiés, donc quoi que vous changiez, vous voulez aller le modifier et l'ajouter et faire un nouveau / nouveau commit.

Plus

Si Git Extras est installé, vous pouvez exécuter git undopour annuler la dernière validation. git undo 3annulera les trois derniers commits.

Je voulais annuler les cinq derniers commits dans notre référentiel partagé. J'ai recherché l'ID de révision vers lequel je voulais revenir. Ensuite, j'ai tapé ce qui suit.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Je préfère utiliser git rebase -ipour ce travail, car une belle liste apparaît où je peux choisir les commits à supprimer. Ce n'est peut-être pas aussi direct que d'autres réponses ici, mais cela semble juste .

Choisissez le nombre de validations que vous souhaitez lister, puis invoquez comme ceci (pour enrôler les trois derniers)

git rebase -i HEAD~3

Exemple de liste

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Ensuite, Git supprimera les validations pour toute ligne que vous supprimez.

Comment corriger le commit local précédent

Utilisez git-gui (ou similaire) pour effectuer a git commit --amend. Depuis l'interface graphique, vous pouvez ajouter ou supprimer des fichiers individuels de la validation. Vous pouvez également modifier le message de validation.

Comment annuler le commit local précédent

Réinitialisez simplement votre succursale à l'emplacement précédent (par exemple, en utilisant gitkou git rebase). Réappliquez ensuite vos modifications à partir d'une copie enregistrée. Après le garbage collection dans votre référentiel local, ce sera comme si la validation indésirable ne s'était jamais produite. Pour faire tout cela en une seule commande, utilisez git reset HEAD~1.

Avertissement : l' utilisation imprudente de git resetest un bon moyen de mettre votre copie de travail dans un état déroutant. Je recommande aux novices Git d'éviter cela s'ils le peuvent.

Comment annuler un commit public

Effectuez une sélection inversée ( git-revert ) pour annuler les modifications.

Si vous n'avez pas encore apporté d'autres modifications à votre branche, vous pouvez simplement le faire ...

git revert --no-edit HEAD

Poussez ensuite votre branche mise à jour vers le référentiel partagé.

L'historique des validations affichera les deux validations séparément .

Avancé: correction de la branche privée dans le référentiel public

Cela peut être dangereux - assurez-vous d'avoir une copie locale de la branche à repousser.

Notez également: vous ne voulez pas faire cela si quelqu'un d'autre travaille sur la branche.

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

Nettoyez votre succursale localement puis repoussez ...

git push origin (branch_name)

Dans le cas normal, vous n'avez probablement pas à vous soucier de l'historique de validation de votre branche privée. Poussez simplement un commit de suivi (voir 'Comment annuler un commit public' ci-dessus), et plus tard, faites un squash-merge pour masquer l'historique.

Si vous souhaitez l'annuler définitivement et que vous avez cloné un référentiel

L'ID de validation peut être vu par

git log 

Ensuite, vous pouvez faire -

git reset --hard <commit_id>

git push origin <branch_name> -f

Si vous avez commis des pourriels mais pas poussé,

git reset --soft HEAD~1

HEAD ~ 1 est un raccourci pour la validation avant la tête. Alternativement, vous pouvez vous référer au SHA-1 du hachage si vous souhaitez réinitialiser. L' option --soft supprimera le commit mais laissera tous vos fichiers modifiés "Les changements à valider", comme le dirait git status.

Si vous souhaitez vous débarrasser des modifications apportées aux fichiers suivis dans l'arborescence de travail depuis la validation avant la tête, utilisez plutôt " --hard ".

OU

Si vous avez déjà poussé et que quelqu'un a tiré, ce qui est généralement mon cas, vous ne pouvez pas utiliser git reset . Vous pouvez cependant faire un git revert ,

git revert HEAD

Cela va créer un nouveau commit qui inverse tout ce qui a été introduit par le commit accidentel.

Sur SourceTree (GUI pour GitHub), vous pouvez cliquer avec le bouton droit sur le commit et faire un «Reverse Commit». Cela devrait annuler vos modifications.

Sur le terminal:

Vous pouvez également utiliser:

git revert

Ou:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Une seule commande:

git reset --soft 'HEAD^' 

Cela fonctionne très bien pour annuler le dernier commit local!

Réinitialisez-le simplement en faisant la commande ci-dessous en utilisant git:

git reset --soft HEAD~1

Expliquez: qu'est git reset- ce que c'est, c'est essentiellement resetà n'importe quel commit que vous souhaitez revenir, puis si vous le combinez avec la --softclé, il reviendra, mais gardez les modifications dans vos fichiers, donc vous revenez à l'étape auquel le fichier vient d'être ajouté, HEADest le chef de la branche et si vous combinez avec ~1(dans ce cas, vous utilisez également HEAD^), il ne retournera qu'un seul commit ce que vous voulez ...

Je crée les étapes dans l'image ci-dessous plus en détail pour vous, y compris toutes les étapes qui peuvent se produire dans des situations réelles et en validant le code:

Comment annuler le dernier commit Git?

Pour restaurer tout ce qu'il était avant le dernier commit, nous devons réinitialiser le commit avant HEAD.

1. Si vous ne souhaitez pas conserver les modifications que vous avez apportées:

   git reset --hard HEAD^
   

2. Si vous souhaitez conserver vos modifications:

   git reset --soft HEAD^
   

Maintenant, vérifiez votre journal git. Cela montrera que notre dernier commit a été supprimé.

"Réinitialiser l'arborescence de travail au dernier commit"

git reset --hard HEAD^ 

"Nettoyer les fichiers inconnus de l'arborescence de travail"

git clean    

voir - Git Quick Reference

REMARQUE: cette commande supprimera votre commit précédent, utilisez-la donc avec prudence! git reset --hardest plus sûr.

Utilisez reflog pour trouver un état correct

git reflog

REFLOG AVANT RÉINITIALISATION

Sélectionnez le reflog correct (f3cb6e2 dans mon cas) et tapez

git reset --hard f3cb6e2

Après cela, le repo HEAD sera réinitialisé à ce HEADid LOG AFTER RESET

Enfin le reflog ressemble à l'image ci-dessous

REFLOG FINAL

Première exécution:

git reflog

Il vous montrera toutes les actions possibles que vous avez effectuées sur votre référentiel, par exemple, valider, fusionner, extraire, etc.

Alors fais:

git reset --hard ActionIdFromRefLog

Annuler le dernier commit:

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

Cela annulera le dernier commit.

Ici --softsignifie réinitialiser la mise en scène.

HEAD~ou HEAD^signifie se déplacer pour s'engager avant HEAD.

Remplacer le dernier commit par un nouveau commit:

git commit --amend -m "message"

Il remplacera le dernier commit par le nouveau commit.

Autrement:

Extrayez la branche que vous souhaitez rétablir, puis réinitialisez votre copie de travail locale sur le commit que vous souhaitez être la dernière sur le serveur distant (tout ce qui se passera ensuite au revoir). Pour ce faire, dans SourceTree, j'ai fait un clic droit sur le et sélectionné "Réinitialiser BRANCHNAME à ce commit".

Ensuite, accédez au répertoire local de votre référentiel et exécutez cette commande:

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

Cela effacera toutes les validations après celle en cours dans votre référentiel local, mais uniquement pour cette branche.

Tapez git loget recherchez le dernier code de hachage de validation, puis entrez:

git reset <the previous co>

Dans mon cas, j'ai accidentellement commis des fichiers que je ne voulais pas. J'ai donc fait ce qui suit et cela a fonctionné:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Vérifiez les résultats avec gitk ou git log --stat

Simple, exécutez ceci dans votre ligne de commande:

git reset --soft HEAD~ 

Il y a plusieurs façons de procéder:

Commande Git pour annuler la dernière validation / les validations précédentes:

Avertissement: n'utilisez pas --hard si vous ne savez pas ce que vous faites. --hard est trop dangereux , et il pourrait supprimer vos fichiers.

La commande de base pour annuler le commit dans Git est:

$ git reset --hard <COMMIT -ID>

ou

$ git reset --hard HEAD~<n>

COMMIT-ID : ID du commit

n: est le nombre de dernières validations que vous souhaitez annuler

Vous pouvez obtenir l'ID de validation comme indiqué ci-dessous:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

où d81d3f1 et be20eb8 sont l'ID de validation.

Voyons maintenant quelques cas:

Supposons que vous souhaitiez annuler le dernier commit 'd81d3f1'. Voici deux options:

$ git reset --hard d81d3f1

ou

$ git reset --hard HEAD~1

Supposons que vous souhaitiez annuler la validation 'be20eb8':

$ git reset --hard be20eb8

Pour des informations plus détaillées, vous pouvez également consulter et essayer d'autres commandes pour réinitialiser la tête à un état spécifié:

$ git reset --help

Pour un commit local

git reset --soft HEAD~1

ou si vous ne vous souvenez pas exactement dans quel commit il se trouve, vous pouvez utiliser

git rm --cached <file>

Pour un commit poussé

La bonne façon de supprimer des fichiers de l'historique du référentiel est d'utiliser git filter-branch. C'est,

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

Mais je vous recommande d'utiliser cette commande avec soin. Pour en savoir plus, consultez la page de manuel git-filter-branch (1) .

Il existe deux scénarios principaux

Vous n'avez pas encore poussé le commit

Si le problème était des fichiers supplémentaires que vous avez validés (et que vous ne voulez pas qu'ils soient dans le référentiel), vous pouvez les supprimer en utilisant git rmpuis en validant avec--amend

git rm <pathToFile>

Vous pouvez également supprimer des répertoires entiers avec -r, ou même combiner avec d'autres commandes Bash

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Après avoir supprimé les fichiers, vous pouvez valider, avec l' option --amend

git commit --amend -C HEAD # the -C option is to use the same commit message

Cela réécrira votre commit local récent en supprimant les fichiers supplémentaires, donc, ces fichiers ne seront jamais envoyés en push et seront également supprimés de votre dépôt local .git par GC.

Vous avez déjà poussé le commit

Vous pouvez appliquer la même solution de l'autre scénario et ensuite faire git pushavec l' -foption, mais ce n'est pas recommandé car il écrase l'historique distant avec une modification divergente (cela peut gâcher votre référentiel).

Au lieu de cela, vous devez effectuer la validation sans --amend(rappelez-vous ceci à propos de -amend`: cette option réécrit l'historique sur la dernière validation).

Pour rétablir la révision précédente, supprimer définitivement toutes les modifications non validées:

git reset --hard HEAD~1