Branches de la liste Git : Un guide pratique

Si vous avez déjà travaillé sur plusieurs fonctionnalités simultanément, cette situation vous est peut-être familière : vous exécutez une commande Git et vous ne savez plus où se trouve votre travail de la semaine dernière.

Ce problème devient plus fréquent à mesure que les projets prennent de l'ampleur. Au début, un référentiel peut ne disposer que d'une branche d'main. Cependant, au fil du temps, les équipes créent des branches pour les nouvelles fonctionnalités, les corrections de bogues, les expérimentations, les versions et les correctifs d'urgence. 

C'est là que la liste des branches dans Git devient essentielle. Il aide à répondre à des questions pratiques :

• Sur quelle branche est-ce que je travaille actuellement ?
• Quelles autres branches sont présentes sur mon ordinateur ?
• Quelles branches sont présentes sur le dépôt distant ?

Dans ce guide, nous examinerons les principes fondamentaux de la création de branches dans Git, comment procéder et comment résoudre les problèmes courants.

Si vous débutez avec Git, je vous recommande de suivre notre cours Introduction à Git afin de vous familiariser avec cet outil avant d'aborder des sujets plus avancés liés à la gestion des branches.

Comprendre les branches Git

Avant de commencer à les énumérer, examinons ce que sont les branches Git. 

Une idée fausse courante consiste à croire que les branches Git sont des dossiers distincts ou des copies complètes d'une base de code, mais en réalité, une branche Git n'est qu'un pointeur léger vers un commit spécifique.

Vous pouvez le considérer comme une chronologie parallèle où vous pouvez développer des fonctionnalités ou mener des expériences de manière isolée sans affecter votre code principal stable. Cette architecture rend la création et la fusion de branches extrêmement rapides et efficaces.

Source : Git

Git suit votre position actuelle dans ces chronologies à l'aide d'une référence spéciale appelée HEAD, qui pointe toujours vers la branche sur laquelle vous travaillez actuellement. Étant donné que les branches ne sont que des pointeurs, le changement de contexte est instantané et ne nécessite pas le déplacement de fichiers volumineux.

Pour plus de détails, veuillez consulter notre tutoriel sur les branches Git ou notre aide-mémoire Git.

Comment répertorier les branches locales dans Git

Une fois ces bases conceptuelles établies, examinons comment répertorier les branches locales dans votre référentiel.

Une branche locale est une branche qui existe sur votre ordinateur. Il se trouve dans le dossier .git de votre référentiel et représente un pointeur mobile vers une série de commits. Vous pouvez basculer vers une branche locale, apporter des modifications et créer de nouveaux commits sur celle-ci.

Il est utile de considérer les succursales locales de la manière suivante :

• Ils font partie de votre copie du référentiel.
• Ils avancent lorsque vous validez de nouvelles modifications.
• Ils ne se mettent pas automatiquement à jour lorsque d'autres personnes publient du code.

Utilisation de git branch

La commande la plus courante et fondamentale pour lister les branches locales est très simple :

git branch

Lorsque vous exécutez cette commande sans aucune option supplémentaire, Git affiche toutes les branches locales.

Points importants à retenir concernant git branch:

• Il n'affiche que les branches locales, et non les branches distantes.
• Il ne se connecte pas à Internet.
• Cela ne modifie pas les fichiers, les commits ou l'historique des branches.

En raison de sa sécurité et de sa rapidité, de nombreux développeurs ont l'habitude d'exécuter git branch avant de commencer un nouveau travail ou de changer de contexte.

Comprendre le résultat

Voici un exemple de ce que pourrait afficher git branch:

 bugfix/login-timeout
  feature/payment-refactor
* main

Bien que ce résultat semble simple, il comporte quelques détails importants.

Tout d'abord, l'astérisque (*) indique la branche actuellement extraite. Il s'agit de la branche à laquelle votre répertoire de travail est actuellement associé. Tout nouveau commit que vous créez sera ajouté à cette branche.

Deuxièmement, Git met généralement en évidence la branche actuelle en vert. Il s'agit simplement d'une aide visuelle fournie par le terminal qui ne modifie en rien le comportement de Git.

Troisièmement, veuillez noter ce qui n'est pas affiché :

• Aucune date de validation
• Aucun nom d'auteur
• Aucune information à distance

Ceci est intentionnel. Git conserve une sortie par défaut concise, ce qui facilite la lecture et la combinaison avec d'autres commandes.

Conseil pour les débutants : Si votre terminal semble « bloqué » après avoir exécuté une commande Git, veuillez essayer d'appuyer sur la touche q. Git utilise fréquemment un pager pour afficher les sorties longues, et il s'agit d'une méthode courante pour le quitter.

Obtenir uniquement la branche actuelle

Il n'est pas toujours nécessaire de lister toutes les branches. Il se peut que vous souhaitiez simplement savoir sur quelle branche vous vous trouvez actuellement. Git fournit une commande dédiée à cet effet :

git branch --show-current

La sortie correspond simplement au nom de la branche :

main

Les situations courantes où cela peut être utile comprennent :

• Vérification de votre branche avant de pousser le code
• Enregistrement du nom de la branche dans les scripts
• Utilisation du nom de la branche dans l'automatisation ou les pipelines CI

Si Git est dans un état HEAD détaché, cette commande ne renvoie aucune information. Bien que cela puisse paraître inhabituel au premier abord, cela s'avère utile lors de la rédaction de scripts qui doivent détecter si une branche est extraite.

Erreur fréquente : Certains utilisateurs considèrent que Git est « défectueux » lorsqu'aucun nom de branche n'apparaît. Dans la plupart des cas, cela signifie simplement que vous n'êtes pas actuellement sur une branche, mais sur un commit spécifique.

Comment répertorier les branches distantes et toutes les branches dans Git

La liste des branches distantes ou même de toutes les branches dans Git fonctionne de manière très similaire à la liste des branches locales.

Répertorier les branches distantes dans Git

Les référentiels distants, tels que ceux sur GitHub ou GitLab, possèdent leurs propres branches. Pour les visualiser, veuillez ajouter l'indicateur d'-r:

git branch -r

  origin/HEAD -> origin/main
  origin/bugfix/login-timeout
  origin/feature/payment-refactor
  origin/main

Cet exemple de résultat peut sembler déroutant au premier abord, nous allons donc l'analyser.

Ce que vous voyez ici sont des branches de suivi à distance. Il s'agit de références locales que Git utilise pour mémoriser le dernier état connu du dépôt distant.

Points clés à comprendre :

• Ces branches sont stockées localement.
• Ils ne sont mis à jour que lorsque vous récupérez les données.
• Ils ne se déplacent pas automatiquement.

Conseil pour les débutants : Considérez les branches de suivi à distance comme le carnet de notes de Git. Git enregistre l'état du serveur distant lors de votre dernière vérification, mais il ne mettra pas à jour ce carnet de notes à moins que vous ne le récupériez explicitement.

Affichage de toutes les branches dans Git

Pour afficher à la fois les branches locales et les branches suivies à distance, veuillez utiliser l'indicateur ` -a ` :

git branch -a

* main
  feature/payment-refactor
  remotes/origin/bugfix/login-timeout
  remotes/origin/main

Cette vue combinée vous aide à comprendre comment vos succursales locales sont liées aux succursales distantes.

Modèles de dénomination à surveiller :

• Les succursales locales apparaissent sous forme de noms simples tels que main

• Les branches suivies à distance apparaissent sous remotes/origin/

Cette vue est particulièrement utile pour déterminer s'il convient de créer une nouvelle branche locale qui suit une branche distante existante.

Veuillez toujours récupérer en premier lieu.

Si un collègue publie une nouvelle branche et que vous ne pouvez pas la visualiser, la raison la plus courante est que votre cache local est obsolète. 

La solution consiste à récupérer:

git fetch

Ce que fait git fetch:

• Télécharge les dernières informations sur les branches à partir du serveur distant.
• Mise à jour de vos branches de suivi à distance
• Laisse vos fichiers de travail inchangés

Cette commande peut être exécutée en toute sécurité à tout moment. Il ne fusionne pas le code et ne remplace pas votre travail. De nombreuses équipes considèrent l'exécution de ` git fetch ` comme une étape de routine avant d'inspecter les branches.

Erreur fréquente : Les débutants confondent souvent l'git fetch e avec l'git pull e. La commande fetch récupère uniquement les informations de mise à jour de la branche, tandis que la commande pull fusionne également les modifications dans votre branche actuelle.

Comment obtenir plus de détails sur votre liste de branches Git

Parfois, les noms des branches ne suffisent pas. Si vous souhaitez obtenir des informations supplémentaires, il existe quelques indicateurs utiles qui peuvent vous aider.

Affichage des derniers commits

Pour visualiser le contenu de chaque branche, veuillez utiliser :

git branch -v

Le résultat pourrait ressembler à ceci :

* main   a1b2c3d Fix typo in README
  feature/payment-refactor e4f5g6h Refactor payment service

Comme vous pouvez le constater, l'indicateur d'-v s apporte un contexte important :

• Le hachage de validation court indique où pointe actuellement la branche.
• Le message de validation indique l'objectif de la branche.

C'est l'un des moyens les plus simples de comprendre à quoi sert une branche sans avoir à l'examiner.

Conseil pour les débutants : Si vous n'êtes pas certain qu'une branche puisse être supprimée en toute sécurité, vérifier son dernier message de validation constitue un bon premier indice.

Vérification des connexions en amont

Les branches locales suivent souvent une branche distante correspondante. Pour visualiser cette relation, veuillez exécuter :

git branch -vv

* main   a1b2c3d [origin/main] Fix typo in README
  feature/payment-refactor e4f5g6h [origin/feature/payment-refactor] Refactor payment service

Cette sortie vous indique :

• À quelle branche distante votre branche locale est-elle liée ?

• D'où proviennent les informations sur git pull

• Où git push s'efforcera de

Si une branche n'a pas de source, elle n'affichera rien entre parenthèses. Cela explique souvent les erreurs de poussée ou de traction.

Erreur fréquente : Tenter d'exécuter git pull sur une branche sans amont échouera généralement. Dans ce cas, il est nécessaire de définir d'abord une branche en amont ou de pousser la branche pour la première fois.

Trier les branches par date ou par version

Pour identifier les branches récemment actives, il est possible de trier par date de validation :

git branch --sort=-committerdate

Cela place les branches les plus récemment mises à jour en haut et les branches plus anciennes en bas.

Pour les référentiels comportant des branches versionnées, le tri sémantique est plus utile :

git branch --sort=v:refname

Cela respecte les numéros de version et évite toute confusion liée à l'ordre alphabétique.

Comment filtrer la liste des branches dans Git

Si vous recherchez une branche spécifique, le filtrage peut s'avérer très utile. Je vais vous expliquer comment procéder à l'aide de quelques indicateurs importants.

Recherche par modèle de nom

Dans les référentiels de grande taille notamment, le filtrage par nom peut vous faire gagner beaucoup de temps dans la recherche de la branche appropriée. Vous pouvez filtrer par nom en utilisant le drapeau --list avec votre terme de recherche :

git branch --list 'feature/*'

Veuillez noter comment l'* est utilisé comme caractère générique : Le résultat affiche uniquement les branches qui correspondent au modèle, c'est-à-dire celles qui commencent par feature. Les équipes utilisent souvent des préfixes tels que feature/, bugfix/ ou hotfix/ pour organiser leurs données. Considérez-les comme des dossiers pour vos branches.

Recherche de branches fusionnées et non fusionnées

Deux filtres particulièrement importants sont :

git branch --merged
git branch --no-merged

Ces commandes comparent d'autres branches à votre branche actuelle.

• --merged affiche les branches dont le travail est déjà inclus

• --no-merged affiche les branches qui contiennent encore des commits uniques

Rappel de sécurité : Veuillez toujours vérifier que vous êtes sur la branche de base appropriée (souvent main ou develop) avant d'utiliser --merged. Les résultats dépendent de votre branche actuelle.

Identifier la branche contenant un commit

Si vous connaissez un hachage de commit et souhaitez déterminer où il se trouve, veuillez utiliser cette commande :

git branch --contains <commit-hash>

Ceci est utile pour suivre les bogues ou vérifier qu'un correctif a bien été fusionné.

Par exemple, lorsqu'un collègue vous dit ceci : J'ai identifié un bug dans ce hachage de commit ; quelles branches sont concernées par ce bug ? Vous pouvez utiliser cette commande pour localiser précisément l'emplacement exact du bogue.

Combiner des filtres pour des flux de travail avancés

Les filtres que je vous ai présentés peuvent être combinés pour affiner davantage les résultats. Veuillez considérer l'exemple suivant :

git branch --list 'feature/*' --no-merged

Cette commande affiche rapidement toutes les branches d'feature/ s non fusionnées et aide l'équipe à rester organisée.

Dépannage des problèmes courants

Si vous rencontrez des difficultés, ne vous inquiétez pas ; les problèmes les plus courants sont généralement faciles à résoudre.

Branches distantes manquantes

Si vous ne parvenez pas à visualiser une branche que quelqu'un d'autre a poussée, la raison la plus probable est que vous avez simplement omis de la récupérer. Pour résoudre le problème :

1. Exécuter git fetch

2. Veuillez ensuite énumérer à nouveau les branches.

Si le problème provenait d'une récupération manquante, cette solution rapide met immédiatement à jour votre vue locale.

L'état HEAD détaché

Parfois, la sortie de l'git branch e ressemble à ceci :

* (HEAD detached at a1b2c3d)

Cela signifie que vous n'êtes pas sur une branche. Vous visualisez directement un commit spécifique.

Être dans un état HEAD détaché n'est pas dangereux en soi, mais toute nouvelle validation que vous effectuez peut être difficile à retrouver par la suite, à moins que vous ne créiez une branche.

Pour revenir au travail normal, veuillez utiliser checkout pour créer une nouvelle branche :

git checkout <branch-name>

Vous pouvez également créer une nouvelle branche à partir de votre position actuelle en utilisant l'indicateur d'-b:

git checkout -b <new-branch-name>

Les branches apparaissent toujours après leur suppression.

Si les branches distantes apparaissent toujours après leur suppression sur le serveur, vous pouvez supprimer leur référence locale à l'aide de la commande suivante :

git remote prune origin

Cela permet de supprimer les références obsolètes et de maintenir votre référentiel bien organisé.

Conseil de professionnel : En alternative, vous pouvez également utiliser git fetch --prune à chaque fois que vous effectuez une récupération, afin que le dépôt soit mis à jour et nettoyé en une seule étape.

Conclusion

Répertorier les branches dans Git est une compétence essentielle qui vous aide à mieux comprendre votre référentiel. Les commandes et les indicateurs abordés dans ce tutoriel vous aideront à éviter les erreurs et à collaborer en toute confiance avec d'autres personnes. 

Lorsque vous démarrez un nouveau projet, il est généralement utile de réfléchir au type de structure de branches dont vous aurez besoin. Pour obtenir des conseils, veuillez consulter ce guide sur la stratégie de branchement Git.

Êtes-vous prêt à aller au-delà des bases ? Le cursus « Git Fundamentals » (Principes fondamentaux de Git) de l' propose les concepts et l'expérience pratique nécessaires pour passer du niveau débutant à celui de professionnel.