Historique Git et gestion des journaux

Introduction

Bienvenue, voyageur temporel de Git ! Aujourd'hui, nous nous lançons dans un voyage passionnant à travers l'historique de vos projets Git. L'une des fonctionnalités les plus puissantes de Git est sa capacité à suivre et à afficher l'évolution de votre travail. Cet historique n'est pas seulement un enregistrement de ce qui s'est passé, mais un outil redoutable pour comprendre, déboguer et améliorer votre projet.

Dans cet atelier, nous explorerons 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 par date, la recherche de modifications spécifiques et même la génération de statistiques à partir de l'historique de votre projet.

À la fin de cet atelier, vous serez capable de naviguer dans l'historique de votre projet comme un professionnel, en extrayant des informations précieuses qui feront de vous un développeur plus efficace. Que vous soyez à la recherche d'un bug, en train de réviser des modifications ou simplement curieux de comprendre comment votre projet a évolué, les compétences acquises ici seront inestimables.

Montons 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 commits à explorer. Nous allons créer un nouveau répertoire, initialiser un dépôt Git et ajouter quelques commits.

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 commits 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 commit initial.
2. Nous avons créé un fichier JavaScript avec une fonction "hello" et l'avons commité.
3. Nous avons ajouté une fonction "goodbye" au même fichier et l'avons commitée.
4. Nous avons ajouté un fichier de test et l'avons commité.
5. Enfin, nous avons modifié notre script pour appeler les deux fonctions et avons validé les changements.

Nous avons maintenant un dépôt avec un historique prêt à être exploré !

Utilisation de base des journaux

Maintenant que nous avons un historique de commits, explorons l'utilisation basique de git log.

Pour voir l'historique des commits de votre projet, exécutez simplement :

git log

Vous devriez voir une sortie similaire à celle-ci :

commit 1234567890abcdef1234567890abcdef12345678 (HEAD -> main)
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 10:00:00 2023 +0000

    Call hello and goodbye functions

commit 2345678901abcdef2345678901abcdef23456789
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 09:45:00 2023 +0000

    Add test file

...

Chaque entrée du journal affiche :

• Le hash complet du commit (un identifiant unique pour le commit)
• L'auteur du commit
• La date et l'heure du commit
• Le message de validation (commit message)

Par défaut, git log affiche tous les commits, en commençant par le plus récent. Ils sont présentés dans l'ordre chronologique inverse (le plus récent en premier).

Si la sortie est longue, Git l'affichera dans un pagineur (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 commit sur une seule ligne, avec seulement le hash court et le message du commit.

N'oubliez pas que git log est votre fenêtre sur le passé du projet. C'est un excellent point de départ pour comprendre quels changements ont été effectués, quand et par qui.

Formatage de la sortie du journal

Git offre 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 commit, utilisez l'option --stat :

git log --stat

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

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

git log -p

Cela affiche le "patch" réel (les lignes ajoutées et supprimées) pour chaque commit. C'est très utile pour examiner les modifications en détail.

Vous pouvez également créer des formats personnalisés à l'aide de l'option --pretty. Par exemple :

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

Cela affichera :

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

Vous pouvez personnaliser cette chaîne de format pour inclure n'importe quelle information. Voici quelques balises utiles :

• %H : hash complet du commit
• %ad : date de l'auteur
• %cn : nom de celui qui a validé (committer)
• %ce : email de celui qui a validé
• %cd : date de validation

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

Filtrage du journal par date

Souvent, vous souhaiterez examiner les commits effectués dans une plage de temps spécifique. Git propose plusieurs options pour filtrer le journal par date.

Pour voir les commits de la semaine dernière :

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 commits entre le 1er et le 30 juin 2023.

Git comprend une grande variété de formats de date, y compris des formats relatifs comme "yesterday" (hier), "1 month 2 weeks 3 days ago" (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 commits dont la date de validation tombe dans la plage spécifiée. La date de commit correspond au moment où le commit a été créé, ce qui peut différer du moment où les modifications réelles ont été écrites.

Si vous cherchez à savoir quand un changement particulier a été introduit, vous préférerez peut-être utiliser l'option --grep pour rechercher des messages de commit spécifiques, ce que nous verrons à l'étape suivante.

Recherche de modifications spécifiques dans le journal

Git offre des capacités de recherche puissantes pour vous aider à retrouver des commits spécifiques. Explorons certaines de ces fonctionnalités.

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

git log --grep="function"

Cela affichera tous les commits où le mot "function" apparaît dans le message.

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

git log -- script.js

Cela montre tous les commits qui ont affecté le fichier script.js.

Pour rechercher des modifications ayant 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 commits 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 de script.js au cours de la semaine dernière :

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

Notez 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 capacités de recherche sont incroyablement utiles lorsque vous essayez de déterminer quand une modification particulière a été introduite ou quand un bug a été corrigé.

Génération de statistiques à partir du journal

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

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

git shortlog -s -n

Cela affiche une liste d'auteurs, triée par nombre de commits, avec le décompte à 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 le plus changé :

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 commits :

git rev-list --count HEAD

Ces statistiques peuvent être très utiles pour comprendre les schémas de développement globaux de votre projet. Elles permettent d'identifier les parties du projet les plus actives, les contributeurs les plus dynamiques et la croissance du projet au fil du temps.

Gardez à l'esprit que, bien que ces statistiques soient informatives, elles ne racontent pas toute l'histoire. Le nombre de commits ou de lignes modifiées n'est pas nécessairement corrélé à l'impact ou à la qualité des contributions.

Résumé

Félicitations, historien de Git ! Vous venez de débloquer la puissance des fonctionnalités de gestion de l'historique et des journaux de Git. Récapitulons les concepts clés que nous avons abordés :

1. Utilisation de base des journaux : Vous avez appris à visualiser l'historique des commits de votre projet avec git log.
2. Formatage de la sortie : Vous avez découvert comment personnaliser l'affichage pour obtenir exactement les informations nécessaires.
3. Filtrage par date : Vous avez vu comment vous concentrer sur des périodes spécifiques.
4. Recherche de modifications : Vous avez appris des techniques puissantes pour retrouver l'origine de changements précis.
5. Génération de statistiques : Vous avez exploré des moyens d'extraire des tendances sur l'évolution de votre projet.

Ces compétences s'avéreront inestimables à mesure que vous travaillerez sur des projets de plus grande envergure. Que vous traquiez un bug, passiez en revue l'évolution d'une fonctionnalité ou analysiez les tendances de développement, la commande git log et ses diverses options seront vos fidèles alliées.

N'oubliez pas que l'historique de Git n'est pas qu'une simple trace du passé : c'est un outil puissant pour comprendre et améliorer votre projet. Utilisez-le à bon escient, et il fera de vous un développeur plus efficace.

Continuez à explorer et à expérimenter ces commandes. Plus vous serez à l'aise pour naviguer dans l'historique, plus vous pourrez en tirer des enseignements précieux. Bon voyage temporel dans vos dépôts Git !