Tutoriel Git Diff : Comparer les modifications dans Git

Introduction

Bienvenue, explorateur de Git ! Aujourd'hui, nous allons plonger au cœur de 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é exactement quelles modifications vous avez apportées à vos fichiers, ou si vous avez eu besoin de comparer différentes versions de votre code, git diff est l'outil qu'il vous faut.

La commande git diff agit comme un microscope pour vos modifications de code. Elle vous permet de visualiser les différences précises entre les divers états de votre dépôt, qu'il s'agisse de changements dans votre répertoire de travail, dans votre zone d'index (staging area), entre des commits ou même entre des branches.

Dans cet atelier, nous allons explorer comment :

Comparer votre répertoire de travail avec la zone d'index
Comparer votre zone d'index avec le dernier commit
Comparer différentes branches
Comparer des fichiers spécifiques
Utiliser des outils de diff externes pour une comparaison plus visuelle

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

C'est parti, explorons la puissance de git diff !

Configuration de votre espace de travail

Avant de commencer à comparer, configurons un espace de travail avec quelques fichiers et commits. Nous allons créer un nouveau répertoire, initialiser un dépôt Git et ajouter des 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 :

Nous avons créé un fichier README et effectué notre commit initial.
Nous avons créé un fichier JavaScript avec une fonction de salutation et l'avons commité.
Nous avons créé un autre fichier JavaScript avec un tableau de nombres et l'avons commité.

Nous avons maintenant un dépôt avec un historique à explorer !

Comparer le répertoire de travail et la zone d'index

L'utilisation la plus basique de git diff consiste à voir les modifications de votre répertoire de travail qui n'ont pas encore été indexé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 changements :

git diff

Vous devriez voir une sortie similaire à celle-ci :

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 + '!';
+}

Décortiquons cette sortie :

La première ligne indique quels fichiers sont comparés.
Les lignes +++ et --- montrent quelles versions de fichiers sont comparées (a/ est l'original, b/ est la nouvelle version).
La ligne @@ fournit le contexte sur l'emplacement des modifications dans le fichier.
Les lignes commençant par + sont des ajouts, tandis que - indiquerait des suppressions.

Ce diff nous montre que nous avons ajouté trois nouvelles lignes à greet.js.

Appuyez sur q pour quitter la vue diff.

Maintenant, indexons ces modifications :

git add greet.js

Si vous lancez à nouveau git diff, vous ne verrez aucune sortie. C'est parce que git diff ne montre par défaut que les modifications non indexées. Pour voir les modifications indexées, vous devez utiliser git diff --staged, ce que nous verrons à l'étape suivante.

N'oubliez pas : git diff sans argument compare votre répertoire de travail à votre zone d'index. C'est un excellent moyen de vérifier vos modifications avant de les indexer.

Comparer la zone d'index et le dernier commit

Maintenant que nous avons indexé nos modifications, apprenons à comparer la zone d'index avec le dernier commit. C'est très utile pour vérifier ce qui sera inclus dans votre prochain commit.

Pour voir la différence entre la zone d'index et le dernier commit, utilisez :

git diff --staged

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

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

Apportons et indexons une autre modification pour voir comment cela fonctionne :

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

Désormais, lorsque vous lancerez git diff --staged, vous verrez à la fois la fonction farewell et la nouvelle ligne console.log.

Rappelez-vous que git diff --staged (ou git diff --cached, qui est synonyme) vous montre les changements actuellement dans votre zone d'index par rapport au dernier commit. C'est une étape de vérification essentielle avant de valider vos changements.

Comparer des branches

Git diff est également utile pour comparer différentes branches. C'est particulièrement pratique lorsque vous travaillez sur une branche de fonctionnalité (feature branch) et que vous voulez voir en quoi elle diffère de la branche principale.

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 à la branche principale :

git diff master feature-branch

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

Cette commande affiche les différences entre les sommets (tips) des branches master et feature-branch. Elle signifie : "montre-moi quels changements sont présents dans feature-branch mais 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.

Points à retenir lors de la comparaison de branches :

Les changements présents dans la première branche (ou la branche actuelle si omise) mais pas dans la seconde sont affichés comme des suppressions (avec un -).
Les changements présents dans la seconde branche mais pas dans la première sont affichés comme des ajouts (avec un +).

Cette fonctionnalité est incroyablement utile lors de la préparation d'une fusion (merge) ou pour visualiser l'apport d'une branche de fonctionnalité.

Comparer des fichiers spécifiques

Parfois, vous ne souhaitez voir les modifications que pour un fichier ou un ensemble de fichiers précis. Git diff 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 les changements uniquement dans greet.js, nous pouvons utiliser :

git diff greet.js

Cela n'affichera que les modifications apportées à greet.js.

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

git diff master feature-branch -- numbers.js

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

Le symbole -- dans la commande ci-dessus est utilisé pour séparer le chemin du fichier des noms de branches. Ce n'est pas toujours obligatoire, mais c'est une bonne habitude 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 diff que nous avons apprises. C'est particulièrement utile dans les grands projets où vous pouvez avoir des modifications sur de nombreux fichiers mais ne vouloir vous concentrer que sur quelques-uns.

Utiliser des outils de diff externes

Bien que le diff intégré de Git soit puissant, vous pourriez parfois préférer une représentation plus visuelle de vos modifications. De nombreux développeurs utilisent des outils de diff externes à cet effet.

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

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

Désormais, 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 suivant et :prev pour le précédent. Pour quitter vimdiff, utilisez :qa!.

Il existe de nombreux autres outils de diff 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.

Gardez à l'esprit que si les outils de diff visuels peuvent être très utiles, notamment pour les modifications importantes, ils ne sont pas toujours nécessaires. Beaucoup de développeurs deviennent très à l'aise avec la sortie standard de git diff et préfèrent sa rapidité et sa simplicité pour un usage quotidien.

Résumé

Félicitations, détective du diff ! Vous venez de terminer une exploration approfondie de l'univers de git diff. Récapitulons les concepts clés que nous avons abordés :

Comparer le répertoire de travail et la zone d'index : Vous avez appris à visualiser les modifications non indexées.
Comparer la zone d'index et le dernier commit : Vous avez découvert comment réviser vos changements indexés avant de les valider.
Comparer des branches : Vous avez vu comment comparer différentes branches pour comprendre leur divergence.
Comparer des fichiers spécifiques : Vous avez appris à cibler votre analyse sur des fichiers particuliers.
Utiliser des outils de diff externes : Vous avez exploré l'utilisation d'outils visuels pour obtenir une perspective différente sur vos modifications.

La commande git diff est un outil indispensable de votre panoplie Git. Elle vous permet d'inspecter les changements avec précision, que vous prépariez un commit, révisiez le travail d'un collègue ou cherchiez à comprendre l'historique de votre projet.

N'oubliez pas que la maîtrise de git diff vient avec la pratique. Ne vous découragez pas si la sortie vous semble cryptique au début ; avec le temps, vous lirez les diffs rapidement et efficacement.

Tout au long de votre parcours avec Git, continuez à explorer les diverses options et cas d'utilisation de git diff. C'est une commande polyvalente qui, combinée à d'autres fonctionnalités de Git, vous offrira une vision profonde de l'évolution de votre projet.

Bonne continuation dans vos comparaisons, et que vos modifications de code soient toujours claires et intentionnelles !

Exploration approfondie de Git Diff