Cursus
Branche Git : Un guide pour créer, gérer et fusionner des branches
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 sitemain
.
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.
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
Apprenez Git avec DataCamp
Cursus
Git Fundamentals
Cours