Comment vérifier si une branche Git est synchronisée avec une autre branche

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une branche Git est synchronisée avec une autre branche. Il s'agit d'une compétence fondamentale pour gérer l'historique de votre projet et vous assurer que les branches sont à jour.

Vous allez explorer trois méthodes différentes pour y parvenir : utiliser git log pour comparer les historiques des commits, employer git diff pour identifier les différences entre les branches, et enfin, vérifier la relation entre les branches en utilisant git merge-base. À la fin de ce laboratoire, vous disposerez de techniques pratiques pour déterminer en toute confiance l'état de synchronisation de vos branches Git.

Skills Graph

Utiliser git log pour comparer les commits

Dans cette étape, nous allons apprendre à utiliser la commande git log pour comparer différents commits dans l'historique de votre projet. C'est comme regarder différentes instantanés (snapshots) de votre machine à voyager dans le temps et voir comment les choses ont changé entre elles.

Tout d'abord, assurons-nous que nous sommes dans le répertoire de notre projet. Ouvrez votre terminal et accédez au dossier my-time-machine :

cd ~/project/my-time-machine

Maintenant, créons un nouveau fichier et effectuons un commit. Cela nous donnera un autre point dans l'historique avec lequel comparer notre premier commit.

echo "This is the second message." > second_message.txt
git add second_message.txt
git commit -m "Add a second message file"

Vous devriez voir une sortie similaire à celle-ci après le commit :

[master a1b2c3d] Add a second message file
 1 file changed, 1 insertion(+)
 create mode 100644 second_message.txt

Maintenant, nous avons deux commits dans notre historique. Affichons le journal (log) à nouveau :

git log

Vous verrez deux entrées de commit, la plus récente en haut. Chaque commit a un identifiant unique (la longue chaîne de caractères).

Pour comparer deux commits spécifiques, nous pouvons utiliser git log avec la syntaxe de plage commit1..commit2. Cela affiche les commits qui sont accessibles depuis commit2 mais pas depuis commit1.

Trouvons les identifiants des commits pour nos deux commits. Vous pouvez obtenir les identifiants courts à partir de la sortie de git log --oneline. Par exemple, si l'identifiant de votre premier commit était a1b2c3d et celui de votre deuxième était e4f5g6h, vous utiliserez ces identifiants.

git log --oneline

Exemple de sortie :

e4f5g6h (HEAD -> master) Add a second message file
a1b2c3d Send a message to the future

Maintenant, comparons l'état du projet entre le premier commit (a1b2c3d) et le deuxième commit (e4f5g6h). Remplacez les identifiants d'exemple par vos identifiants de commit réels :

git log a1b2c3d..e4f5g6h

Cette commande vous montrera les commits qui ont été effectués après le commit avec l'identifiant a1b2c3d jusqu'au commit avec l'identifiant e4f5g6h inclus. Dans ce cas, cela devrait vous montrer le deuxième commit.

Comprendre comment comparer les commits à l'aide de git log est crucial pour naviguer dans l'historique de votre projet. Cela vous permet de voir la séquence des modifications et de comprendre l'évolution de votre base de code.

Exécuter git diff branch1 branch2

Dans l'étape précédente, nous avons utilisé git log pour voir quels commits étaient présents dans différentes parties de notre historique. Maintenant, utilisons la commande git diff pour voir les modifications réelles entre deux points différents dans le temps ou entre différentes branches. C'est comme comparer deux versions de votre machine à voyager dans le temps et voir exactement quelles parties ont été ajoutées, supprimées ou modifiées.

Tout d'abord, assurez-vous que vous êtes dans le répertoire de votre projet :

cd ~/project/my-time-machine

Actuellement, nous n'avons qu'une seule branche, master. Pour démontrer la comparaison de branches, créons une nouvelle branche appelée feature-branch. Imaginez une branche comme une ligne temporelle alternative où vous pouvez travailler sur de nouvelles fonctionnalités ou des expériences sans affecter la ligne temporelle principale (master).

git branch feature-branch

Maintenant, changeons de branche pour notre nouvelle branche :

git checkout feature-branch

Vous devriez voir une sortie indiquant que vous avez changé de branche :

Switched to branch 'feature-branch'

Sur cette nouvelle branche, modifions le fichier message.txt :

echo "Adding a line on the feature branch." >> message.txt

Cette commande ajoute une nouvelle ligne au fichier message.txt.

Maintenant, validons (commit) cette modification sur la branche feature-branch :

git add message.txt
git commit -m "Add a line to message.txt on feature branch"

Vous devriez voir une sortie similaire à celle-ci après le commit :

[feature-branch a1b2c3d] Add a line to message.txt on feature branch
 1 file changed, 1 insertion(+)

Maintenant, nous avons deux branches (master et feature-branch) avec des historiques de commits différents. La branche master a les deux premiers commits, et la branche feature-branch a ces deux commits plus le nouveau commit que nous venons de faire.

Utilisons git diff pour voir les différences entre la branche master et la branche feature-branch.

git diff master feature-branch

La sortie vous montrera les lignes exactement différentes entre les deux branches :

diff --git a/message.txt b/message.txt
index a1b2c3d..e4f5g6h 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+Adding a line on the feature branch.

Cette sortie montre que le fichier message.txt est différent. La ligne commençant par + indique une ligne qui a été ajoutée sur la branche feature-branch par rapport à la branche master.

L'utilisation de git diff est incroyablement puissante pour comprendre exactement quelles modifications ont été apportées entre différentes versions de votre projet ou entre différentes branches. Cela vous aide à examiner les modifications avant de les fusionner et à identifier précisément où se sont produites les modifications spécifiques.

Appuyez sur q pour quitter la vue diff et revenir à la ligne de commande.

Vérifier avec git merge-base

Dans cette étape, nous allons explorer la commande git merge-base. Cette commande est utile pour trouver le meilleur ancêtre commun entre deux commits. Imaginez cela comme la recherche du point dans le temps où deux lignes temporelles (branches) différentes se sont divergées.

Tout d'abord, assurez-vous que vous êtes dans le répertoire de votre projet :

cd ~/project/my-time-machine

Nous avons deux branches, master et feature-branch. La branche feature-branch a été créée à partir de master, puis un nouveau commit a été ajouté à feature-branch. L'ancêtre commun de ces deux branches est le commit sur master juste avant la création de feature-branch.

Utilisons git merge-base pour trouver l'ancêtre commun de master et feature-branch :

git merge-base master feature-branch

La sortie de cette commande sera l'identifiant du commit de l'ancêtre commun. Cela devrait être l'identifiant du deuxième commit que nous avons effectué sur la branche master avant de créer la branche feature-branch.

Exemple de sortie :

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9

(L'identifiant de commit réel sera différent dans votre cas).

Pour vérifier que c'est bien l'ancêtre commun, vous pouvez utiliser git log --oneline pour voir l'historique des deux branches et confirmer visuellement l'identifiant du commit.

git log --oneline --graph --all

Cette commande vous montrera une représentation graphique de votre historique de commits sur toutes les branches. Vous pouvez remonter depuis les extrémités de master et feature-branch pour trouver où leurs historiques convergent. L'identifiant du commit identifié par git merge-base devrait être ce point de convergence.

Comprendre l'ancêtre commun est important dans Git, surtout lorsque vous vous apprêtez à fusionner des branches. Git utilise l'ancêtre commun pour déterminer les modifications qui doivent être combinées.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une branche Git est synchronisée avec une autre branche en utilisant diverses commandes Git. Nous avons commencé par utiliser git log pour comparer les commits entre les branches, en comprenant comment afficher l'historique des commits et identifier les différences à l'aide de la syntaxe de plage. Cela nous a permis de voir quels commits existent dans une branche mais pas dans l'autre.

Ensuite, nous avons exploré la commande git diff pour examiner les différences réelles de contenu entre les branches, en visualisant les modifications ligne par ligne. Enfin, nous avons utilisé git merge-base pour trouver le commit de l'ancêtre commun de deux branches, ce qui aide à déterminer si une branche est entièrement incluse dans l'autre. Ces étapes fournissent une approche complète pour vérifier la synchronisation des branches dans Git.