Gestion de l'historique et du journal (log) de Git

Introduction

Bienvenue, voyageur temporel de Git! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers l'histoire de vos projets Git. L'une des fonctionnalités les plus puissantes de Git est sa capacité à suivre et à afficher l'histoire de votre projet. Cette histoire n'est pas seulement un enregistrement de ce qui s'est passé, mais un outil puissant pour comprendre, déboguer et améliorer votre projet.

Dans ce labo (LabEx), nous allons explorer la commande git log, qui est votre fenêtre sur les archives historiques de Git. Nous commencerons par l'utilisation de base, puis nous plongerons dans des techniques plus avancées telles que le formatage de la sortie des journaux, le filtrage des journaux par date, la recherche de modifications spécifiques et même la génération de statistiques à partir de l'histoire de votre projet.

À la fin de ce labo (LabEx), vous serez capable de naviguer dans l'histoire de votre projet comme un pro, extrayant des informations et des connaissances précieuses qui vous feront devenir un développeur plus efficace. Que vous cherchiez à localiser un bogue, à passer en revue des modifications ou simplement à comprendre comment votre projet a évolué, les compétences que vous apprendrez ici seront inestimables.

Entrons dans notre machine à remonter le temps Git et explorons le passé!

Configuration de votre espace de travail

Avant de plonger dans les fonctionnalités d'historique de Git, configurons un espace de travail avec un historique de validations (commits) à explorer. Nous allons créer un nouveau répertoire, initialiser un dépôt Git et ajouter quelques validations.

Ouvrez votre terminal et tapez ces commandes :

cd ~/project
mkdir git-history-lab
cd git-history-lab
git init

Maintenant, créons quelques fichiers et effectuons une série de validations en copiant et collant les commandes suivantes :

echo "## Git History Lab" > README.md
git add README.md
git commit -m "Initial commit"

echo "function hello() {" > script.js
echo "  console.log('Hello, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add hello function"

echo "function goodbye() {" >> script.js
echo "  console.log('Goodbye, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add goodbye function"

echo "This is a test file" > test.txt
git add test.txt
git commit -m "Add test file"

echo "hello();" >> script.js
echo "goodbye();" >> script.js
git add script.js
git commit -m "Call hello and goodbye functions"

Analysons ce que nous venons de faire :

1. Nous avons créé un fichier README et effectué notre première validation.
2. Nous avons créé un fichier JavaScript avec une fonction "hello" et l'avons validé.
3. Nous avons ajouté une fonction "goodbye" au même fichier et l'avons validé.
4. Nous avons ajouté un fichier de test et l'avons validé.
5. Enfin, nous avons modifié notre script pour appeler les deux fonctions et validé les modifications.

Maintenant, nous avons un dépôt avec un historique à explorer!

Utilisation de base du journal (log)

Maintenant que nous avons un historique de validations (commits), explorons l'utilisation de base de la commande git log.

Pour voir l'historique des validations de votre projet, il suffit d'exécuter :

git log

Vous devriez voir une sortie similaire à celle-ci :

commit 1234567890abcdef1234567890abcdef12345678 (HEAD -> main)
Author: Your Name <[email protected]>
Date:   Mon Jun 5 10:00:00 2023 +0000

    Call hello and goodbye functions

commit 2345678901abcdef2345678901abcdef23456789
Author: Your Name <[email protected]>
Date:   Mon Jun 5 09:45:00 2023 +0000

    Add test file

...

Chaque entrée du journal montre :

• Le hachage complet de la validation (un identifiant unique pour la validation)
• L'auteur de la validation
• La date et l'heure de la validation
• Le message de validation

Par défaut, git log affiche toutes les validations, en commençant par la plus récente. Elle les affiche dans l'ordre chronologique inverse (les plus récentes en premier).

Si la sortie est longue, Git l'affichera dans un visualiseur de texte (généralement less). Vous pouvez naviguer à l'aide des touches fléchées et appuyer sur q pour quitter.

Pour voir une version plus concise du journal, vous pouvez utiliser :

git log --oneline

Cela affiche chaque validation sur une seule ligne, avec seulement le hachage court de la validation et le message de validation.

N'oubliez pas que git log est votre fenêtre sur l'historique du projet. C'est un excellent point de départ pour comprendre quelles modifications ont été apportées, quand et par qui.

Formatage de la sortie du journal (log)

Git propose des options puissantes pour formater la sortie du journal afin d'afficher exactement les informations dont vous avez besoin. Explorons quelques-unes de ces options.

Pour afficher les fichiers qui ont été modifiés dans chaque validation (commit), utilisez l'option --stat :

git log --stat

Cela vous montrera quels fichiers ont été modifiés dans chaque validation et combien de lignes ont été ajoutées ou supprimées.

Pour avoir une vue plus détaillée des modifications, utilisez l'option -p :

git log -p

Cela affiche le patch réel (les lignes qui ont été ajoutées et supprimées) pour chaque validation. C'est très utile pour passer en revue les modifications en détail.

Vous pouvez également créer des formats personnalisés en utilisant l'option --pretty. Par exemple :

git log --pretty=format:"%h - %an, %ar : %s"

Cela affichera :

• %h : hachage de validation abrégé
• %an : nom de l'auteur
• %ar : date de l'auteur, relative
• %s : sujet (message de validation)

Vous pouvez personnaliser cette chaîne de format pour inclure toutes les informations dont vous avez besoin. Voici quelques espaces réservés utiles :

• %H : hachage de validation complet
• %ad : date de l'auteur
• %cn : nom du validateur (committer)
• %ce : e-mail du validateur
• %cd : date du validateur

Expérimentez avec différents formats pour trouver celui qui vous convient le mieux!

Filtrage du journal (log) par date

Souvent, vous voudrez examiner les validations (commits) effectuées dans une plage de temps spécifique. Git propose plusieurs options pour filtrer le journal par date.

Pour voir les validations effectuées au cours de la dernière semaine :

git log --since=1.week

Vous pouvez également utiliser des dates spécifiques :

git log --after="2023-06-01" --before="2023-06-30"

Cela affichera les validations effectuées entre le 1er juin et le 30 juin 2023.

Git comprend une variété de formats de date, y compris les formats relatifs tels que "hier", "il y a 1 mois 2 semaines et 3 jours", etc.

Vous pouvez également utiliser l'option --until au lieu de --before, et --after est synonyme de --since.

N'oubliez pas que ces filtres affichent les validations dont la date de validation tombe dans la plage spécifiée. La date de validation est la date à laquelle la validation a été créée, qui peut différer de la date à laquelle les modifications réelles ont été effectuées.

Si vous cherchez à savoir quand une modification particulière a été introduite, vous pouvez utiliser l'option --grep pour rechercher des messages de validation spécifiques, que nous aborderons à l'étape suivante.

Recherche dans le journal (log) pour des modifications spécifiques

Git propose des fonctionnalités de recherche puissantes pour vous aider à trouver des validations (commits) spécifiques. Explorons quelques-unes de ces fonctionnalités.

Pour rechercher des validations contenant un mot spécifique dans le message de validation :

git log --grep="function"

Cela affichera toutes les validations où le mot "function" apparaît dans le message de validation.

Vous pouvez également rechercher les modifications apportées à un fichier spécifique :

git log -- script.js

Cela affiche toutes les validations qui ont affecté le fichier script.js.

Pour rechercher les modifications qui ont ajouté ou supprimé une ligne de code spécifique :

git log -S "console.log"

C'est ce qu'on appelle une recherche "pickaxe". Elle affiche les validations où le nombre d'occurrences de "console.log" a changé.

Vous pouvez combiner ces options avec d'autres. Par exemple, pour voir les modifications détaillées apportées à script.js au cours de la dernière semaine :

git log -p --since=1.week -- script.js

N'oubliez pas que la recherche de Git est sensible à la casse par défaut. Utilisez l'option -i pour une recherche insensible à la casse :

git log --grep="function" -i

Ces fonctionnalités de recherche sont incroyablement utiles lorsque vous essayez de déterminer quand une modification particulière a été introduite ou quand un bogue a été corrigé.

Génération de statistiques à partir du journal (log)

Git peut fournir des informations précieuses sur l'historique de votre projet grâce à des statistiques. Explorons quelques façons de générer ces statistiques.

Pour voir un résumé du nombre de validations (commits) par auteur :

git shortlog -s -n

Cela affiche une liste d'auteurs, triée par nombre de validations, avec le nombre de validations à côté de chaque nom.

Pour voir combien de lignes chaque auteur a ajoutées et supprimées :

git log --author="Jane Doe" --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "Added lines: %s, Removed lines: %s, Total lines: %s\n", add, subs, loc }'

Remplacez "Jane Doe" par le nom de l'auteur que vous souhaitez vérifier.

Pour voir quels fichiers ont été le plus modifiés :

git log --pretty=format: --name-only | sort | uniq -c | sort -rg | head -10

Cela affiche les 10 fichiers les plus fréquemment modifiés.

Pour voir le nombre total de validations :

git rev-list --count HEAD

Ces statistiques peuvent être très utiles pour comprendre les tendances globales de développement de votre projet. Elles peuvent aider à identifier les parties du projet les plus activement développées, les contributeurs les plus actifs et comment le projet a évolué au fil du temps.

N'oubliez pas que, bien que ces statistiques puissent être informatives, elles ne racontent pas toute l'histoire. Le nombre de validations ou de lignes modifiées ne correspond pas nécessairement à l'impact ou à la qualité des contributions.

Résumé

Félicitations, historien de Git! Vous venez de débloquer le potentiel des fonctionnalités de gestion de l'historique et du journal (log) de Git. Récapitulons les concepts clés que nous avons abordés :

1. Utilisation de base du journal : Vous avez appris à consulter l'historique des validations (commits) de votre projet en utilisant git log.
2. Formatage de la sortie du journal : Vous avez découvert comment personnaliser la sortie du journal pour afficher exactement les informations dont vous avez besoin.
3. Filtrage du journal par date : Vous avez vu comment vous concentrer sur les validations effectuées dans des plages de temps spécifiques.
4. Recherche dans le journal pour des modifications spécifiques : Vous avez appris des techniques puissantes pour trouver quand des modifications particulières ont été introduites.
5. Génération de statistiques à partir du journal : Vous avez exploré des méthodes pour extraire des informations sur les tendances de développement de votre projet.

Ces compétences se révèleront inestimables lorsque vous travaillerez sur des projets plus importants. Que vous cherchiez à identifier un bogue, à examiner l'évolution d'une fonctionnalité ou à comprendre les tendances globales de développement de votre projet, la commande git log et ses diverses options seront vos compagnons de confiance.

N'oubliez pas que l'historique de Git n'est pas seulement un enregistrement de ce qui s'est passé - c'est un outil puissant pour comprendre et améliorer votre projet. Utilisez-le avec sagesse, et il vous rendra un développeur plus efficace.

Continuez à explorer et à expérimenter avec ces commandes. Plus vous vous familiariserez avec la navigation dans l'historique de votre projet, plus vous serez en mesure d'en extraire des informations précieuses. Bon voyage dans le temps dans vos dépôts Git!