Plongée approfondie dans Git Diff

Introduction

Bienvenue, explorateur Git! Aujourd'hui, nous allons plonger profondément dans l'une des fonctionnalités les plus puissantes et les plus utilisées de Git : la commande git diff. Si vous vous êtes déjà demandé quelles modifications vous avez apportées à vos fichiers, ou si vous avez besoin de comparer différentes versions de votre code, git diff est l'outil que vous cherchez.

La commande git diff est comme un microscope pour les modifications de votre code. Elle vous permet de voir les différences précises entre différents états de votre dépôt, que ce soit les modifications dans votre répertoire de travail, votre zone de préparation (staging area), entre les commits, ou même entre les branches.

Dans ce laboratoire (LabEx), nous allons explorer comment :

1. Comparer votre répertoire de travail avec la zone de préparation
2. Comparer votre zone de préparation avec le dernier commit
3. Comparer différentes branches
4. Comparer des fichiers spécifiques
5. Utiliser des outils de comparaison différentiels externes pour une comparaison plus visuelle

À la fin de ce laboratoire, vous serez un expert en git diff, capable d'examiner vos modifications avec précision et confiance. Cette compétence est essentielle pour passer en revue votre travail, préparer vos commits et collaborer efficacement avec les autres.

Plongeons-y et commençons à explorer le pouvoir de git diff!

Skills Graph

Configuration de votre espace de travail

Avant de commencer à utiliser la commande de comparaison différentielle (diff), configurons un espace de travail avec quelques fichiers et commits à comparer. Nous allons créer un nouveau répertoire, initialiser un dépôt Git et ajouter quelques fichiers avec plusieurs commits.

Ouvrez votre terminal et tapez ces commandes :

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

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

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

echo "function greet(name) {" > greet.js
echo "  return 'Hello, ' + name + '!';" >> greet.js
echo "}" >> greet.js
git add greet.js
git commit -m "Add greet function"

echo "const numbers = [1, 2, 3, 4, 5];" > numbers.js
echo "console.log(numbers);" >> numbers.js
git add numbers.js
git commit -m "Add numbers array"

Analysons ce que nous venons de faire :

1. Nous avons créé un fichier README et effectué notre premier commit.
2. Nous avons créé un fichier JavaScript avec une fonction de salutation et l'avons validé (committed).
3. Nous avons créé un autre fichier JavaScript avec un tableau de nombres et l'avons validé (committed).

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

Comparaison du répertoire de travail et de la zone de préparation (staging area)

L'utilisation la plus basique de git diff consiste à voir les modifications dans votre répertoire de travail qui n'ont pas encore été préparées (staged). Explorons cela.

Tout d'abord, apportons quelques modifications à notre fichier greet.js :

echo "function farewell(name) {" >> greet.js
echo "  return 'Goodbye, ' + name + '!';" >> greet.js
echo "}" >> greet.js

Maintenant, utilisons git diff pour voir ces modifications :

git diff

Vous devriez voir une sortie similaire à ceci :

diff --git a/greet.js b/greet.js
index 95f5574..a3641f6 100644
--- a/greet.js
+++ b/greet.js
@@ -1,3 +1,7 @@
 function greet(name) {
   return 'Hello, ' + name + '!';
 }
+function farewell(name) {
+  return 'Goodbye, ' + name + '!';
+}

Analysons cette sortie :

• La première ligne indique quels fichiers sont comparés.
• Les lignes +++ et --- indiquent quelles versions de fichier sont comparées (a/ est la version originale, b/ est la nouvelle version).
• La ligne @@ fournit des informations sur l'endroit dans le fichier où les modifications ont lieu.
• Les lignes commençant par + sont des ajouts, tandis que - indiquerait des suppressions.

Cette comparaison différentielle (diff) nous montre que nous avons ajouté trois nouvelles lignes au fichier greet.js.

Appuyez sur q pour quitter la vue de comparaison différentielle.

Maintenant, préparons (stage) ces modifications :

git add greet.js

Si vous exécutez git diff à nouveau, vous ne verrez aucune sortie. C'est parce que git diff montre par défaut uniquement les modifications non préparées (unstaged). Pour voir les modifications préparées (staged), vous devez utiliser git diff --staged, que nous aborderons à l'étape suivante.

N'oubliez pas que git diff sans aucun argument compare votre répertoire de travail à votre zone de préparation (staging area). C'est un excellent moyen de passer en revue vos modifications avant de les préparer.

Comparaison de la zone de préparation (staging area) et du dernier commit

Maintenant que nous avons préparé (staged) nos modifications, apprenons à comparer la zone de préparation avec le dernier commit. Cela est utile pour passer en revue les modifications qui seront incluses dans votre prochain commit.

Pour voir la différence entre la zone de préparation et le dernier commit, utilisez :

git diff --staged

Vous devriez voir une sortie similaire à celle que nous avons vue à l'étape précédente, montrant l'ajout de la fonction farewell.

Cette commande est particulièrement utile lorsque vous avez préparé des modifications au fil du temps et que vous souhaitez passer en revue tout ce qui sera inclus dans votre prochain commit.

Faisons et préparons une autre modification pour voir comment cela fonctionne :

echo "console.log(greet('World'));" >> greet.js
git add greet.js

Maintenant, lorsque vous exécutez git diff --staged, vous verrez à la fois la fonction farewell et la nouvelle ligne console.log.

N'oubliez pas que git diff --staged (ou git diff --cached, qui est synonyme) vous montre quelles modifications sont actuellement dans votre zone de préparation par rapport au dernier commit. C'est un excellent moyen de vérifier vos modifications préparées avant de les valider (committer).

Comparaison de branches

La commande git diff est également utile pour comparer différentes branches. Cela est particulièrement utile lorsque vous travaillez sur une branche de fonctionnalité (feature branch) et que vous souhaitez voir en quoi elle diffère de la branche principale (main branch).

Créons une nouvelle branche et apportons quelques modifications :

git checkout -b feature-branch
echo "const PI = 3.14159;" >> numbers.js
git add numbers.js
git commit -m "Add PI constant"

Maintenant, comparons cette branche avec la branche principale :

git diff master feature-branch

Vous devriez voir une sortie montrant l'ajout de la constante PI dans le fichier numbers.js.

Cette commande montre les différences entre les points d'extrémité (tips) des branches master et feature-branch. Elle signifie « montrez-moi les modifications présentes dans feature-branch qui ne sont pas dans master ».

Vous pouvez également comparer votre branche actuelle avec une autre branche en omettant le nom de la première branche :

git diff master

Cela compare votre branche actuelle (feature-branch) avec master.

N'oubliez pas que lors de la comparaison de branches :

• Les modifications présentes dans la première branche (ou dans la branche actuelle si omise) mais pas dans la deuxième sont affichées comme des suppressions (avec un -).
• Les modifications présentes dans la deuxième branche mais pas dans la première sont affichées comme des ajouts (avec un +).

Cette fonctionnalité est incroyablement utile lors de la préparation d'une fusion (merge) de branches ou lorsque vous souhaitez voir quelles modifications une branche de fonctionnalité apporte.

Comparaison de fichiers spécifiques

Parfois, vous ne souhaitez voir que les modifications apportées à un fichier spécifique ou à un ensemble de fichiers. La commande git diff vous permet de le faire facilement.

Apportons des modifications à plusieurs fichiers :

echo "function multiply(a, b) { return a * b; }" >> greet.js
echo "const doubledNumbers = numbers.map(n => n * 2);" >> numbers.js

Maintenant, si nous voulons voir uniquement les modifications apportées à greet.js, nous pouvons utiliser :

git diff greet.js

Cela affichera uniquement les modifications apportées à greet.js.

Vous pouvez également comparer un fichier spécifique entre des branches :

git diff master feature-branch -- numbers.js

Cela montre les différences dans numbers.js entre les branches master et feature-branch.

Le -- dans la commande ci-dessus est utilisé pour séparer le chemin du fichier des noms de branches. Ce n'est pas toujours nécessaire, mais c'est une bonne pratique de l'utiliser pour éviter toute ambiguïté, surtout si vos noms de fichiers pourraient être confondus avec des noms de branches.

N'oubliez pas que vous pouvez utiliser des chemins de fichiers avec n'importe laquelle des commandes de comparaison différentielle (diff) que nous avons apprises. Cela est particulièrement utile dans les projets plus importants où vous pourriez avoir des modifications sur de nombreux fichiers mais ne voulez vous concentrer que sur quelques-uns.

Utilisation d'outils de comparaison différentielle externes

Bien que la fonction de comparaison différentielle (diff) intégrée à Git soit puissante, vous pourriez parfois souhaiter avoir une représentation plus visuelle de vos modifications. De nombreux développeurs utilisent des outils de comparaison différentielle externes à cette fin.

Un outil populaire est vimdiff. Configurons Git pour utiliser vimdiff :

git config --global diff.tool vimdiff
git config --global difftool.prompt false

Maintenant, au lieu de git diff, vous pouvez utiliser git difftool :

git difftool

Cela ouvrira chaque fichier modifié dans vimdiff. Vous pouvez naviguer entre les fichiers en utilisant :n pour le fichier suivant et :prev pour le fichier précédent. Pour quitter vimdiff, utilisez :qa!.

Il existe de nombreux autres outils de comparaison différentielle disponibles, tels que Beyond Compare, KDiff3 ou P4Merge. Le choix de l'outil dépend souvent des préférences personnelles et de votre système d'exploitation.

N'oubliez pas que bien que les outils de comparaison différentielle visuels puissent être très utiles, surtout pour les modifications importantes, ils ne sont pas toujours nécessaires. De nombreux développeurs maîtrisent la sortie standard de git diff et préfèrent sa rapidité et sa simplicité pour une utilisation quotidienne.

Résumé

Félicitations, détective des différences (diff)! Vous venez de plonger au cœur du monde de git diff. Récapitulons les concepts clés que nous avons abordés :

1. Comparaison du répertoire de travail (working directory) et de la zone de préparation (staging area) : Vous avez appris à voir les modifications non préparées (unstaged) dans votre répertoire de travail.
2. Comparaison de la zone de préparation et du dernier commit : Vous avez découvert comment passer en revue les modifications préparées avant de les valider (committer).
3. Comparaison de branches : Vous avez vu comment comparer différentes branches pour voir en quoi elles ont divergé.
4. Comparaison de fichiers spécifiques : Vous avez appris à vous concentrer sur des fichiers particuliers lors de la comparaison différentielle.
5. Utilisation d'outils de comparaison différentielle externes : Vous avez exploré comment utiliser des outils de comparaison différentielle visuels pour avoir une autre perspective sur vos modifications.

La commande git diff est un outil puissant dans votre boîte à outils Git. Elle vous permet d'inspecter les modifications avec précision, que vous prépariez un commit, examiniez le travail d'un collègue ou tentiez de comprendre l'historique de votre projet.

N'oubliez pas que maîtriser git diff nécessite de la pratique. Ne vous découragez pas si la sortie semble cryptique au début - avec le temps, vous serez capable de lire rapidement et efficacement les différences.

Au fur et à mesure de votre parcours avec Git, continuez d'explorer les diverses options et cas d'utilisation de git diff. C'est une commande polyvalente qui peut être combinée avec de nombreuses autres fonctionnalités de Git pour vous donner des informations approfondies sur les modifications de votre projet.

Bonnes comparaisons différentielles, et que vos modifications de code soient toujours claires et intentionnelles!