Comment vérifier si un commit Git est le plus récent

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si un commit Git spécifique est le dernier commit de votre dépôt. Nous allons explorer comment utiliser la commande git log -1 pour afficher le dernier commit pointé par HEAD, puis utiliser git rev-parse HEAD pour récupérer l'identifiant unique de ce commit. Enfin, vous testerez ces commandes avec des commits plus anciens pour consolider votre compréhension de la façon dont HEAD représente la position actuelle dans l'historique de votre projet.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560066{{"Comment vérifier si un commit Git est le plus récent"}} git/status -.-> lab-560066{{"Comment vérifier si un commit Git est le plus récent"}} git/commit -.-> lab-560066{{"Comment vérifier si un commit Git est le plus récent"}} git/log -.-> lab-560066{{"Comment vérifier si un commit Git est le plus récent"}} end

Exécuter git log -1 pour vérifier HEAD

Dans cette étape, nous allons apprendre à vérifier rapidement le dernier commit dans notre dépôt Git en utilisant la commande git log -1. C'est un moyen pratique de voir l'état actuel de l'historique de votre projet sans afficher tout le journal.

Tout d'abord, assurez-vous que vous êtes dans le répertoire my-time-machine. Si ce n'est pas le cas, utilisez la commande cd pour y accéder :

cd ~/project/my-time-machine

Maintenant, exécutons la commande pour voir le dernier commit :

git log -1

Vous devriez voir une sortie similaire à celle-ci :

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master)
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Send a message to the future

La commande git log -1 vous montre les détails du dernier commit effectué dans la branche actuelle. L'option -1 indique à Git de n'afficher que le dernier commit.

Remarquez la partie (HEAD -> master). HEAD est un pointeur qui pointe toujours vers le dernier commit dans la branche actuelle. Dans ce cas, il pointe vers le dernier commit de la branche master. Imaginez HEAD comme votre position actuelle dans la chronologie du projet. Lorsque vous effectuez un nouveau commit, HEAD se déplace automatiquement pour pointer vers ce nouveau commit.

Comprendre HEAD est crucial car de nombreuses commandes Git opèrent sur le commit vers lequel HEAD pointe. Dans les étapes suivantes, nous explorerons comment HEAD est lié aux identifiants de commit spécifiques.

Comparer un commit avec git rev-parse HEAD

Dans l'étape précédente, nous avons vu que git log -1 affiche le commit vers lequel HEAD pointe. Maintenant, utilisons la commande git rev-parse HEAD pour obtenir simplement l'identifiant unique (le hachage SHA-1) du commit vers lequel HEAD pointe actuellement.

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

Exécutez la commande suivante :

git rev-parse HEAD

Vous devriez voir une longue chaîne de lettres et de chiffres, qui est le hachage SHA-1 complet de votre dernier commit :

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9

Comparez cette sortie avec le hachage du commit que vous avez vu dans la sortie de git log -1 de l'étape précédente. Ils devraient être identiques !

La commande git rev-parse est une commande Git de bas niveau souvent utilisée pour traduire différents types de références Git (comme les noms de branches, les étiquettes ou HEAD) en leurs hachages SHA-1 correspondants. C'est un outil puissant pour la création de scripts et l'automatisation dans Git.

En utilisant git rev-parse HEAD, vous demandez essentiellement à Git : "Quel est l'identifiant exact du commit que ma position actuelle (HEAD) représente ?" Cela vous donne l'identifiant brut du instantané avec lequel vous travaillez actuellement.

Comprendre comment obtenir le hachage brut d'un commit est important car ces hachages sont le moyen fondamental par lequel Git suit les versions spécifiques de votre projet. Vous pouvez utiliser ces hachages pour faire référence à n'importe quel point dans l'historique de votre projet.

Tester avec des commits plus anciens

Dans les étapes précédentes, nous avons appris ce qu'est HEAD et comment obtenir le hachage de son commit. Maintenant, voyons comment Git fait référence aux commits plus anciens.

Actuellement, nous n'avons qu'un seul commit dans notre dépôt. Pour démontrer comment faire référence à des commits plus anciens, nous devons effectuer un autre commit.

Tout d'abord, ajoutons une autre ligne à notre fichier message.txt. Utilisez la commande echo avec >> pour ajouter du texte au fichier :

echo "This is a second message." >> message.txt

Maintenant, vérifions l'état :

git status

Vous devriez voir 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)

Maintenant, préparez les modifications et créez un nouveau commit :

git add message.txt
git commit -m "Add a second message"

Vous devriez voir une sortie indiquant qu'un nouveau commit a été créé :

[master a1b2c3d] Add a second message
 1 file changed, 1 insertion(+)

Maintenant, nous avons deux commits. Affichons le journal à nouveau :

git log --oneline

L'option --oneline donne une vue concise du journal. Vous devriez voir quelque chose comme ceci (les hachages seront différents) :

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

Le commit du haut est le plus récent, et c'est là que HEAD pointe. Le commit en dessous est le plus ancien.

Git propose des moyens de faire référence aux commits par rapport à HEAD. Le commit directement avant HEAD peut être référencé comme HEAD~1 ou HEAD^. Essayons d'obtenir le hachage du commit précédent en utilisant git rev-parse :

git rev-parse HEAD~1

Vous devriez voir le hachage du premier commit que vous avez effectué :

e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v1w2x3

Ce hachage devrait correspondre au hachage du commit "Send a message to the future" dans la sortie de git log --oneline.

Vous pouvez utiliser HEAD~2, HEAD~3, etc., pour faire référence à des commits plus anciens dans l'historique. Cette référence relative est très utile pour naviguer dans l'historique de votre projet et effectuer des opérations sur des versions passées spécifiques.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un commit Git est le plus récent en comprenant le rôle de HEAD. Nous avons utilisé la commande git log -1 pour afficher les détails du dernier commit, constatant que HEAD pointe vers ce commit. Ensuite, nous avons utilisé git rev-parse HEAD pour récupérer le hachage SHA-1 unique du commit vers lequel HEAD pointe actuellement, qui représente le dernier commit de la branche actuelle.