Comment vérifier si un message de commit Git contient un texte spécifique

Introduction

Dans ce laboratoire, vous apprendrez à rechercher efficacement dans l'historique des commits Git pour un texte spécifique dans les messages de commit. Nous allons explorer la commande git log --grep pour filtrer les commits en fonction de mots-clés, vous permettant de localiser rapidement les modifications pertinentes dans un grand projet.

Vous apprendrez également à utiliser git show pour examiner les détails d'un commit spécifique trouvé grâce à votre recherche, et à effectuer des recherches sensibles à la casse avec git log --grep pour affiner vos résultats. À la fin de ce laboratoire, vous maîtriserez l'utilisation de ces commandes Git pour naviguer dans et comprendre l'historique de votre projet.

Skills Graph

Utiliser git log --grep pour rechercher

Dans cette étape, nous allons apprendre à rechercher dans l'historique de nos commits en utilisant git log --grep. Cela est incroyablement utile lorsque vous avez de nombreux commits et que vous devez trouver un commit spécifique en fonction de son message.

Tout d'abord, faisons quelques commits supplémentaires afin d'avoir des éléments à rechercher. Nous allons ajouter quelques messages supplémentaires à notre fichier message.txt.

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

Vous devriez voir une sortie similaire à celle-ci :

[master <commit-id>] Add second message
 1 file changed, 1 insertion(+)

Maintenant, ajoutons un autre message et validons-le :

echo "Adding a third message about the future." >> message.txt
git add message.txt
git commit -m "Add third message about future"

Vous devriez voir une sortie similaire à celle-ci :

[master <commit-id>] Add third message about future
 1 file changed, 1 insertion(+)

Maintenant, nous avons trois commits dans notre historique. Utilisons git log pour les afficher tous :

git log --oneline

Vous devriez voir quelque chose comme cela (les identifiants de commit seront différents) :

<commit-id> Add third message about future
<commit-id> Add second message
<commit-id> Send a message to the future

Maintenant, disons que nous voulons trouver le commit qui mentionne "future". Nous pouvons utiliser git log --grep pour cela :

git log --grep "future" --oneline

Cette commande demande à Git de nous montrer uniquement les commits dont les messages contiennent le mot "future". Vous devriez voir une sortie similaire à celle-ci :

<commit-id> Add third message about future
<commit-id> Send a message to the future

Notez que seuls les commits dont le message contient "future" sont affichés. C'est un moyen puissant de filtrer votre historique de commits et de trouver rapidement ce que vous recherchez.

L'option --grep vous permet de rechercher dans les messages de commit un motif spécifique. Cela est très utile lorsque vous avez un grand projet avec de nombreux commits et que vous devez trouver un commit lié à une fonctionnalité spécifique ou à la correction d'un bogue.

Exécuter git show pour un commit spécifique

Dans cette étape, nous allons apprendre à afficher les détails d'un commit spécifique en utilisant la commande git show. Cette commande vous permet de voir exactement quelles modifications ont été introduites dans un commit particulier.

Tout d'abord, récupérons l'identifiant du premier commit que nous avons effectué. Nous pouvons de nouveau utiliser git log --oneline pour voir la liste des commits :

git log --oneline

Regardez la sortie et trouvez le message de commit "Send a message to the future". Copiez l'identifiant court du commit (la chaîne de lettres et de chiffres avant le message). Cela devrait ressembler à a1b2c3d.

Maintenant, utilisez la commande git show suivie de l'identifiant de commit que vous avez copié. Remplacez <commit-id> par l'identifiant réel que vous avez copié :

git show <commit-id>

Vous devriez voir des informations détaillées sur ce commit spécifique, notamment :

• L'identifiant du commit, l'auteur, la date et le message.
• Les modifications apportées dans ce commit. Pour notre premier commit, il montrera que le fichier message.txt a été créé et que la ligne "Hello, Future Me" a été ajoutée.

La sortie ressemblera à ceci (l'identifiant du commit et la date seront différents) :

commit <commit-id>
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..e69de29
--- /dev/null
+++ b/message.txt
@@ -0,0 +1 @@
+Hello, Future Me

La commande git show est incroyablement utile pour comprendre l'historique de votre projet. Vous pouvez l'utiliser pour voir exactement quelles modifications ont été apportées dans n'importe quel commit, ce qui est essentiel pour le débogage ou pour comprendre comment une fonctionnalité a été implémentée.

Vous pouvez également utiliser git show sans identifiant de commit pour voir les détails du dernier commit. Essayez-le :

git show

Cela vous montrera les détails du commit "Add third message about future".

N'oubliez pas que vous pouvez appuyer sur q pour quitter la vue git show et revenir à la ligne de commande.

Tester la recherche sensible à la casse

Dans cette étape, nous allons explorer comment git log --grep gère la sensibilité à la casse. Par défaut, la recherche est sensible à la casse, ce qui signifie que "future" est différent de "Future".

Essayons de rechercher "Future" (avec une majuscule F) en utilisant git log --grep :

git log --grep "Future" --oneline

D'après nos commits précédents, seul le message du premier commit "Send a message to the Future" contient "Future" avec une majuscule F. La sortie devrait ressembler à ceci :

<commit-id> Send a message to the future

Notez que le commit "Add third message about future" n'est pas inclus car il utilise un "f" minuscule.

Maintenant, essayons de rechercher "future" (avec un "f" minuscule) à nouveau :

git log --grep "future" --oneline

Cette fois, les deux commits qui contiennent "future" (indépendamment de la casse dans le message d'origine) devraient être affichés :

<commit-id> Add third message about future
<commit-id> Send a message to the future

Attendez, ce n'est pas correct ! L'étape précédente a montré les deux commits lors de la recherche de "future". C'est parce que le comportement par défaut de git log --grep est insensible à la casse sur certains systèmes ou configurations.

Pour garantir une recherche sensible à la casse, vous pouvez utiliser l'option --i (ou --ignore-case). Essayons de rechercher "Future" en tenant compte de la casse :

git log --grep "Future" --oneline --i

Cette commande demande à Git d'ignorer la casse lors de la recherche. Maintenant, les deux commits contenant "future" ou "Future" devraient être affichés :

<commit-id> Add third message about future
<commit-id> Send a message to the future

Cela démontre que bien que le comportement par défaut puisse varier, l'utilisation explicite de l'option --i rend la recherche insensible à la casse. Si vous avez besoin d'une recherche strictement sensible à la casse, vous devriez généralement vous fier au comportement par défaut sans --i. Cependant, compte tenu de la possibilité de variations, il est bon de connaître l'option --i pour les recherches insensibles à la casse.

Comprendre la sensibilité à la casse dans les recherches est important pour trouver précisément des commits, en particulier dans les projets où les conventions de messages de commit peuvent varier.

Résumé

Dans ce laboratoire (lab), nous avons appris à rechercher efficacement dans l'historique des commits Git. Nous avons commencé par utiliser git log --grep pour filtrer les commits en fonction d'un texte spécifique dans leurs messages. Cette commande puissante nous permet de localiser rapidement les commits pertinents, notamment dans les projets ayant un historique de commits important. Nous avons pratiqué cela en créant plusieurs commits, puis en utilisant --grep pour trouver ceux contenant le mot "future".

Nous avons également exploré comment afficher les détails d'un commit spécifique en utilisant git show et comment effectuer des recherches sensibles à la casse avec git log --grep. Ces techniques constituent des outils essentiels pour naviguer dans et comprendre l'évolution d'un dépôt Git.