Comment visualiser l'historique des commits d'une branche Git distante

Introduction

Git est un système de contrôle de version puissant qui permet aux développeurs de suivre les modifications, de collaborer sur des projets et de maintenir un historique complet de leur base de code. Une compétence essentielle dans Git est de savoir comment afficher l'historique des commits des branches distantes, ce qui vous permet de comprendre comment un projet a évolué et qui a contribué à des modifications spécifiques.

Dans ce laboratoire, nous apprendrons à visualiser et à interpréter l'historique des commits des branches Git distantes en utilisant un dépôt GitHub réel. Ces connaissances vous aideront à mieux comprendre l'évolution des projets, à déboguer des problèmes et à collaborer plus efficacement avec votre équipe.

Comprendre les dépôts Git et les commandes de log de base

Avant d'explorer l'historique des commits des branches distantes, comprenons la structure de base d'un dépôt Git et comment visualiser l'historique des commits localement.

Dans ce laboratoire, nous travaillerons avec un dépôt Git réel - le dépôt git-playground de GitHub. Naviguons-y et explorons :

cd ~/project/git-playground

Qu'est-ce qu'un dépôt Git ?

Un dépôt Git est une collection de fichiers et l'historique des modifications apportées à ces fichiers. Git suit les modifications par le biais de commits, qui sont des instantanés de vos fichiers à des moments précis.

Examinons la structure de notre dépôt git-playground :

ls -la

Vous devriez voir les fichiers suivants :

• README.md - La documentation du dépôt
• file1.txt - Un fichier texte d'exemple
• file2.txt - Un autre fichier texte d'exemple

Visualisation de l'historique des commits de base

La commande la plus fondamentale pour visualiser l'historique des commits dans Git est git log. Cette commande affiche l'historique des commits dans l'ordre chronologique inverse (les commits les plus récents en premier).

Essayons-la :

git log

Vous devriez voir une sortie similaire à celle-ci :

commit d22f46ba8c2d4e07d773c5126e9c803933eb5898 (HEAD -> master, origin/master, origin/main, origin/feature-branch, origin/HEAD)
Author: Hang <huhuhang@users.noreply.github.com>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file2.txt

commit cf80005e40a3c661eb212fcea5fad06f8283f08f
Author: Hang <huhuhang@users.noreply.github.com>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file1.txt

commit b00b9374a7c549d1af111aa777fdcc868d8a2a01
Author: Hang <huhuhang@users.noreply.github.com>
Date:   Wed Apr 26 14:16:00 2023 +0800

    Initial commit

Chaque entrée de commit affiche :

• Un hash de commit unique (identifiant)
• L'auteur du commit
• La date et l'heure du commit
• Le message de commit

Pour une vue plus concise, vous pouvez utiliser l'option --oneline :

git log --oneline

Cela affichera chaque commit sur une seule ligne, ne montrant que le hash court du commit et le message de commit :

d22f46b Added file2.txt
cf80005 Added file1.txt
b00b937 Initial commit

Ces commandes de log de base vous aident à comprendre l'historique de votre branche actuelle. Dans la prochaine étape, nous explorerons comment visualiser les informations sur les branches distantes.

Comprendre les dépôts et branches distants

Dans cette étape, nous allons découvrir les dépôts distants et comment travailler avec eux dans Git.

Que sont les dépôts distants ?

Un dépôt distant est une version de votre projet hébergée sur Internet ou sur un autre réseau. Lorsque vous collaborez avec d'autres personnes, vous envoyez vos modifications vers des dépôts distants et récupérez leurs modifications depuis ceux-ci.

Dans notre cas, nous avons un dépôt distant hébergé sur GitHub à l'adresse https://github.com/labex-labs/git-playground.git. Cette connexion distante est déjà configurée dans notre dépôt local avec le nom origin.

Pour voir les dépôts distants configurés, utilisez :

git remote -v

Vous devriez voir une sortie similaire à :

origin  https://github.com/labex-labs/git-playground.git (fetch)
origin  https://github.com/labex-labs/git-playground.git (push)

Comprendre les branches distantes

Les branches distantes représentent l'état des branches dans vos dépôts distants. Elles suivent la convention de nommage <nom-distant>/<nom-de-branche>, comme origin/master ou origin/feature-branch.

Pour voir toutes les branches, y compris les branches distantes, utilisez :

git branch -a

La sortie devrait afficher les branches locales et distantes :

* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/feature-branch
  remotes/origin/main
  remotes/origin/master

Récupération des données distantes

Avant de pouvoir visualiser l'historique des commits des branches distantes, vous devez récupérer les dernières données du dépôt distant. Cela met à jour votre copie locale des branches distantes sans fusionner de modifications.

Récupérons les dernières données :

git fetch origin

Cette commande télécharge tous les derniers commits, branches et fichiers du dépôt distant, vous permettant de visualiser le dernier état des branches distantes.

Vous pouvez maintenant visualiser l'historique des commits d'une branche distante en utilisant git log en spécifiant le nom de la branche distante :

git log origin/feature-branch

Étant donné que toutes les branches de ce dépôt pointent vers le même commit, vous verrez le même historique de commits :

commit d22f46ba8c2d4e07d773c5126e9c803933eb5898 (HEAD -> master, origin/master, origin/main, origin/feature-branch, origin/HEAD)
Author: Hang <huhuhang@users.noreply.github.com>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file2.txt

commit cf80005e40a3c661eb212fcea5fad06f8283f08f
Author: Hang <huhuhang@users.noreply.github.com>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file1.txt

commit b00b9374a7c549d1af111aa777fdcc868d8a2a01
Author: Hang <huhuhang@users.noreply.github.com>
Date:   Wed Apr 26 14:16:00 2023 +0800

    Initial commit

En comprenant les dépôts distants et comment en récupérer les données, vous pouvez accéder et visualiser l'historique des commits de n'importe quelle branche distante.

Commandes avancées de log Git pour les branches distantes

Maintenant que nous comprenons les bases de la visualisation de l'historique des branches distantes, explorons des options de log Git plus avancées pour mieux visualiser et analyser l'historique des commits.

Personnalisation de la sortie du log

La commande git log possède de nombreuses options pour personnaliser sa sortie. Voici quelques-unes des plus utiles :

Afficher un log concis

Pour une vue plus compacte de l'historique des commits, utilisez l'option --oneline :

git log --oneline origin/master

Exemple de sortie :

d22f46b Added file2.txt
cf80005 Added file1.txt
b00b937 Initial commit

Limiter le nombre de commits

Si vous souhaitez uniquement voir un nombre spécifique de commits, utilisez l'option -n suivie du nombre :

git log -n 2 origin/master

Ceci affichera seulement les 2 commits les plus récents sur la branche master distante.

Voir les commits avec les modifications

Pour voir les modifications réelles apportées dans chaque commit, ajoutez l'option -p (abréviation de "patch") :

git log -p origin/master

Ceci affichera le diff complet pour chaque commit, y compris les lignes ajoutées ou supprimées. Ceci est particulièrement utile lors de l'investigation de bugs ou de la compréhension de modifications spécifiques.

Essayons ceci avec un fichier spécifique :

git log -p origin/master -- file1.txt

Cette commande affiche l'historique des commits avec les modifications pour le fichier file1.txt uniquement sur la branche master distante.

Visualisation du graphe des commits

Pour une représentation visuelle de l'historique des commits, utilisez l'option --graph :

git log --graph --oneline --all

Ceci affichera un graphe ASCII montrant la relation entre les commits et les branches :

* d22f46b (HEAD -> master, origin/master, origin/main, origin/feature-branch, origin/HEAD) Added file2.txt
* cf80005 Added file1.txt
* b00b937 Initial commit

Le graphe vous aide à visualiser comment les branches divergent et fusionnent, facilitant ainsi la compréhension de l'historique de développement du projet.

Voir les statistiques des commits

Pour voir les statistiques sur les modifications dans chaque commit :

git log --stat origin/master

Ceci montre quels fichiers ont été modifiés et combien de lignes ont été ajoutées ou supprimées dans chaque commit.

Ces commandes de log avancées vous fournissent des outils puissants pour analyser et comprendre l'historique des commits des branches distantes de diverses manières.

Comparaison des branches et examen des commits spécifiques

Maintenant que nous pouvons visualiser l'historique des commits des branches distantes, apprenons à comparer les branches et à examiner les commits spécifiques plus en détail.

Comparaison des branches

Git fournit des outils puissants pour comparer différentes branches. Comme toutes les branches de notre dépôt git-playground pointent vers le même commit, comprenons d'abord comment utiliser ces commandes, puis nous verrons des exemples pratiques.

Pour voir les différences entre votre branche actuelle et une branche distante, utilisez :

git diff origin/main

Comme toutes les branches sont identiques dans notre exemple, cela n'affichera aucune différence. Cependant, dans des projets réels, cela montrerait ce qui a changé entre votre branche actuelle et la branche distante.

Vous pouvez également comparer deux branches distantes :

git diff origin/master origin/feature-branch

Encore une fois, comme elles sont identiques, aucune différence ne sera affichée.

Examen des commits spécifiques

Parfois, vous devez examiner un commit spécifique en détail. Vous pouvez le faire en utilisant la commande git show suivie du hash du commit :

Tout d'abord, obtenons les hashes des commits :

git log --oneline origin/master

Examinons maintenant un commit spécifique en utilisant son hash :

git show d22f46b

Cette commande affiche les détails du commit ainsi que les modifications introduites dans ce commit. Vous verrez l'ajout de file2.txt.

Examinons le commit qui a ajouté file1.txt :

git show cf80005

Et le commit initial :

git show b00b937

Visualisation du contenu des fichiers à partir d'une branche distante

Pour voir le contenu d'un fichier spécifique tel qu'il existe dans une branche distante, utilisez :

git show origin/master:README.md

Ceci affiche le contenu de README.md tel qu'il existe dans la branche master du dépôt distant.

Vous pouvez également voir le contenu d'autres fichiers :

git show origin/master:file1.txt
git show origin/master:file2.txt

Vérifier qui a modifié une ligne spécifique

Pour voir qui a apporté des modifications à un fichier particulier et quand, utilisez la commande git blame :

git blame README.md

Ceci affiche chaque ligne du fichier avec le hash du commit, l'auteur et la date de la dernière modification de cette ligne.

Essayez avec les autres fichiers :

git blame file1.txt
git blame file2.txt

Visualisation de l'historique des fichiers

Pour voir comment un fichier spécifique a évolué au fil du temps :

git log -p origin/master -- README.md

Ceci montre tous les commits qui ont modifié le fichier README.md dans la branche master distante, ainsi que les modifications apportées dans chaque commit.

Ces commandes fournissent des outils précieux pour comprendre l'historique et l'évolution de votre base de code, facilitant ainsi le suivi des modifications, le débogage des problèmes et la collaboration avec d'autres développeurs.

Applications pratiques de l'historique des branches distantes

Maintenant que nous avons appris les aspects techniques de la visualisation de l'historique des branches distantes, explorons quelques applications pratiques de ces connaissances dans des scénarios de développement réels.

Revue de code et compréhension des modifications

Lors de la revue des modifications de code apportées par les membres de l'équipe, vous pouvez utiliser :

git log -p origin/master

Cela vous aide à comprendre les modifications de manière exhaustive avant de les fusionner dans la branche principale. Dans notre exemple git-playground, vous pouvez voir exactement quand et comment chaque fichier a été ajouté.

Débogage des problèmes

Lorsqu'un bug apparaît dans votre application, vous pouvez retracer quand il a été introduit. Par exemple, s'il y avait un problème avec un fichier spécifique :

git log -p origin/master -- file1.txt

En examinant l'historique des commits du fichier spécifique, vous pouvez identifier quand et pourquoi le code problématique a été ajouté.

Suivi du développement des fonctionnalités

Pour comprendre la progression du développement d'un projet :

git log --oneline origin/master

Ceci vous donne une vue chronologique des commits qui ont contribué au projet. Dans notre exemple :

d22f46b Added file2.txt
cf80005 Added file1.txt
b00b937 Initial commit

Vous pouvez voir que le projet a évolué à partir d'un commit initial, puis a ajouté deux fichiers séquentiellement.

Identification des contributeurs

Pour voir qui a contribué à un fichier spécifique ou à une zone du codebase :

git shortlog -sn origin/master

Ceci montre un résumé des contributeurs et le nombre de commits qu'ils ont effectués :

     3  Hang

Pour un fichier spécifique :

git shortlog -sn origin/master -- README.md

Pratiquons un scénario du monde réel

Imaginez que vous ayez besoin de comprendre comment le projet a évolué. Essayez ces commandes :

1. Tout d'abord, vérifiez la chronologie globale du projet :

git log --oneline --graph --all

2. Visualisez les modifications détaillées pour chaque commit :

git log --stat origin/master

3. Voyez le contenu exact qui a été ajouté dans chaque commit :

git log -p origin/master

4. Vérifiez quand un fichier spécifique a été modifié pour la dernière fois :

git log -1 --format="%H %an %ad %s" origin/master -- file2.txt

5. Comparez l'état du dépôt à différents moments :

git show cf80005:. | head -10

Compréhension des relations entre les branches

Comme toutes les branches de notre dépôt pointent vers le même commit, comprenons ce que cela signifie :

git show-branch origin/master origin/main origin/feature-branch

Ceci montre que toutes les branches sont dans le même état, ce qui est courant dans les dépôts simples ou lorsque les branches sont maintenues synchronisées.

Travail avec les références distantes

Pour voir toutes les références distantes :

git ls-remote origin

Ceci montre toutes les branches et les tags disponibles sur le dépôt distant.

Ces exemples pratiques démontrent comment la visualisation de l'historique des branches distantes peut vous aider à comprendre l'évolution de votre codebase, à collaborer plus efficacement avec les membres de l'équipe et à résoudre les problèmes plus efficacement.

En maîtrisant les compétences abordées dans ce laboratoire, vous serez mieux équipé pour travailler avec Git dans des environnements de développement professionnels et collaborer efficacement sur des projets logiciels.

Résumé

Dans ce laboratoire, vous avez appris à visualiser et analyser l'historique des commits des branches Git distantes en utilisant un véritable dépôt GitHub (git-playground), ce qui est une compétence essentielle pour une collaboration efficace dans les projets de développement logiciel.

Points clés abordés :

• Compréhension des dépôts Git et de l'historique des commits de base avec git log
• Travail avec les dépôts distants et récupération des données des branches distantes depuis GitHub
• Utilisation d'options avancées de git log pour personnaliser et visualiser l'historique des commits
• Comparaison des branches et examen détaillé des commits spécifiques
• Application de ces compétences à des scénarios de développement réels en utilisant des données de commits réelles

En travaillant avec le dépôt git-playground, vous avez vu :

• Comment cloner et explorer un véritable dépôt GitHub
• L'historique réel des commits montrant l'évolution du commit initial à l'ajout de fichiers
• Comment utiliser diverses commandes Git pour analyser la contribution de "Hang" sur trois commits
• Des applications pratiques de l'analyse des commits pour comprendre le développement du projet

Ces compétences vous permettront de :

• Mieux comprendre l'évolution du projet et le contexte derrière les modifications de code
• Déboguer efficacement les problèmes en retraçant quand et pourquoi des modifications spécifiques ont été apportées
• Collaborer plus efficacement avec les membres de l'équipe en comprenant leurs contributions
• Prendre des décisions plus éclairées lors de la fusion, du branchement et de la gestion du code

Au fur et à mesure que vous continuerez à travailler avec Git, ces capacités deviendront de plus en plus précieuses, vous aidant à naviguer dans des bases de code complexes et à contribuer efficacement aux projets de développement collaboratifs.