Comment vérifier si un commit Git a été modifié (amend)

Introduction

Dans ce laboratoire, vous apprendrez à déterminer si un commit Git a été modifié (amended). Nous allons explorer la commande git reflog pour afficher l'historique des mises à jour des références, qui peut révéler les opérations de modification (amend).

Vous apprendrez également à utiliser git log pour comparer les commits et comprendre les différences entre les commits modifiés (amended) et les commits non modifiés, acquérant ainsi des compétences pratiques pour examiner l'historique de votre dépôt.

Skills Graph

Vérifier le git reflog pour les entrées de modification (amend)

Dans cette étape, nous allons explorer la commande git reflog et comment elle nous aide à voir l'historique de notre dépôt, y compris des actions telles que la modification (amend) de commits.

Tout d'abord, assurons-nous que nous sommes dans le répertoire de notre projet. Ouvrez votre terminal et accédez au répertoire my-time-machine :

cd ~/project/my-time-machine

Maintenant, utilisons la commande git reflog pour voir l'historique de notre dépôt. Le reflog (journal des références) enregistre les mises à jour des extrémités des branches et d'autres références dans le dépôt. Cela est différent de git log, qui montre l'historique des commits.

Tapez la commande suivante :

git reflog

Vous devriez voir une sortie similaire à celle-ci :

a1b2c3d (HEAD -> master) HEAD@{0}: commit: Send a message to the future
a1b2c3d (HEAD -> master) HEAD@{1}: initial commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Décortiquons cette sortie :

• Chaque ligne représente une action qui a mis à jour une référence (comme HEAD).
• HEAD@{0} est la plus récente action, HEAD@{1} est l'action précédente, et ainsi de suite.
• La première partie de chaque ligne (a1b2c3d, e4f5g6h) est le hachage du commit. Remarquez comment le hachage du commit change après une opération de "modification" (amend).
• Le texte après le hachage du commit décrit l'action, comme commit, initial commit (amend) ou commit (initial).

Le git reflog est un outil puissant pour récupérer des commits perdus ou comprendre la séquence d'opérations qui a conduit à l'état actuel de votre dépôt. Il vous montre où votre HEAD a été, même si ces commits ne font plus partie de l'historique d'une branche (par exemple, après une modification (amend) ou un rebase).

Dans la sortie d'exemple, vous pouvez voir une entrée comme initial commit (amend). Cela indique que le commit initial a été modifié (amend). La modification (amend) d'un commit remplace le dernier commit par un nouveau commit qui inclut les modifications que vous avez préparées (staged). Alors que git log ne montrera que le commit final, modifié (amend), git reflog montre à la fois le commit initial original et le commit modifié.

Comprendre le git reflog est crucial pour naviguer dans l'historique de votre projet, en particulier lorsque vous utilisez des commandes qui réécrivent l'historique, comme git commit --amend.

Utiliser git log pour comparer les commits

Dans cette étape, nous allons utiliser la commande git log pour afficher l'historique des commits et comprendre en quoi elle diffère de git reflog, notamment après avoir utilisé git commit --amend.

Assurez-vous que vous êtes toujours dans le répertoire ~/project/my-time-machine.

Maintenant, affichons l'historique des commits en utilisant git log :

git log --oneline

L'option --oneline fournit une vue concise de l'historique des commits, affichant chaque commit sur une seule ligne.

Vous devriez voir une sortie similaire à celle-ci :

a1b2c3d (HEAD -> master) Send a message to the future

Comparez cette sortie à celle de git reflog de l'étape précédente. Remarquez que git log n'affiche qu'un seul commit, qui est le commit final, modifié (amend). Il n'affiche pas le commit initial original qui a été remplacé par l'opération de modification (amend).

Voici une différence clé entre git log et git reflog. git log affiche l'historique des commits accessibles depuis l'extrémité de la branche actuelle, tandis que git reflog affiche l'historique des emplacements où HEAD et d'autres références ont pointé.

Imaginez git log comme l'historique officiel publié de votre projet, tandis que git reflog est votre journal personnel de tout ce que vous avez fait dans le dépôt.

Vous pouvez également utiliser git log pour comparer différents commits. Bien que nous n'ayons pour l'instant qu'un seul commit dans notre historique, dans un projet réel avec plusieurs commits, vous pourriez utiliser des commandes telles que git log commit1..commit2 pour voir les commits entre deux points spécifiques de l'historique, ou git diff commit1 commit2 pour voir les modifications exactes introduites entre deux commits.

Pour l'instant, il est important de comprendre que git log affiche l'historique des commits et que git reflog affiche l'historique des mises à jour des références.

Tester les commits non modifiés (non-amended)

Dans cette étape, nous allons créer un nouveau commit sans utiliser le flag --amend et observer comment il apparaît dans git log et git reflog. Cela vous aidera à mieux comprendre comment ces commandes suivent l'historique différemment.

Tout d'abord, ajoutons plus de contenu à notre fichier message.txt. Nous allons ajouter une nouvelle ligne :

echo "Hello again, Future Me!" >> message.txt

L'opérateur >> ajoute le texte au fichier existant, au lieu de le remplacer.

Maintenant, vérifions l'état pour voir les modifications :

git status

Vous devriez voir une sortie indiquant que message.txt a été modifié :

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit (use "git add" and/or "git commit -a")

Ensuite, nous devons préparer (stager) les modifications :

git add message.txt

Et maintenant, créons un nouveau commit sans modifier le précédent :

git commit -m "Add another message"

Vous devriez voir une sortie confirmant le nouveau commit :

[master 1a2b3c4] Add another message
 1 file changed, 1 insertion(+)

Maintenant, vérifions à nouveau le git log :

git log --oneline

Cette fois, vous devriez voir deux commits :

1a2b3c4 (HEAD -> master) Add another message
a1b2c3d Send a message to the future

Les deux commits sont visibles dans le git log car le deuxième commit a été ajouté au-dessus du premier, prolongeant l'historique de la branche.

Enfin, vérifions le git reflog :

git reflog

Vous devriez voir une sortie similaire à celle-ci :

1a2b3c4 (HEAD -> master) HEAD@{0}: commit: Add another message
1a2b3c4 (HEAD -> master) HEAD@{1}: commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Remarquez que git reflog montre toutes les actions : le commit initial, le commit initial modifié (amend) et le nouveau commit que nous venons de créer. Chaque action qui a déplacé HEAD est enregistrée.

Cette étape démontre que lorsque vous créez un nouveau commit sans --amend, git log et git reflog afficheront le nouveau commit, mais git reflog conservera toujours l'historique du commit modifié (amend), que git log n'affiche pas.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un commit Git a été modifié (amend). Nous avons exploré la commande git reflog, qui fournit un historique des mises à jour des références telles que HEAD, nous permettant de voir des actions telles que la modification de commits. En examinant la sortie du reflog, nous pouvons identifier les entrées indiquant une opération de modification (amend) et observer comment le hachage (hash) du commit change après une telle action.

Nous avons également appris que git reflog est un outil précieux pour comprendre la séquence des opérations dans un dépôt, même pour les commits qui ne sont plus directement accessibles via git log. Cela aide à récupérer des travaux perdus ou à diagnostiquer des problèmes liés à l'historique du dépôt.