Accéder au contenu principal

Branche Git : Un guide pour créer, gérer et fusionner des branches

Maîtrisez la puissance des branches Git pour un développement plus fluide et une meilleure collaboration.
Actualisé 6 mai 2025  · 12 min de lecture

Si vous avez déjà travaillé sur un projet de codage en groupe, vous savez à quel point les choses peuvent rapidement devenir incontrôlables lorsque plusieurs personnes tentent de mettre à jour les fichiers dupliqués simultanément. Des conflits surgissent, des bogues se faufilent et les progrès s'arrêtent. C'est là qu'interviennent les branches Git, non pas comme une astuce avancée, mais comme la base d'un développement propre et parallèle.

Dans Git, les ramifications ne sont pas seulement encouragées, elles sont attendues. Qu'il s'agisse d'expérimenter une nouvelle fonctionnalité, de corriger un bogue ou de réviser le code de quelqu'un d'autre, les branches vous permettent de travailler sans marcher sur les plates-bandes de quelqu'un d'autre. Ils vous permettent de casser des choses, d'itérer, puis d'intégrer vos changements dans la base de code principale.

Ce guide vous présente l'essentiel des branchements dans Git. Nous commencerons par git branch et git checkout, puis nous examinerons de plus près la façon dont les branches sont créées, gérées, fusionnées et supprimées. Nous discuterons également des meilleures pratiques afin que vous puissiez maintenir votre flux de travail sans conflit. J'espère qu'à la fin de ce guide, vous aurez une meilleure compréhension au-delà de la mémorisation des commandes : Vous comprendrez mieux le déroulement du travail. Si tout cela vous intéresse et que vous souhaitez continuer à pratiquer, notre cours Introduction aux concepts de GitHub est un excellent point de départ.

Comprendre les branches Git

Maintenant que nous avons planté le décor, voyons ce qu'est une branche Git. À la base, une branche Git n'est pas un dossier séparé ni une copie complète de votre base de code ; il s'agit simplement d'un pointeur léger pour un commit particulier. C'est l'une des raisons pour lesquelles Git se distingue des systèmes de contrôle de version plus anciens : les branchements sont rapides, peu coûteux et essentiels aux flux de travail quotidiens.

Considérez une branche comme une ligne du temps. Lorsque vous créez une nouvelle branche, vous dites essentiellement : "Explorons un nouveau chemin à partir d'ici". Toutes vos modifications restent sur ce chemin jusqu'à ce que vous décidiez de les réintégrer ou non dans la ligne principale. Cette flexibilité facilite grandement l'expérimentation d'idées, la création de fonctionnalités isolées et la collaboration avec d'autres personnes sans interférer avec le code stable.

Git garde la trace de votre position actuelle dans le projet en utilisant une référence spéciale appelée HEAD. Lorsque vous changez de branche, HEAD pointe vers l'extrémité de la nouvelle branche. Ce détail en coulisse permet à Git de changer de contexte si rapidement, et c'est aussi ce qui fait que des commandes comme git checkout et git switch sont si transparentes une fois que vous comprenez ce qui se passe sous le capot.

En comprenant le fonctionnement des branches Git, vous pourrez organiser votre flux de développement avec clarté et confiance. Si vous suivez le cours et souhaitez tester ces concepts, le cours Git intermédiaire de DataCamp aborde le branchement avec de nombreuses pratiques guidées.

Lister et visualiser les branches Git

Vous avez donc créé des branches et commencé à les utiliser, mais comment garder une trace de tout ce que vous avez fait ? Heureusement, Git fournit des outils simples mais puissants pour lister, trier et filtrer les branches afin de ne jamais perdre de vue votre flux de travail.

Vérification de la branche courante

Pour commencer, vérifions quelles branches existent dans votre dépôt local et identifions celle sur laquelle vous vous trouvez actuellement.

git branch

Cette commande dresse la liste de toutes vos branches locales. Vous remarquerez un astérisque ( *) à côté de votre branche actuelle. Pour un look encore plus ciblé, essayez :

git branch --show-current

Cette fonction renvoie uniquement le nom de la branche dans laquelle vous travaillez, de manière claire et nette.

Vous voulez aussi voir les succursales éloignées ? Utiliser :

git branch -r

Et si vous souhaitez visualiser simultanément les branches locales et distantes :

git branch -a

Vous obtenez ainsi une image complète de la structure de ramification de votre projet, ce qui est particulièrement utile lorsque vous collaborez avec d'autres personnes sur des plateformes telles que GitHub. 

Trier et filtrer les branches

Au fur et à mesure que votre projet se développe, votre liste de branches s'allonge. Le tri et le filtrage vous permettent de gérer efficacement cette liste. Pour trier les branches en fonction de la date de livraison la plus récente, utilisez :

git branch --sort=-committerdate

Vous pouvez également effectuer un tri en fonction d'autres critères, tels que le nom de l'auteur, la date de création ou la configuration en amont. Voici un outil pratique pour filtrer les branches qui contiennent un commit spécifique :

git branch --contains <commit>

Cela vous montre quelles branches ont déjà inclus un commit donné, ce qui permet de vérifier si une correction de bogue ou une fonctionnalité a été fusionnée dans ces branches. Inversement, la commande ci-dessous vous montre quelles branches n'ont pas encore récupéré ce commit :

git branch --no-contains <commit>

La gestion efficace des succursales implique de les créer et d'en assurer la visibilité et le contrôle. Ces commandes permettent de maintenir votre développement propre, organisé et efficace.

Vous voulez savoir comment ces éléments sont liés à la collaboration ? Le cours sur les fondements de Git constitue une excellente base et couvre des flux de travail réels que vous utiliserez à maintes reprises.

Créer une nouvelle branche Git

Maintenant que vous savez comment lister les branches et passer de l'une à l'autre, voyons comment les créer. La création de branches est une partie essentielle du flux de travail de Git, et heureusement, la création de nouvelles branches est simple, que vous mettiez en place une branche de fonctionnalités, un correctif, ou que vous expérimentiez quelque chose d'entièrement nouveau.

Création d'une branche sans commutation

Parfois, vous souhaitez créer une branche sans vous y engager immédiatement. Cette fonction est utile lorsque vous préparez plusieurs branches à la fois ou lorsque vous mettez en place des flux de travail pour d'autres personnes.

git branch new-feature

Cette commande crée une branche nommée new-feature, mais vous serez toujours sur votre branche actuelle. Vous pourrez y revenir plus tard, lorsque vous serez prêt à travailler dessus.

Créer et basculer vers une branche simultanément

Si vous vous lancez directement dans le développement, vous pouvez créer et passer à la nouvelle branche en une seule fois. Dans les anciennes versions de Git, vous utiliseriez :

git checkout -b new-feature

Cependant, dans le système Git moderne, l'approche la plus transparente et la plus intuitive est la suivante :

git switch -c new-feature

Cette opération permet non seulement de créer la branche, mais aussi de l'extraire immédiatement, afin que vous puissiez commencer à travailler.

Mise en place de branches en amont

Lorsque vous travaillez avec des dépôts distants, vous souhaitez souvent que votre branche locale suive une branche distante. Cela simplifie l'envoi et la réception des mises à jour. Pour créer une branche qui cursus une branche distante dès le départ, utilisez :

git branch --track new-feature origin/new-feature

Si vous avez déjà créé la branche et que vous souhaitez définir ou modifier l'amont, cette commande fait l'affaire :

git branch --set-upstream-to=origin/new-feature

Cette configuration garantit que votre branche locale sait de quelle branche distante elle doit tirer ou pousser, afin que votre flux de travail reste fluide et connecté.

Passer d'une branche à l'autre dans Git

Une fois que vous avez créé plusieurs branches, vous devrez souvent passer de l'une à l'autre, que ce soit pour revenir à main afin de fusionner un correctif ou pour passer à une branche de fonctionnalités afin de continuer à coder. Git rend ce processus transparent et, comme la plupart des choses liées à Git, il y a plus d'une façon de le faire.

Utilisation de git checkout

Pendant longtemps, git checkout a été la commande de référence pour changer de branche :

git checkout feature-login

Cette commande fait basculer votre répertoire de travail vers la branche feature-login, mettant à jour tous vos fichiers pour refléter l'instantané de cette branche. Il est fiable et encore largement utilisé. Mais voilà : git checkout fait beaucoup de choses. Il permet de changer de branche, de restaurer des fichiers et même de vérifier des commits. Cela peut être déroutant, surtout si vous débutez.

Utilisation du commutateur git

Pour rendre les choses plus intuitives, Git a introduit the git switch dans la version 2.23 :

git switch feature-login

Cette opération fait exactement ce que vous attendez d'elle : elle intervertit les branches. Il ne touche pas à votre arborescence de travail et ne réinitialise pas vos fichiers, sauf si vous le lui demandez. C'est plus simple, plus sûr, plus facile à enseigner et à mémoriser.

Alors, quand devriez-vous utiliser quoi ?

  • Utilisez git switch pour passer d'une branche à l'autre : c'est clair et bien conçu.
  • Utilisez git checkout si vous avez besoin de restaurer des fichiers ou de consulter un commit spécifique.

Fusionner des branches Git

Vous avez donc travaillé sur une fonctionnalité dans une branche distincte. Vient alors le moment de vérité : combiner vos modifications dans la branche principale. Dans Git, ce processus est appelé merging. En fonction de l'historique de vos branches, il y a plusieurs façons de l'aborder.

Fusion en avance rapide

Supposons que votre site feature branch ait été créé à partir de the main et que, pendant que vous y travailliez, personne d'autre n'ait touché au site main. Dans ce cas, Git n'a pas besoin de réfléchir beaucoup. Il déplace simplement le pointeur main vers le dernier commit dans feature-branch.

git checkout main
git merge feature-branch

Aucun nouveau commit n'est créé - Git avance rapidement main. Propre et simple, il est parfait pour les projets individuels ou les branches éphémères.

Fusion à trois

Les choses deviennent plus intéressantes lorsque les deux branches ont progressé indépendamment l'une de l'autre. Votre coéquipier a peut-être apporté des modifications à la pageprincipale pendant que vous codiez dans the feature branch. Maintenant, Git doit examiner trois instantanés : l'ancêtre commun, votre branche et la branche cible.

git checkout main
git merge feature-branch

Dans ce cas, Git crée un nouveau commit de fusion pour combiner les deux branches. S'il y a des conflits, par exemple si vous et votre coéquipier avez modifié la même ligne dans le même fichier, Git vous demandera de les résoudre manuellement. Vous modifierez le fichier, le marquerez comme résolu, puis validerez la fusion.

git add .
git commit

Si cela vous semble un peu intimidant, consultez notre Git Merge Tutorial : Un guide complet avec des exemples est un excellent guide qui couvre tous les points essentiels, y compris la gestion des conflits avec élégance.

Rebaser au lieu de fusionner

Vous n'êtes pas fan des commits de fusion qui encombrent votre historique ? Vous n'êtes pas seul. C'est là que Git rebase entre en jeu. Au lieu de créer un nouveau commit de fusion, rebase reproduit vos modifications sur une autre branche, ce qui permet d'obtenir un historique plus propre et linéaire.

git checkout feature-branch
git rebase main

Ainsi, lorsque vous fusionnez, Git voit une ligne droite - il n'y a pas besoin d'un commit de fusion. Toutefois, il convient de l'utiliser avec prudence, en particulier lorsque vous travaillez avec des branches partagées. Il peut être dangereux de réécrire l'histoire si d'autres personnes travaillent sur le même code.

Pour savoir quand il est préférable d'utiliser le merge ou le rebase (et comment rebaser en toute sécurité), le cours Intermédiaire Git vous offre des conseils pratiques et concrets.

Suppression des branches Git

Après une fusion réussie, il est conseillé de nettoyer les branches dont vous n'avez plus besoin, à la fois localement et à distance. Votre espace de travail reste ainsi bien rangé et votre historique Git est plus facile à parcourir. Voyons comment y parvenir sans perdre le sommeil à cause de la suppression accidentelle de quelque chose d'important.

Suppression de succursales locales

Lorsqu'une branche a été fusionnée et que son travail est terminé, vous pouvez la supprimer en toute sécurité de votre dépôt local :

git branch -d feature-branch

Le drapeau-d signifie "supprimer". Git vérifiera que la branche a déjà été fusionnée afin d'éviter toute perte de données.

Mais que se passe-t-il si vous souhaitez supprimer une branche, même si elle est fusionnée ? C'est là qu' intervient la majuscule -D :

git branch -D feature-branch

Cela force la suppression, même si Git vous avertit que la branche n'a pas été fusionnée. Avant d'appuyer sur la touche "Entrée", assurez-vous que vous n'avez pas besoin de ces modifications.

Vous souhaitez approfondir la gestion de votre espace de travail local et de vos succursales ? Consultez notre site Git Pull Force : Comment écraser une branche locale avec une branche distante tutoriel. Il s'agit d'un compagnon utile qui vous permet de vous assurer que vous ne vous contentez pas de supprimer des branches, mais que vous les gérez en toute sécurité.

Suppression des branches distantes

Le nettoyage local ne représente que la moitié du travail. Si la branche se trouve également sur un serveur distant (comme GitHub), vous voudrez la supprimer là aussi, surtout si vous avez terminé la fonctionnalité ou la correction de bogue.

git push origin --delete feature-branch

Cette commande demande à Git de supprimer la branche de l'origine remote. Elle est nette et directe, ce qui permet d'éviter que votre télécommande ne soit encombrée de branches inutilisées.

Une fois que vous avez supprimé les branches distantes, il est également judicieux de nettoyer vos références de suivi locales.

git fetch -p

Le site -p signifie "pruneau". Il supprime toutes les branches de suivi à distance périmées qui n'existent plus sur le serveur.

Pour plus d'informations sur les habitudes d'hygiène de Git, le Git Push and Pull Tutorial et le Complete Git Cheat Sheet sont des références rapides parfaites.

Pousser et tirer des branches Git

Une fois que vous avez créé et organisé vos branches localement, l'étape suivante consiste à les synchroniser avec le dépôt distant. C'est essentiel pour la collaboration et la sauvegarde. Voyons comment pousser, tirer et curseurer les branches de manière efficace.

Pousser une nouvelle branche sur le serveur distant

Vous avez créé une nouvelle fonctionnalité localement et l'avez testée. Vous souhaitez maintenant la partager avec votre équipe ou la sauvegarder. Pour pousser une nouvelle branche vers un dépôt distant (typiquement nommé origin), utilisez :

git push -u origin new-feature

Le drapeau -u (abréviation de --set-upstream) indique à Git de se souvenir de la branche distante pour les prochaines extractions et extractions. Ainsi, la prochaine fois, vous pourrez lancer git pull ou git push sans spécifier la branche.

Si vous vous demandez ce qui se passe en coulisses lors d'un push ou d'un pull, notre tutoriel Git Push and Pull l'explique à l'aide d'exemples que vous pouvez suivre.

Récupérer les modifications d'une branche distante

Supposons que quelqu'un d'autre ait mis à jour la branche sur laquelle vous travaillez. Vous voudrez tirer ces modifications vers le bas pour rester synchronisé :

Git pull origin new-feature

Cela permet de récupérer les derniers commits du serveur distant et de les fusionner dans votre branche locale. Si vous voulez éviter de fusionner des commits, vous pouvez utiliser la méthode suivante :

git pull --rebase origin new-feature

Comme l'explique la section sur la fusion, --rebase vous permet de conserver un historique des livraisons propre.

Le cursus d'une branche distante

Lorsque vous souhaitez commencer à travailler avec une branche qui existe déjà sur le serveur distant, la façon la plus simple de procéder est la suivante :

git checkout --track origin/feature-xyz

Cette commande vérifie la branche distante et met automatiquement en place un suivi, de sorte que les futurs pulls et pushes sont un jeu d'enfant.

Problèmes courants et dépannage

Même avec les meilleurs flux de travail, les choses ne se passent pas toujours bien. Qu'il s'agisse d'un conflit de fusion, d'une branche accidentellement supprimée ou de modifications non validées, Git dispose d'outils pour vous aider à récupérer. Examinons quelques-uns des problèmes de branchement les plus courants et la manière de les résoudre.

Gestion des conflits de fusion

Vous venez d'essayer de fusionner une branche, et Git lance un conflit de fusion. Cela se produit lorsque deux branches modifient différemment la même partie d'un fichier, et que Git n'arrive pas à décider quelle modification conserver.

Voici comment vous y prendre :

git status

Cela vous permet de savoir quels sont les fichiers en conflit. Ensuite, vous pouvez utiliser :

git diff

Pour savoir quelle est la cause du problème. À partir de là, ouvrez manuellement le(s) fichier(s) conflictuel(s), résolvez les différences, puis

git add <resolved-file>
git commit

Si vous souhaitez en savoir plus sur la fusion des flux de travail et la résolution des conflits, consultez le didacticiel Git Merge, qui propose une présentation complète.

Récupération des branches supprimées

Vous avez accidentellement supprimé une branche et vous sentez la panique vous envahir ? Ne vous inquiétez pas, ce n'est pas perdu pour toujours si vous agissez rapidement.

Vous pouvez le récupérer en utilisant git reflog, qui enregistre vos positions HEAD récentes :

git reflog

Trouvez le hash du commit avant que vous ne supprimiez la branche, puis recréez-la avec :

git checkout -b your-branch-name <commit-hash>

Et comme ça, votre branche est de retour. Vous voulez mieux comprendre comment Git suit ces références ? Notre guide Git Reflog l'explique à l'aide d'exemples concrets.

Stocker les changements avant de changer de fournisseur

Parfois, vous souhaitez changer de branche, mais vous avez des modifications non validées. Git ne vous laissera pas changer si cela risque de vous faire perdre du travail. C'est là que git stash entre en jeu.

git stash

Et Git mettra temporairement de côté vos modifications. Après avoir changé de branche, vous pouvez les ramener avec :

git stash pop

Cela est particulièrement utile lorsque vous passez d'une fonctionnalité à l'autre ou d'un correctif à l'autre.

Si vous gérez beaucoup de changements ou si vous nettoyez votre répertoire de travail, vous pourriez également être intéressé par Git Clean : Supprimez les fichiers non suivis et maintenez les dépôts en ordre.

Stratégies avancées de ramification

Vous savez maintenant comment créer, changer et gérer des branches Git en toute simplicité. Mais comment les équipes utilisent-elles ces branches dans des projets réels ? La réponse réside dans le choix de la bonne stratégie de branchement, c'est-à-dire une structure permettant de déterminer quand et comment utiliser les branches dans votre flux de développement. Examinons quelques-unes des approches les plus populaires.

Flux de travail des branches de fonctionnalités

Le flux de travail par branche est l'une des stratégies les plus courantes, en particulier dans les projets collaboratifs. Voici comment cela fonctionne :

Chaque nouvelle fonctionnalité obtient sa propre branche, créée à partir de la branche principale (ou develop). Cela permet aux développeurs de travailler de manière indépendante sans affecter le code prêt à la production.

git switch -c feature/login-page

Une fois la fonctionnalité terminée et testée, elle est réintégrée dans la branche principale (ou une branche de préparation) par le biais d'une demande d'extraction.

Ce modèle permet d'isoler le travail, de rendre les revues de code plus faciles à gérer et d'éviter d'encombrer votre branche principale avec des fonctionnalités à moitié terminées. Pour que la collaboration à distance se déroule sans heurts, n'oubliez pas de pousser vos branches :

git push -u origin feature/login-page

Avez-vous besoin de rafraîchir vos connaissances sur la poussée et la traction des branches ? Le tutoriel Git Push and Pull vous guide tout au long du processus.

Flux de travail GitFlow

Si vous travaillez sur un projet avec des versions régulières, GitFlow peut vous convenir. Ce flux de travail introduit des rôles structurés pour différents types de branches :

  • main: contient toujours du code prêt à la production.

  • develop: branche d'intégration pour les fonctionnalités.

  • feature/*: branches éphémères pour les nouvelles fonctionnalités.

  • release/*: branches de pré-production pour les tests.

  • hotfix/*: Les solutions rapides sont basées sur le site main.

Voici un exemple rapide de création d'une nouvelle branche de fonctionnalité à l'aide des outils GitFlow :

git flow feature start payment integration

Cette stratégie ajoute un peu de complexité, mais elle est particulièrement efficace dans les grandes équipes où une structure claire et la stabilité sont des priorités. Si vous souhaitez explorer les flux de travail au-delà de GitHub, consultez What GitLab Is : Features, Benefits, and How to Get Started pour un autre point de vue sur les pratiques structurées de Git.

Développement basé sur un tronc

Préférez-vous un minimum de ramifications et une livraison rapide ? Le développement par troncs d'arbre est peut-être votre style. Dans cette stratégie, tous les développeurs s'engagent sur une seule branche, généralement la main, avec de petites et fréquentes modifications. Au lieu de branches à long terme, cette approche encourage les branches à court terme ou les modifications directes de la branche main.

C'est rapide et simple, mais cela demande de la discipline, une bonne automatisation des tests et une bonne communication. Ce modèle est standard dans les startups et les équipes pratiquant le DevOps ou le CI/CD. Le choix d'une stratégie de ramification dépend de la taille de votre équipe et de la cadence de publication, ainsi que, bien sûr, du niveau de collaboration.

Conclusion

Les branches sont au cœur du système de contrôle de version de Git. Ils permettent aux développeurs de travailler sur de nouvelles fonctionnalités, des corrections de bogues et des expériences de manière isolée, sans perturber la base de code principale. Cette flexibilité permet de mieux organiser les flux de travail et d'améliorer la collaboration au sein de l'équipe.

En effectuant des transferts fréquents, en fusionnant de manière responsable et en maintenant une structure de branches propre, vous réduisez le risque de conflits et rendez votre base de code plus facile à naviguer et à maintenir. Il ne fait aucun doute que la maîtrise des branches Git vous permet de produire de meilleurs logiciels au fil du temps.


Oluseye Jeremiah's photo
Author
Oluseye Jeremiah
LinkedIn

Rédacteur technique spécialisé dans l'IA, la ML et la science des données, rendant les idées complexes claires et accessibles.

Apprenez les bases de Git dès aujourd'hui

Pour les débutants : Maîtriser le contrôle des versions à l'aide de Git.
Commencez à apprendre gratuitement
Sujets

Apprenez Git avec DataCamp

Cursus

GitHub Foundations

10 hr
Prepare for the GitHub Foundations Certification by learning the fundamentals of Git and GitHub: version control, collaboration, and branching.
Afficher les détailsRight Arrow
Commencer le cours
Voir plusRight Arrow