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ôtfile1.txt- Un fichier texte d'exemplefile2.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 :
- Tout d'abord, vérifiez la chronologie globale du projet :
git log --oneline --graph --all
- Visualisez les modifications détaillées pour chaque commit :
git log --stat origin/master
- Voyez le contenu exact qui a été ajouté dans chaque commit :
git log -p origin/master
- 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
- 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 logpour 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.
