Prise en main de Git — Chapitre 3 / 4

Les branches

Les branches permettent de travailler sur plusieurs choses en même temps. Sans risquer de casser ce qui fonctionne déjà. Ce chapitre t'explique comment ça marche.

Chapitre 3 / 4

Étape 01 / 11

Une branche, c'est quoi ?

Concept

Mot clé : branche Une branche est un nom qui pointe vers un commit. C'est comme un post-it collé sur une page d'un livre. Le post-it dit : «je suis ici». Quand tu ajoutes un nouveau commit, le post-it se déplace sur la nouvelle page.

Beaucoup de gens croient qu'une branche est une copie du code. Ce n'est pas vrai.

Une branche est juste un pointeur. C'est un petit fichier qui contient le hash d'un commit. Créer une branche est instantané. Ça ne prend presque pas de place sur ton disque.

A

B

feature

HEAD

C

main

HEAD indique la branche active

Chaque branche n’est qu’une étiquette posée sur un commit. HEAD suit la branche où tu te trouves.

Concept

Point important La branche main n'est pas spéciale. C'est juste un nom. Git la crée par défaut, mais tu pourrais l'appeler autrement. Elle n'a aucun pouvoir particulier.

« Créer une branche copie tout le code du projet. » Vrai ou faux ?

Étape 02 / 11

Pourquoi utiliser des branches ?

Imagine que tu travailles sur un site web. Le site fonctionne bien. Maintenant, tu veux ajouter une nouvelle page.

Si tu travailles directement sur main, tu risques de casser le site. Tes changements en cours ne sont peut-être pas finis.

Avec une branche, tu travailles à part. Le site reste fonctionnel sur main. Quand ta nouvelle page est prête, tu la ramènes dans main.

L'analogie

C'est comme avoir un brouillon. Tu écris sur le brouillon. Quand c'est prêt, tu recopies au propre.

Étape 03 / 11

Créer une branche

Concept

Mot clé : git branch La commande git branch sert à gérer les branches. Sans argument, elle affiche la liste des branches. Avec un nom, elle crée une nouvelle branche.

$ git branch

* main
  feature/header

$ git branch feature/about

# Crée une nouvelle branche appelée feature/about
# Attention : tu restes sur la branche actuelle

La nouvelle branche apparaît dans la liste, mais l'étoile n'a pas bougé : tu es toujours sur main.

$ git branch

  feature/about
  feature/header
* main

Étape 04 / 11

Changer de branche

Concept

Mot clé : git switch La commande git switch te permet de changer de branche. Quand tu changes de branche, Git met à jour les fichiers dans ton dossier. Les fichiers correspondent à l'état de la branche choisie.

$ git switch feature/about

# Bascule sur la branche feature/about
# Les fichiers changent pour correspondre à cette branche

$ git switch -c feature/footer

# Crée une nouvelle branche ET bascule dessus
# C'est un raccourci pour : git branch + git switch

L'option -c signifie "create". C'est le raccourci le plus utilisé. Tu crées et tu bascules en une seule commande.

En cas de doute, git status te dit toujours sur quelle branche tu te trouves :

$ git status

On branch feature/footer
nothing to commit, working tree clean

Quelle commande permet de basculer sur une autre branche ?

Étape 05 / 11

Fusionner : ramener une branche dans main

Concept

Mot clé : git merge Fusionner (merge) signifie combiner le travail de deux branches. En général, tu fusionnes ta branche de travail dans main. C'est comme recopier ton brouillon au propre.

Pour fusionner, tu dois d'abord te placer sur la branche qui va recevoir les changements. En général, c'est main.

# Étape 1 : revenir sur main

$ git switch main

# Étape 2 : fusionner la branche

$ git merge feature/about

Updating a1b2c3d..e4f5g6h
Fast-forward
 about.html | 24 ++++++++++++
 1 file changed, 24 insertions(+)

Les commits de feature/about font maintenant partie de main. La branche, elle, existe toujours : tu peux la supprimer ou continuer à travailler dessus.

Étape 06 / 11

Deux façons de fusionner

Git peut fusionner de deux façons différentes. Cela dépend de ce qui s'est passé sur les branches.

Cas 1 : Fast-forward (avance rapide) Cela arrive quand main n'a pas bougé depuis la création de la branche. Git se contente d'avancer le pointeur. Pas besoin de créer un nouveau commit.

L'analogie

C'est comme si tu avais lu les pages 1 à 10 d'un livre, et ton ami a lu les pages 11 à 15. Il suffit de continuer. Pas de travail supplémentaire.

Avant

A

B

main

C

D

feature

Après · main avance

A

B

C

feature

D

main

main n’a pas bougé : Git avance simplement le marque-page jusqu’au bout. Aucun commit créé.

Tu reconnais ce cas dans la sortie de Git : il écrit "Fast-forward".

$ git merge feature

Updating a1b2c3d..d4e5f6g
Fast-forward
 index.html | 8 ++++
 1 file changed, 8 insertions(+)

Cas 2 : Merge commit (commit de fusion) Cela arrive quand les deux branches ont des commits différents. Git crée un nouveau commit qui combine les deux. Ce commit a deux parents.

L'analogie

C'est comme si toi et ton ami avez chacun écrit un chapitre différent. Il faut assembler les deux chapitres pour faire le livre complet.

Les deux branches ont avancé : Git crée un commit de merge M qui a 2 parents.

Ici, la sortie de Git est différente : il indique la stratégie utilisée pour combiner les deux historiques.

$ git merge feature

Merge made by the 'ort' strategy.
 index.html | 12 ++++++
 1 file changed, 12 insertions(+)

Quand Git peut-il faire un simple « fast-forward » (sans commit de merge) ?

Étape 07 / 11

Visualiser les branches

Il existe une commande très utile pour voir toutes les branches et les commits. Elle dessine un graphe dans le terminal.

$ git log --graph --oneline --all

*   f7a8b9c (HEAD → main) Merge branch 'feature'
|\
| * d4e5f6a (feature) Add feature
|/
* a1b2c3d Initial commit

Cette commande montre :

Les commits (chaque ligne avec un *)
Les branches (les noms entre parenthèses)
Les liens entre commits (les lignes |, / et \)
Où tu te trouves (HEAD →)

Étape 08 / 11

Bien nommer ses branches

Le nom d'une branche doit expliquer ce que tu fais dessus. Voici les conventions les plus courantes :

feature/nom — pour ajouter une fonctionnalité. Exemple : feature/page-contact
fix/nom — pour corriger un bug. Exemple : fix/menu-mobile
chore/nom — pour la maintenance technique. Exemple : chore/update-dependencies

$ git switch -c fix/menu-mobile

Switched to a new branch 'fix/menu-mobile'

Étape 09 / 11

Erreurs fréquentes

Les branches deviennent vite naturelles. En attendant, voici les pièges qui reviennent le plus souvent :

Oublier de revenir sur main avant de fusionner. Tu dois toujours être sur la branche qui reçoit les changements.
Créer une branche depuis une autre branche au lieu de main. Vérifie toujours où tu es avec git status avant de créer une branche.
Travailler directement sur main. Crée toujours une branche, même pour un petit changement. C'est plus sûr.
Penser qu'une branche est une copie du code. C'est juste un pointeur. Créer 100 branches ne prend presque pas de place.

Étape 10 / 11

Pour aller plus loin

Tu veux creuser ? Ces ressources prolongent ce chapitre :

git checkout : l'ancienne commande pour changer de branche
git log : explorer l'historique en détail
Résoudre un conflit de merge Git

Étape 11 / 11

Teste tes connaissances

Avant de passer aux exercices, vérifie que tu as bien compris les branches. Clique sur la réponse qui te semble correcte.

Quiz — Chapitre 3

1. Que se passe-t-il quand tu crées une branche avec git branch feature ?

2. Quelle est la différence entre un fast-forward et un merge commit ?

3. Avant de fusionner une branche dans main, tu dois d'abord…

4. Que fait git switch -c feature/header ?

Chapitre 3 sur 4

L'enquête ne fait que commencer, la suite t'attend...

← Chapitre 2 Chapitre suivantChapitre 4 — Résoudre les conflits →

Ton avis compte

Aide-nous à améliorer cette formation en partageant ton retour.