Comment vérifier si un commit Git est présent dans une branche spécifique

Introduction

Dans ce laboratoire (lab), vous apprendrez à déterminer si un commit Git spécifique existe au sein d'une branche particulière. Nous allons explorer la commande git branch --contains pour identifier toutes les branches qui incluent un commit donné, ce qui vous permettra de mieux comprendre l'historique du commit et les points d'intégration.

Vous apprendrez également à utiliser git log avec le nom d'une branche pour vérifier la présence d'un commit dans l'historique de cette branche et à vérifier efficacement plusieurs branches pour un commit. Ce laboratoire vous dotera des compétences essentielles pour comprendre et naviguer dans l'historique de votre projet Git.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BranchManagementGroup -.-> git/branch("Handle Branches") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560059{{"Comment vérifier si un commit Git est présent dans une branche spécifique"}} git/commit -.-> lab-560059{{"Comment vérifier si un commit Git est présent dans une branche spécifique"}} git/branch -.-> lab-560059{{"Comment vérifier si un commit Git est présent dans une branche spécifique"}} git/log -.-> lab-560059{{"Comment vérifier si un commit Git est présent dans une branche spécifique"}} end

Exécuter git branch --contains Commit

Dans cette étape, nous allons apprendre à utiliser la commande git branch --contains pour savoir quelles branches contiennent un commit spécifique. C'est une commande très utile lorsque vous souhaitez comprendre l'historique de votre projet et voir où un changement particulier a été intégré.

Tout d'abord, assurons-nous que nous sommes dans le répertoire my-time-machine. Ouvrez votre terminal et tapez :

cd ~/project/my-time-machine

Maintenant, créons un nouveau fichier et effectuons un commit. Cela nous donnera un nouveau commit avec lequel travailler.

echo "Another message for the future" > message2.txt
git add message2.txt
git commit -m "Add another message"

Vous devriez voir une sortie similaire à ceci après le commit :

[master <commit-id>] Add another message
 1 file changed, 1 insertion(+)
 create mode 100644 message2.txt

Maintenant, nous avons un nouveau commit. Trouvons l'ID du commit de ce nouveau commit. Nous pouvons utiliser git log --oneline pour voir un journal condensé :

git log --oneline

La sortie ressemblera à ceci :

<commit-id-2> (HEAD -> master) Add another message
<commit-id-1> Send a message to the future

Le premier ID de commit listé est celui de "Add another message". Copiez cet ID de commit.

Maintenant, utilisons git branch --contains avec cet ID de commit. Remplacez <commit-id-2> par l'ID de commit réel que vous avez copié :

git branch --contains <commit-id-2>

La sortie devrait afficher la branche master, indiquant que ce commit se trouve sur la branche master :

* master

La commande git branch --contains <commit> est puissante car elle vous aide à retracer la lignée d'un commit. Si vous avez plusieurs branches, cette commande répertoriera toutes les branches qui incluent ce commit spécifique. Cela est essentiel pour comprendre comment les modifications circulent dans les différentes lignes de développement de votre projet.

Utiliser git log Branch pour vérifier

Dans l'étape précédente, nous avons utilisé git branch --contains pour voir quelles branches contiennent un commit spécifique. Maintenant, utilisons la commande git log avec le nom d'une branche pour vérifier l'historique de cette branche. Cela nous montrera tous les commits qui font partie de l'historique de cette branche.

Assurez-vous que vous êtes toujours dans le répertoire ~/project/my-time-machine :

cd ~/project/my-time-machine

Nous savons depuis l'étape précédente que notre dernier commit se trouve sur la branche master. Affichons le journal spécifiquement pour la branche master :

git log master --oneline

Vous devriez voir une sortie similaire à ceci, montrant les commits sur la branche master :

<commit-id-2> (HEAD -> master) Add another message
<commit-id-1> Send a message to the future

Cette sortie confirme que nos deux commits se trouvent bien sur la branche master. Utiliser git log <branch-name> est un excellent moyen d'inspecter l'historique d'une branche spécifique et de voir tous les commits accessibles depuis le sommet de cette branche.

Comparer la sortie de git branch --contains <commit> et de git log <branch-name> vous aide à comprendre la relation entre les commits et les branches. git branch --contains vous indique quelles branches incluent un commit quelque part dans leur historique, tandis que git log <branch-name> montre l'historique linéaire menant au sommet de cette branche spécifique.

Appuyez sur q pour quitter la vue du journal.

Vérifier plusieurs branches

Dans cette étape, nous allons créer une nouvelle branche et voir comment git branch --contains se comporte lorsqu'un commit est présent sur plusieurs branches. Cela illustrera davantage la puissance de cette commande pour comprendre la structure des branches de votre projet.

Tout d'abord, assurez-vous que vous êtes dans le répertoire ~/project/my-time-machine :

cd ~/project/my-time-machine

Maintenant, créons une nouvelle branche appelée feature-branch :

git branch feature-branch

Cette commande crée une nouvelle branche, mais ne vous bascule pas sur celle-ci. Vous êtes toujours sur la branche master.

Vérifions nos branches :

git branch

Vous devriez voir les deux branches listées, avec master en surbrillance (indiquant qu'il s'agit de la branche actuelle) :

* master
  feature-branch

Maintenant, récupérons à nouveau l'ID du commit de notre dernier commit en utilisant git log --oneline :

git log --oneline

La sortie sera similaire à celle précédente :

<commit-id-2> (HEAD -> master, feature-branch) Add another message
<commit-id-1> Send a message to the future

Remarquez que le dernier commit affiche maintenant à la fois HEAD -> master et feature-branch. Cela signifie que la branche feature-branch a été créée à ce commit.

Maintenant, utilisons à nouveau git branch --contains avec cet ID de commit. Remplacez <commit-id-2> par l'ID de commit réel :

git branch --contains <commit-id-2>

Cette fois, la sortie devrait afficher les deux branches, car le commit existe dans l'historique des branches master et feature-branch :

* master
  feature-branch

Cela démontre comment git branch --contains peut vous montrer toutes les branches qui ont un commit particulier dans leur historique. Cela est incroyablement utile pour suivre où les modifications ont été fusionnées ou intégrées à travers différentes lignes de développement.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un commit Git est présent dans une branche spécifique. Nous avons commencé par utiliser la commande git branch --contains <commit-id>, qui liste toutes les branches qui incluent le commit spécifié. C'est un outil fondamental pour comprendre l'historique et l'intégration des modifications dans un dépôt Git.

Ensuite, nous avons exploré comment vérifier la présence d'un commit dans une branche en utilisant git log <branch-name>. Cette commande affiche l'historique des commits d'une branche spécifique, nous permettant de confirmer visuellement si le commit cible fait partie de la lignée de cette branche. Enfin, nous avons vu comment étendre ces techniques pour vérifier la présence d'un commit sur plusieurs branches, offrant ainsi une vue complète de sa distribution au sein de la structure des branches du projet.