Git Revert - Comment utiliser Git Revert

Cette page explique ce que fait git revert, les options qu'il accepte, un exemple complet, les différences avec git reset, comment annuler un commit de fusion, et comment résoudre les conflits qu'un revert peut provoquer.

Description

La commande git revert est une opération d'annulation qui va vers l'avant. Contrairement aux commandes telles que git reset, elle ne réécrit pas l'historique. Au lieu de supprimer ou de déplacer des commits, elle calcule l'inverse des modifications introduites par un commit cible et enregistre cet inverse sous la forme d'un nouveau commit au sommet de la branche actuelle.

Comme rien n'est supprimé de l'historique, git revert est la méthode sûre pour annuler un travail que vous avez déjà poussé vers un dépôt partagé : toute personne disposant du commit original le conserve, et le revert ajoute simplement un commit de suivi qui l'annule. Cela préserve l'historique complet des révisions, ce qui est important pour la traçabilité et la collaboration.

Quelques points à garder à l'esprit :

Un revert nécessite une référence de commit pour savoir quoi annuler. L'exécution de git revert sans argument échoue.
Un revert laisse le répertoire de travail dans l'état dans lequel il se trouverait si ce commit n'avait jamais existé (par rapport aux commits environnants) — pas nécessairement un diff vide, car des commits ultérieurs peuvent toujours toucher les mêmes lignes.
Annuler un revert réapplique le changement original, puisque l'inverse de l'inverse est l'original.

Quand utiliser git revert

Utilisez git revert lorsque :

Le commit que vous souhaitez annuler est déjà publié (poussé, ouvert dans une pull request, ou récupéré par des coéquipiers).
Vous souhaitez annuler un seul commit spécifique quelque part au milieu de l'historique sans toucher aux commits qui lui font suite.
Vous avez besoin d'une trace auditée indiquant qu'un changement a été délibérément annulé.

Préférez git reset lorsque le commit est local et non publié et que vous souhaitez simplement le supprimer, ou git commit --amend lorsque vous devez uniquement corriger le commit le plus récent (non poussé).

Options

`-e` `--edit`	Ouvre l'éditeur système configuré et vous invite à modifier le message de commit avant de valider le revert. Option par défaut.
`--no-edit`	Empêche le revert d'ouvrir l'éditeur (l'opposé de l'option `-e`).
`-n` `--no-commit`	Ajoute les modifications inverses à l'Index de staging et au Répertoire de travail au lieu de créer un nouveau commit.
`-m <parent-number>`	Pour annuler des commits de fusion, spécifie le commit parent vers lequel revenir.

Exemples

# Stage the reverted changes without committing them (useful for review)
git revert -n HEAD

# Revert a merge commit against its first parent
git revert -m 1 <merge-commit-hash>

Fonctionnement

Comme git checkout et git reset, git revert prend également un commit spécifié mais ne déplace pas les pointeurs de référence vers ce commit. L'opération de revert prend le commit spécifié, inverse les modifications de ce commit et crée un nouveau commit de revert.

Voici un exemple de création d'un dépôt :

Commande git revert

mkdir git_revert_example
cd git_revert_example/
git init .
#Initialized empty Git repository in /git_revert_example/.git/
touch w3docs_file
git add w3docs_file
git commit -m "original commit"
#[master (root-commit) 299b15f] original commit
#1 file changed, 0 insertions(+), 0 deletions(-)
#create mode 100644 w3docs_file
echo "original content" >> w3docs_file
git commit -m "add new content to w3docs_file"
#[master 3602d88] add new content to w3docs_file
#1 file changed, 1 insertion(+)
echo "prepended line content" >> w3docs_file
git commit -m "prepend content to w3docs file"
#[master 86bb32e] prepend content to w3docs file
#1 file changed, 1 insertion(+)
git log --oneline
#86bb32e prepend content to w3docs file
#3602d88 add new content to w3docs file
#299b15f original commit

Dans cet exemple, un dépôt est initialisé dans un répertoire nouvellement créé nommé git_revert_example. Il y a 3 commits dans le dépôt dans lesquels un fichier nommé w3docs_file est ajouté. Son contenu a été modifié deux fois. Nous utilisons git log à la fin de la configuration du dépôt pour afficher les 3 commits dans l'historique. Nous pouvons maintenant invoquer git revert :

git revert

git revert HEAD
#[master b9cd081] Revert "prepend content to w3docs file"
#1 file changed, 1 deletion(-)

git revert ne fonctionnera pas sans passer une référence de commit. Dans l'exemple ci-dessus, nous avons passé la référence HEAD pour annuler le dernier commit. Un revert crée un nouveau commit et ouvre l'éditeur système configuré pour vous permettre de modifier son message (passez --no-edit pour accepter le message par défaut). Nous pouvons utiliser git log et voir le nouveau commit ajouté au sommet de l'historique précédent :

git log --oneline

git log --oneline
#b9cd081 Revert "prepend content to w3docs file"
#86bb32e prepend content to w3docs file
#3602d88 add new content to w3docs_file
#299b15f original commit

Après le revert, le commit "prepend" (86bb32e) est toujours dans l'historique du projet. git revert a ajouté un nouveau commit (b9cd081) qui annule ses modifications plutôt que de le supprimer. C'est la différence clé avec git reset.

Annuler sans créer de commit

Passez -n (--no-commit) lorsque vous souhaitez annuler plusieurs commits en un seul revert combiné, ou inspecter les modifications inverses avant de les enregistrer. Git met en stage les modifications inverses mais s'arrête avant de créer un commit, vous laissant le contrôle :

# Stage the inverse of the last two commits, then commit once
git revert -n HEAD~1 HEAD
git status        # review the staged changes
git commit -m "Roll back the last two changes"

Lorsque vous listez plusieurs commits (ou une plage), Git applique un revert pour chacun. Sans -n, il créerait un commit par revert ; avec -n, ils sont combinés en un seul commit que vous créez vous-même.

Annuler un commit de fusion

Un commit de fusion a deux parents, donc Git ne peut pas déterminer seul de quel côté vous souhaitez conserver. Vous devez indiquer quel parent représente la « ligne principale » vers laquelle revenir en utilisant -m <parent-number>. Les numéros de parent commencent à 1 :

# Undo a merge, keeping the first parent (usually the branch you merged into)
git revert -m 1 <merge-commit-hash>

Dans un scénario typique « fusionner une branche de fonctionnalité dans main », le parent 1 est main et le parent 2 est la branche de fonctionnalité, donc -m 1 supprime les modifications de la branche de fonctionnalité.

Avertissement

Annuler une fusion enregistre que les commits fusionnés ont été annulés. Si vous essayez ensuite de fusionner à nouveau cette branche, Git considérera ces commits comme déjà fusionnés et les ignorera. Pour réintroduire le travail, vous devez généralement d'abord annuler le revert. Préférez annuler des commits individuels plutôt qu'un commit de fusion lorsque c'est possible.

Résoudre un conflit de revert

Si des commits ultérieurs ont modifié les mêmes lignes que le revert tente d'annuler, Git s'arrête avec un conflit — exactement comme un conflit de fusion. Modifiez les fichiers marqués, mettez-les en stage, puis terminez le revert en cours :

git revert HEAD~2
# CONFLICT (content): Merge conflict in w3docs_file
# error: could not revert 4f2a1c0... change w3docs_file
# resolve the conflict markers in the file, then:
git add w3docs_file
git revert --continue   # records the revert commit

# Or, to back out of the whole operation:
git revert --abort

Reset vs. revert

La commande git revert annule un commit en ajoutant un nouveau commit, tandis que git reset réécrit l'historique en déplaçant le pointeur de branche en arrière et en supprimant les commits qui le suivent.

Le revert est le choix sûr pour les commits qui ont déjà été publiés dans un dépôt partagé, et il vous permet de cibler un commit spécifique n'importe où dans l'historique. Évitez git revert sur des commits privés et non publiés là où git reset est plus simple et plus propre.

Commandes associées

git reset — déplace le pointeur de branche et supprime les commits ultérieurs (annulation par réécriture de l'historique).
git commit --amend — corrige le commit non poussé le plus récent.
git checkout — supprime les modifications non validées dans le répertoire de travail.
git cherry-pick — l'opération inverse : applique les modifications d'un commit sur la branche actuelle.

Pratique

Quelles sont les caractéristiques et les options de la commande 'git revert' ?

La commande `git revert` annule les modifications introduites par un commit spécifique et crée un nouveau commit avec le contenu inversé.`git revert` supprime le commit de l'historique du projet.L'option `-e` ou `--edit` avec `git revert` ouvre l'éditeur système pour modifier le message de commit du revert.`git revert` ne peut annuler qu'un seul commit à la fois et n'accepte jamais plus d'un commit.L'option `--no-commit` ajoute les modifications inverses à l'Index de staging et au Répertoire de travail sans créer de nouveau commit.`git revert` est une opération sûre pour les commits publiés dans un dépôt partagé.Utiliser `git revert` sans spécifier de référence de commit ne fonctionnera pas.