Branches dans Git : travailler en parallèle sans conflits

Que sont les branches et pourquoi en a-t-on besoin

Une branche dans Git est une ligne de développement indépendante. Techniquement, une branche n'est qu'un pointeur vers un commit spécifique. Cela rend la création de branches incroyablement rapide et légère.

Principaux scénarios d'utilisation des branches :

• Développement de nouvelles fonctionnalités isolées du code principal

• Correction de bogues sans affecter le développement actuel

• Expérimenter avec du code sans risque de casser quelque chose

• Travail parallèle de plusieurs développeurs sur différentes tâches

  

Opérations de base avec les branches

Création d'une nouvelle branche

Vous pouvez créer une branche avec la commande :

git branch feature-auth

Cette commande crée une nouvelle branche, mais ne bascule pas vers elle. Pour créer une branche et basculer immédiatement vers elle, utilisez :

git checkout -b feature-auth

Ou dans une syntaxe plus moderne :

git switch -c feature-auth

Basculer entre les branches

Pour basculer vers une branche existante, utilisez :

git checkout main

Ou :

git switch main

La commande git switch est apparue dans Git 2.23 et a été créée spécifiquement pour changer de branche, rendant la syntaxe plus compréhensible. git checkout effectue de nombreuses opérations différentes, ce qui est parfois déroutant.

Afficher la liste des branches

Pour voir toutes les branches locales :

git branch

La branche actuelle sera marquée d'un astérisque. Pour afficher toutes les branches, y compris celles supprimées :

git branch -a

Commande utile pour afficher les branches avec des informations supplémentaires :

git branch -v

Elle affichera le dernier commit dans chaque branche.

Fusion des branches

Une fois que vous avez terminé de travailler sur la fonction dans une branche séparée, elle doit être fusionnée dans la branche principale. Pour ce faire, utilisez la commande git merge.

Fast-forward merge

Le cas le plus simple est celui où il n'y a pas eu de nouveaux commits dans la branche principale après la création de votre branche de fonctionnalité :

git checkout main
git merge feature-auth

Dans ce cas, Git déplacera simplement le pointeur de la branche main vers l'avant. C'est ce qu'on appelle une fusion fast-forward.

Three-way merge

Si de nouveaux commits apparaissent dans la branche principale après la création de la branche de fonctionnalité, Git créera un commit de fusion qui combine les modifications des deux branches :

git checkout main
git merge feature-user-profile

Git créera automatiquement une validation de fusion avec un message tel que « Merge branch 'feature-user-profile' ».

Résolution des conflits

Les conflits surviennent lorsque les mêmes lignes dans les fichiers sont modifiées dans différentes branches. Git ne peut pas décider automatiquement quelles modifications conserver et vous demande de l'aide.

En cas de conflit, Git marquera les zones problématiques dans les fichiers :

<<<<<<< HEAD
const apiUrl = 'https://api.example.com/v1';
=======
const apiUrl = 'https://api.newdomain.com/v2';
>>>>>>> feature-api-update

Le bloc entre <<<<<<< HEAD et ======= contient les modifications de la branche actuelle, et le bloc entre ======= et >>>>>>> feature-api-update — les modifications de la branche fusionnée.

Pour résoudre le conflit :

1. Ouvrez le fichier et sélectionnez les modifications souhaitées en supprimant les marqueurs de conflit

2. Enregistrez le fichier

3. Ajouter un fichier à la staging area : git add filename.js

4. Terminez la fusion : git commit

De nombreux IDE et éditeurs de code ont des outils intégrés pour la résolution visuelle des conflits, ce qui simplifie considérablement le processus.

Rebase : une alternative à merge

En plus de merge, il existe une autre façon d'intégrer les changements — rebase. Il déplace votre branche vers le haut d'une autre branche, en réécrivant l'historique des validations.

git checkout feature-payment
git rebase main

Cette commande prendra tous les commits de feature-payment et les appliquera au-dessus du dernier commit dans main.

Différences entre merge et rebase

Merge enregistre l'historique complet et crée une validation de fusion supplémentaire. L'histoire est non linéaire, mais reflète le processus de développement réel.

Rebase crée une histoire linéaire en réécrivant les commits. Cela rend l'histoire plus propre et plus facile à comprendre, mais les informations sur le moment exact où les branches existaient en parallèle sont perdues.

Règle importante : ne faites jamais de rebase des branches publiques avec lesquelles d'autres développeurs travaillent. Cela réécrit l'histoire et créera des problèmes pour toute l'équipe.

Stratégies de travail avec les branches

Git Flow

Modèle de ramification populaire proposé par Vincent Driessen. Branches principales :

• main — code de production stable

• develop — branche d'intégration pour le développement

• feature/* — branches pour les nouvelles fonctionnalités

• release/* — préparation de la sortie

• hotfix/* — correctifs urgents en production

GitHub Flow

Modèle simplifié, populaire dans les équipes de livraison continue :

• main - toujours prêt pour le déploiement

• Les branches de fonctionnalité sont créées à partir de la branche principale

• Après la révision, les modifications sont réinjectées dans le main via une pull request

• Le déploiement a lieu immédiatement après la fusion

Trunk-Based Development

Approche minimaliste :

• Une branche principale (trunk/main)

• Les développeurs s'engagent directement dans le main ou créent des branches éphémères

• Les indicateurs de fonctionnalité sont utilisés pour masquer les fonctions inachevées

• Nécessite une discipline élevée et de bons tests de voiture

Conseils pratiques

Nommer les branches

Utilisez des noms clairs et structurés :

feature/user-authentication
bugfix/login-redirect
hotfix/payment-gateway
refactor/api-endpoints

Synchronisation régulière avec la branche principale

Si vous travaillez sur une branche de fonctionnalité pendant une longue période, récupérez régulièrement les modifications de la branche principale :

git checkout feature-dashboard
git merge main

Cela permettra d'éviter de gros conflits lors de la fusion finale.

Suppression des branches

Après la fusion de la branche, elle peut être supprimée :

git branch -d feature-auth

Pour forcer la suppression d'une branche non fusionnée :

git branch -D experimental-feature

Suppression de la branche distante :

git push origin --delete feature-auth

Afficher l'historique des branches

Visualisation de l'historique des commits avec les branches :

git log --oneline --graph --all

Cette commande affichera l'arborescence des commits avec toutes les branches dans un format compact.

Travail avec des branches distantes

Envoi de la branche locale au serveur

git push -u origin feature-api

Le drapeau -u établit une connexion entre la branche locale et la branche distante.

Obtention des branches supprimées

Pour voir les nouvelles branches du serveur :

git fetch origin

Création d'une branche locale basée sur une branche distante :

git checkout -b feature-api origin/feature-api

Ou plus court :

git checkout --track origin/feature-api

Conclusion

Les branches dans Git sont un outil puissant pour organiser le travail parallèle sur un projet. Elles vous permettent d'isoler le développement de nouvelles fonctionnalités, d'expérimenter le code en toute sécurité et de travailler efficacement en équipe. Comprendre les bases du travail avec les branches, de la fusion et de la résolution des conflits est une compétence nécessaire pour tout développeur moderne.

Commencez simplement : créez une branche distincte pour chaque nouvelle tâche, validez régulièrement les modifications et réintégrez les fonctionnalités terminées dans la branche principale. Avec l'expérience, vous trouverez le workflow qui vous convient le mieux, à vous et à votre équipe.

Annexe Code propose des cours de programmation structurés pour les développeurs débutants. La formation est basée sur des exemples pratiques et des tâches réelles qui vous aideront à commencer rapidement à écrire du code.

Rejoignez notre Chaîne Telegram, où nous publions régulièrement des articles utiles, des analyses de sujets complexes et répondons aux questions des programmeurs débutants. Apprendre ensemble est plus facile et plus efficace !