0%
Tutoriel 4 sur 10
40% terminé

Branches et fusion

Apprenez à créer des branches pour travailler sur différentes fonctionnalités et à les fusionner dans votre code principal.

Branches et fusion

Les branches sont l’une des fonctionnalités les plus puissantes de Git. Elles permettent de développer des fonctionnalités en parallèle, d’expérimenter sans risque et de maintenir un historique propre. Ce tutoriel vous apprendra à maîtriser les branches et les techniques de fusion.

Qu’est-ce qu’une branche ?

Une branche Git est un pointeur mobile vers un commit spécifique. Elle permet de diverger de la ligne principale de développement et de travailler sur des fonctionnalités isolées.

gitgraph
    commit id: "Initial"
    commit id: "Feature A"
    branch feature-b
    checkout feature-b
    commit id: "Feature B-1"
    commit id: "Feature B-2"
    checkout main
    commit id: "Hotfix"
    merge feature-b
    commit id: "Release"

Concepts fondamentaux

HEAD est un pointeur vers le commit actuel (généralement le dernier commit de la branche courante).

Branche par défaut

  • Historiquement : master
  • Moderne : main
  • Configurable selon vos préférences

Gestion des branches

Lister les branches

# Branches locales
git branch

# Toutes les branches (locales et distantes)
git branch -a

# Branches distantes uniquement
git branch -r

# Avec informations détaillées
git branch -v

Créer une branche

# Créer une nouvelle branche
git branch nouvelle-fonctionnalite

# Créer et basculer vers la nouvelle branche
git checkout -b nouvelle-fonctionnalite

# Avec Git 2.23+ (recommandé)
git switch -c nouvelle-fonctionnalite

# Créer une branche depuis un commit spécifique
git branch nouvelle-branche abc1234

Basculer entre les branches

# Méthode traditionnelle
git checkout nom-branche

# Méthode moderne (Git 2.23+)
git switch nom-branche

# Revenir à la branche précédente
git switch -

# Basculer avec création si n'existe pas
git switch -c nouvelle-branche

Renommer une branche

# Renommer la branche courante
git branch -m nouveau-nom

# Renommer une autre branche
git branch -m ancien-nom nouveau-nom

Supprimer une branche

# Supprimer une branche fusionnée
git branch -d nom-branche

# Forcer la suppression (même non fusionnée)
git branch -D nom-branche

# Supprimer une branche distante
git push origin --delete nom-branche

Workflow avec les branches

Exemple pratique : Développement d’une fonctionnalité

# 1. Partir de la branche principale
git switch main
git pull origin main

# 2. Créer une branche pour la fonctionnalité
git switch -c feature/login-system

# 3. Développer la fonctionnalité
echo "function login() { /* code */ }" > login.js
git add login.js
git commit -m "feat: add basic login function"

# 4. Continuer le développement
echo "function logout() { /* code */ }" >> login.js
git add login.js
git commit -m "feat: add logout function"

# 5. Revenir à main pour la fusion
git switch main

Types de fusion (Merge)

Fast-Forward Merge

Quand la branche principale n’a pas évolué :

git merge feature/login-system
gitgraph
    commit id: "A"
    commit id: "B"
    branch feature
    checkout feature
    commit id: "C"
    commit id: "D"
    checkout main
    merge feature

Three-Way Merge

Quand les deux branches ont évolué :

git merge feature/login-system
gitgraph
    commit id: "A"
    commit id: "B"
    branch feature
    checkout feature
    commit id: "C"
    commit id: "D"
    checkout main
    commit id: "E"
    merge feature
    commit id: "Merge"

Merge avec message personnalisé

git merge feature/login-system -m "Merge login system feature"

No-Fast-Forward Merge

Forcer la création d’un commit de merge :

git merge --no-ff feature/login-system

Rebase : Alternative au merge

Le rebase réécrit l’historique en déplaçant les commits :

# Rebaser la branche courante sur main
git rebase main

# Rebase interactif pour modifier l'historique
git rebase -i HEAD~3

Différence Merge vs Rebase

Merge :

  • Préserve l’historique exact
  • Crée des commits de fusion
  • Historique plus complexe mais complet

Rebase :

  • Historique linéaire et propre
  • Réécrit l’historique
  • Peut compliquer la collaboration
gitgraph
    commit id: "A"
    commit id: "B"
    branch feature
    checkout feature
    commit id: "C"
    commit id: "D"
    checkout main
    commit id: "E"
    checkout feature
    commit id: "C'"
    commit id: "D'"

Résolution de conflits

Qu’est-ce qu’un conflit ?

Un conflit survient quand Git ne peut pas fusionner automatiquement les modifications.

Exemple de conflit

# Fichier avec conflit
<<<<<<< HEAD
function greet() {
    return "Hello World!";
}
=======
function greet() {
    return "Bonjour le monde!";
}
>>>>>>> feature/french-translation

Résoudre un conflit

# 1. Identifier les fichiers en conflit
git status

# 2. Éditer les fichiers pour résoudre les conflits
# Supprimer les marqueurs <<<<<<<, =======, >>>>>>>
# Garder le code désiré

# 3. Marquer comme résolu
git add fichier-resolu.js

# 4. Finaliser la fusion
git commit

Outils pour résoudre les conflits

# Configurer un outil de merge
git config --global merge.tool vimdiff

# Lancer l'outil de résolution
git mergetool

# Annuler une fusion en cours
git merge --abort

Stratégies de branches

Git Flow

Workflow structuré avec branches spécialisées :

  • main : Code de production
  • develop : Intégration des fonctionnalités
  • feature/* : Nouvelles fonctionnalités
  • release/* : Préparation des versions
  • hotfix/* : Corrections urgentes
# Exemple Git Flow
git switch develop
git switch -c feature/user-profile
# ... développement ...
git switch develop
git merge feature/user-profile

GitHub Flow

Workflow simplifié :

  • main : Code de production
  • feature/* : Toutes les modifications
# Exemple GitHub Flow
git switch main
git switch -c feature/new-header
# ... développement ...
git push origin feature/new-header
# ... Pull Request sur GitHub ...

Trunk-Based Development

Développement directement sur la branche principale avec des branches de courte durée.

Commandes avancées

Cherry-pick

Appliquer un commit spécifique d’une autre branche :

# Appliquer un commit spécifique
git cherry-pick abc1234

# Appliquer plusieurs commits
git cherry-pick abc1234 def5678

Stash avec branches

# Sauvegarder les modifications
git stash

# Basculer de branche
git switch autre-branche

# Appliquer le stash sur la nouvelle branche
git stash pop

Comparer les branches

# Voir les différences entre branches
git diff main..feature/login

# Voir les commits uniques à une branche
git log main..feature/login

# Voir les fichiers modifiés
git diff --name-only main..feature/login

Exercices pratiques

Exercice 1 : Workflow de base avec branches

# 1. Initialiser un projet
mkdir git-branches-demo
cd git-branches-demo
git init
echo "# Projet Demo" > README.md
git add README.md
git commit -m "Initial commit"

# 2. Créer une branche feature
git switch -c feature/add-calculator
echo "function add(a, b) { return a + b; }" > calculator.js
git add calculator.js
git commit -m "feat: add calculator function"

# 3. Revenir à main et créer une autre branche
git switch main
git switch -c feature/add-styles
echo "body { font-family: Arial; }" > styles.css
git add styles.css
git commit -m "style: add basic styles"

# 4. Fusionner les branches
git switch main
git merge feature/add-calculator
git merge feature/add-styles

# 5. Nettoyer
git branch -d feature/add-calculator
git branch -d feature/add-styles

Exercice 2 : Gestion des conflits

# 1. Créer un conflit intentionnel
git switch main
echo "Version main" > conflict.txt
git add conflict.txt
git commit -m "Add conflict file from main"

git switch -c feature/conflict-test
echo "Version feature" > conflict.txt
git add conflict.txt
git commit -m "Modify conflict file from feature"

# 2. Tenter la fusion (conflit attendu)
git switch main
git merge feature/conflict-test

# 3. Résoudre le conflit
# Éditer conflict.txt pour résoudre
echo "Version fusionnée" > conflict.txt
git add conflict.txt
git commit -m "Resolve conflict"

Exercice 3 : Rebase vs Merge

# Préparer l'environnement
git switch main
echo "Line 1" > file.txt
git add file.txt
git commit -m "Add line 1"

# Branche avec merge
git switch -c branch-merge
echo "Line 2 from merge" >> file.txt
git add file.txt
git commit -m "Add line 2 via merge"

git switch main
echo "Line 3 from main" >> file.txt
git add file.txt
git commit -m "Add line 3 from main"

git merge branch-merge

# Branche avec rebase
git switch -c branch-rebase
echo "Line 4 from rebase" >> file.txt
git add file.txt
git commit -m "Add line 4 via rebase"

git switch main
echo "Line 5 from main" >> file.txt
git add file.txt
git commit -m "Add line 5 from main"

git switch branch-rebase
git rebase main
git switch main
git merge branch-rebase

# Comparer les historiques
git log --oneline --graph

Bonnes pratiques

Nommage des branches

# Conventions courantes
feature/user-authentication
bugfix/login-error
hotfix/security-patch
release/v1.2.0
experiment/new-algorithm

Workflow recommandé

  1. Toujours partir de main à jour

    git switch main
    git pull origin main
  2. Créer des branches courtes et focalisées

    git switch -c feature/specific-task
  3. Commits fréquents et atomiques

    git commit -m "feat: add specific functionality"
  4. Tester avant de fusionner

    # Tests, linting, etc.
  5. Nettoyer après fusion

    git branch -d feature/completed-task

Éviter les erreurs courantes

  1. Ne pas développer directement sur main
  2. Toujours vérifier la branche courante
  3. Résoudre les conflits avec attention
  4. Ne pas forcer les push après rebase
  5. Communiquer les rebase en équipe

Outils et interfaces

Outils en ligne de commande

# Voir l'arbre des branches
git log --oneline --graph --all

# Alias utile
git config --global alias.tree 'log --oneline --graph --all'

Outils graphiques

  • GitKraken : Visualisation excellente des branches
  • SourceTree : Interface complète
  • VS Code : Extension Git Graph
  • GitHub Desktop : Simple et efficace

Dépannage

Branche détachée (Detached HEAD)

# Si vous êtes en HEAD détaché
git switch -c nouvelle-branche-sauvegarde
git switch main

Annuler une fusion

# Annuler le dernier merge
git reset --hard HEAD~1

# Ou si le merge n'est pas encore commité
git merge --abort

Récupérer une branche supprimée

# Trouver le commit de la branche supprimée
git reflog

# Recréer la branche
git branch branche-recuperee abc1234

Ressources supplémentaires

Documentation

Outils interactifs

Conclusion

La maîtrise des branches et de la fusion est essentielle pour un développement efficace avec Git. Ces concepts vous permettent de travailler en parallèle, d’expérimenter sans risque et de maintenir un historique propre.

Dans le prochain tutoriel, nous découvrirons GitHub, la plateforme qui révolutionne la collaboration autour de Git.


Temps de lecture estimé : 30 minutes
Niveau : Intermédiaire
Étape précédente : Commandes Git essentielles
Prochaine étape : Introduction à GitHub