Comment vérifier si un dépôt Git contient un hash de commit spécifique

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un dépôt Git contient un hash de commit spécifique. Nous allons explorer la commande git rev-parse pour obtenir le hash complet à partir d'un hash court ou d'autres références Git, offrant ainsi un moyen non ambigu d'identifier les commits.

Ensuite, vous utiliserez la commande git show pour vérifier l'existence et afficher les détails d'un commit en utilisant son hash. Enfin, nous aborderons la manière de gérer les scénarios impliquant des hashs de commit invalides ou inexistants.

Skills Graph

Exécuter git rev-parse pour un commit

Dans cette étape, nous allons apprendre à utiliser la commande git rev-parse pour obtenir le hash complet d'un commit. Cela est utile lorsque vous avez besoin de l'identifiant exact pour un point spécifique dans l'historique de votre projet.

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, récupérons le hash court de notre dernier commit en utilisant git log --oneline. Cette commande affiche une vue condensée de l'historique de vos commits.

git log --oneline

Vous devriez voir une sortie similaire à celle-ci :

a1b2c3d (HEAD -> master) Envoyer un message au futur

La partie a1b2c3d est le hash court de votre commit. Bien que cela soit souvent suffisant pour un usage quotidien, il peut arriver que vous ayez besoin de l'identifiant complet et unique.

C'est là que git rev-parse entre en jeu. Nous pouvons l'utiliser pour obtenir le hash complet à partir du hash court. Remplacez a1b2c3d par le hash court que vous avez vu dans la sortie de votre commande git log --oneline :

git rev-parse a1b2c3d

Vous devriez voir le hash complet affiché dans le terminal, quelque chose comme ceci :

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t

La commande git rev-parse est une commande de bas niveau souvent utilisée dans les scripts. Elle peut analyser différents types de références Git (comme les noms de branches, les tags ou les hashs courts) et afficher l'ID de l'objet correspondant (le hash complet).

Comprendre comment obtenir le hash complet est important car cela fournit un moyen non ambigu de faire référence à un commit spécifique, indépendamment du déplacement des branches ou des tags.

Utiliser git show pour vérifier le hash

Dans l'étape précédente, nous avons appris à obtenir le hash complet d'un commit en utilisant git rev-parse. Maintenant, utilisons la commande git show pour afficher les détails de ce commit spécifique en utilisant son hash.

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

La commande git show est utilisée pour afficher des informations sur différents types d'objets Git, y compris les commits. Lorsque vous fournissez un hash de commit à git show, il affichera le message de commit, l'auteur, la date et les modifications introduites par ce commit.

Utilisons le hash complet que nous avons obtenu à l'étape précédente avec git show. Remplacez a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t par le véritable hash complet de votre commit :

git show a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t

Vous devriez voir une sortie similaire à celle-ci, montrant les détails de votre premier commit :

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Send a message to the future

diff --git a/message.txt b/message.txt
new file mode 100644
index 0000000..a1b2c3d
--- /dev/null
+++ b/message.txt
@@ -0,0 +1 @@
+Hello, Future Me

Cette sortie confirme que le hash que vous avez utilisé correspond au commit où nous avons ajouté le fichier message.txt avec le contenu "Hello, Future Me".

Utiliser git show avec un hash de commit est un moyen puissant d'inspecter l'historique de votre projet. Vous pouvez l'utiliser pour voir exactement quelles modifications ont été apportées dans n'importe quel commit donné, ce qui est inestimable pour le débogage ou pour comprendre comment un projet a évolué.

N'oubliez pas que vous pouvez utiliser soit le hash complet, soit un préfixe suffisamment long du hash (généralement 7 caractères suffisent, mais le hash complet est toujours garanti unique) avec git show.

Gérer les hashs invalides

Dans les étapes précédentes, nous avons utilisé avec succès un hash de commit valide avec git rev-parse et git show. Mais que se passe-t-il si vous fournissez un hash invalide ou inexistant ? Git est conçu pour vous fournir des informations lorsqu'il ne peut pas trouver l'objet que vous recherchez.

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

Essayons d'utiliser git show avec un hash qui n'existe pas. Nous allons simplement taper une chaîne aléatoire de caractères qui ressemble à un hash :

git show deadbeef

Vous devriez voir un message d'erreur similaire à celui-ci :

fatal: bad object deadbeef

Ce message vous indique que Git n'a pas pu trouver d'objet (dans ce cas, un commit) avec le hash deadbeef. C'est la façon dont Git vous fait savoir que la référence que vous avez fournie n'est pas valide dans ce dépôt.

De même, si vous essayez d'utiliser git rev-parse avec un hash invalide, vous obtiendrez une erreur :

git rev-parse invalidhash

La sortie sera similaire :

fatal: ambiguous argument 'invalidhash': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

Ce message d'erreur est un peu plus détaillé et suggère que Git n'a pas pu interpréter invalidhash comme une révision connue ou un chemin de fichier.

Comprendre ces messages d'erreur est important. Lorsque vous rencontrez une erreur "bad object" ou "unknown revision", cela signifie généralement que le hash de commit, le nom de branche ou le tag que vous essayez d'utiliser n'existe pas dans l'historique de votre dépôt actuel. Vérifiez à nouveau le hash ou la référence que vous utilisez pour vous assurer qu'il est correct.

Cette étape démontre que Git est strict quant aux références que vous fournissez. L'utilisation de hashs valides est cruciale pour naviguer et manipuler l'historique de votre projet de manière précise.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un dépôt Git contient un hash de commit spécifique. Nous avons commencé par utiliser la commande git rev-parse pour obtenir le hash complet d'un commit à partir de son hash court, en comprenant son rôle dans l'analyse des références Git et la fourniture d'identifiants d'objets non ambigus.

Ensuite, nous avons exploré la commande git show pour vérifier l'existence et afficher les détails d'un commit en utilisant son hash. Ce processus nous permet de confirmer qu'un commit spécifique est présent dans l'historique du dépôt.