Comment supprimer un commit Git ?

Vous avez fait un commit, tout semble parfait, mais soudain, vous réalisez que votre dernier commit contient une erreur. Peut-être que vous avez accidentellement inclus un fichier, oublié une modification cruciale ou introduit un bug majeur dans le code. Que faire désormais ? 🤔

Supprimer le commit que nous venons de faire, évidemment ! Mais encore faut-il savoir s'y prendre. 😉

Rassurez-vous, Git est conçu pour gérer ce type de situation.

C'est tout l'intérêt d'un gestionnaire de versions : vous permettre de revenir en arrière et de corriger les erreurs sans affecter tout votre historique de projet. Mais, face à plusieurs commandes possibles, comme reset et revert, choisir la bonne méthode peut sembler compliqué.

Dans cet article, nous allons voir ensemble les différentes manières de supprimer ou annuler un commit dans Git. Vous apprendrez non seulement comment revenir au commit précédent, mais aussi comment restaurer l'historique vers n'importe quel commit antérieur, que ce soit sur votre dépôt local ou après avoir poussé vos changements en ligne.

Prêt ? On est parti ! 😗

Mais c'est quoi déjà, un commit avec Git ?

Un commit dans Git représente un point de sauvegarde (on parle aussi d'un instantané) à un moment donné avec des fichiers précis.

Chaque commit possède un identifiant unique en SHA-1.

C'est cet identifiant qui va grandement nous aider pour revenir en arrière dans git !

Avant de continuer, il est important de faire la différence entre deux types d'historique :

1. Les historiques locaux : qui sont uniquement sur votre ordinateur en local ;
2. Les historiques partagés : qui sont déjà publiés en ligne sur un référentiel (GitHub par exemple).

La méthode pour revenir en arrière dépendra de si vous avez déjà publié votre commit en ligne ou pas.

Supprimer un commit local avant de l'avoir poussé (push)

Si vous n'avez pas encore poussé vos modifications sur le dépôt distant, supprimer ou annuler un commit est relativement simple et sans danger. Vous pouvez utiliser la commande git reset pour ce faire.

Revenir en arrière avec git reset

La commande git reset permet de ramener l'état de votre référentiel à une version antérieure. Elle a plusieurs options qui modifient la façon dont Git gère les fichiers et les commits. Il ne faut donc pas se tromper ! 🥸

Pour supprimer le dernier commit, vous pouvez utiliser la commande suivante :

git reset --soft HEAD~1

Cette commande permet de reculer d'un commit tout en conservant les modifications effectuées entre-deux : vous pouvez donc ensuite modifier ou re-commiter les nouvelles modifications réalisées.

Supprimer le dernier commit avec git reset --hard

Si vous voulez supprimer complètement le dernier commit et toutes ses modifications, vous pouvez utiliser l’option --hard :

git reset --hard HEAD~1

Cette commande va supprimer le dernier commit et toutes les modifications qui avaient été effectuées dans ce commit.

Cette commande est irréversible.

Supprimer un commit après l'avoir poussé (push)

Si vous avez déjà poussé votre commit sur un dépôt distant, supprimer ou annuler un commit devient plus délicat, surtout si d'autres personnes travaillent sur la même branche que vous. 😕

Imaginons un peu Pablo qui travaille sur une branche qui a déjà intégré votre modification : il ne va pas être content si vous lui dites que tout son travail va déguerpir. Mais bon, c'est comme ça.

Heureusement, certaines options permettent de limiter la casse.

Utiliser git reset et forcer la mise à jour

Heureusement, la plupart du temps, vous êtes seul à travailler sur votre branche.

Si c'est bien votre cas, vous pouvez utiliser la commande git reset comme dans le cas précédent, puis forcer la mise à jour sur le dépôt distant avec git push --force.

Voici comme faire :

Étape 1 : Revenir en arrière avec git reset

git reset --hard HEAD~1

Étape 2 : Pousser la modification en forçant la mise à jour

git push --force

Attention : utiliser git push --force peut détruire complètement votre historique sur le dépôt distant, ce qui peut provoquer de gros problèmes pour les autres développeurs qui travaillent avec vous. Utilisez cette commande uniquement si vous êtes sûr que cela n'impactera personne.

Utiliser git revert pour annuler un commit

Si vous ne souhaitez pas modifier l’historique partagé et que vous préférez revenir en arrière proprement tout en conservant les commits, vous pouvez utiliser la commande git revert.

Contrairement à reset, revert crée un nouveau commit qui annule les modifications du commit précédent.

Pour annuler le dernier commit

git revert HEAD

Pour annuler un commit spécifique avec l'identifiant SHA-1 du commit

git revert <commit-sha>

Cette méthode est plus sûre lorsqu’il s’agit d’un dépôt partagé, car elle ne modifie pas l’historique existant, mais crée plutôt un nouveau commit d’annulation.

Manipuler plusieurs commits avec git rebase

Parfois, on fait une erreur non pas sur un seul commit... mais sur plusieurs ! 🙄

Heureusement, il existe également une commande pour supprimer plusieurs commits en une seule fois : git rebase.

Cette commande vous permettra de réécrire votre historique en modifiant, supprimant ou fusionnant les commits que vous préciserez.

Voici comment utiliser git rebase pour supprimer plusieurs commits :

1. Commencer par spécifier le nombre de commits à modifier :
   
   CONSOLE

   git rebase -i HEAD~3

   Ici, nous modifions les trois derniers commits dans notre exemple.
2. Une liste de commits récents devrait normalement s'afficher. Vous avez maintenant la possibilité de précisier si vous souhaitez remplacer (avec le mot pick) ou supprimer un commit (avec le mot drop) à côté du commit concerné.
3. Il ne vous reste plus qu'une seule chose à effectuer une fois les modifications réalisées : enregistrer et quitter l'éditeur ! Git ajustera ensuite l'historique en fonction des changements.

Attention la commande git rebase est très puissante mais peut être risquée si mal utilisée. Utilisez-la avec précaution, surtout lorsque vous travaillez sur un dépôt partagé.

Quelques conseils pour éviter les problèmes à l'avenir

Maintenant que nous avons vu comment supprimer un commit, laissez-nous vous donner quelques conseils pour éviter les problèmes à l'avenir... 😬

Pour commencer, travaillez tout le temps sur des branches.

Elles sont faites pour cela ! 

Ensuite, utilisez git revert dans un premier temps. Elle est beaucoup plus intéressante car elle ne casse pas le code des personnes avec qui vous travaillez également sur la branche, contrairement aux commandes git reset et git push --force.

Enfin, faites des sauvegardes très souvent afin d'éviter de devoir revenir sur un commit qui a enregistré des centaines de modifications : ce sera bien plus simple d'y trouver votre bug et de le rectifier.

Conclusion

Supprimer un commit dans Git est une tâche courante mais qui doit être exécutée avec soin, surtout lorsque vous travaillez avec d'autres développeurs.

Vous pouvez choisir entre git reset pour revenir en arrière dans l'historique local, git revert pour annuler proprement un commit, ou git rebase pour réécrire l’historique de manière plus complexe.

Quelle que soit la méthode choisie, il est essentiel de bien comprendre les conséquences et d’utiliser ces commandes de manière appropriée pour éviter des conflits dans l'historique Git.

Si vous voulez aller plus loin avec Git, allez voir notre formation complète sur Git et GitHub. Vous allez adorer !