Aller au contenu principal

Prise en main de Git · Chapitre 4 / 5

Organiser ton travail avec les branches

Une branche te permet de travailler sur une idée sans casser ce qui fonctionne. Tu apprends à les créer, à passer de l'une à l'autre et à les fusionner.

Chapitre 4 / 5

Étape 01 / 15

Dans ce chapitre

Jusqu'ici, tous tes commits se suivaient sur une seule ligne. Les branches te permettent d'ouvrir des lignes de travail séparées, puis de les rassembler.

À la fin de ce chapitre, tu sauras :

  • Expliquer ce qu'est une branche et à quoi elle sert
  • Lister, créer et changer de branche
  • Renommer et supprimer une branche
  • Fusionner une branche dans une autre avec git merge
  • Lire le graphe des branches avec git log --graph

Étape 02 / 15

Une branche, c'est quoi ?

Concept

Branche : une ligne de travail indépendante. Concrètement, c'est juste une étiquette posée sur un commit.

Quand tu crées un dépôt, Git crée une première branche : main. Chaque commit que tu fais s'ajoute au bout de cette branche, et l'étiquette main avance avec lui.

Créer une nouvelle branche, c'est poser une deuxième étiquette. Les commits faits sur cette branche n'apparaissent pas sur main, tant que tu ne les rassembles pas.

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.

L'analogie

Dans le cahier du photographe, une branche est un marque-page. Tu peux poser plusieurs marque-pages et continuer l'histoire à partir de l'un ou de l'autre. Poser un marque-page ne recopie pas le cahier.

Astuce

Une branche n'est pas une copie de ton projet. Créer une branche est instantané et ne prend presque pas de place, même sur un très gros projet.

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

Étape 03 / 15

Pourquoi travailler avec des branches ?

Sans branche, tout le monde travaille sur main. Si tu commites une fonctionnalité à moitié finie, main ne fonctionne plus. Et si un bug urgent arrive, ton travail en cours est au milieu.

Avec les branches, main reste toujours stable. Chaque sujet a sa propre branche :

  • Une nouvelle fonctionnalité : feature/formulaire-contact
  • Une correction de bug : fix/menu-mobile
  • Un essai que tu n'es pas sûr de garder : test/nouvelle-police
ABCDEMfeaturemainHEADcommit de merge
Chaque commit pointe vers son parent. Les branches bifurquent, les merges réunissent : c’est le graphe (DAG).

Quand le travail est prêt, tu le fusionnes dans main. Si l'essai ne marche pas, tu supprimes la branche : main n'a jamais été touchée.

L'analogie

C'est comme écrire au brouillon. Tu essaies, tu ratures, tu recommences. Quand c'est bon, tu recopies au propre.

Étape 04 / 15

Voir tes branches : git branch

git branch, sans rien d’autre, affiche la liste de tes branches locales :

$ git branch

  feature/formulaire-contact
* main

L'étoile * indique la branche sur laquelle tu te trouves. Ici, main.

Pour voir aussi les branches du dépôt distant, ajoute -a (all) :

$ git branch -a

  feature/formulaire-contact
* main
  remotes/origin/main

Les branches qui commencent par remotes/origin/ sont des copies des branches de GitHub. Elles se mettent à jour quand tu fais git pull.

Dans la liste affichée par git branch, que signifie l'étoile * ?

Étape 05 / 15

Créer une branche

$ git branch <nom-branche>

$ git branch fix/menu-mobile

La branche est créée à partir du commit où tu te trouves. Attention : git branch crée la branche, mais tu restes sur ta branche actuelle. L’étoile n’a pas bougé :

$ git branch

  feature/formulaire-contact
  fix/menu-mobile
* main

À pratiquer

Avant de créer une branche, vérifie avec git status que tu es bien sur main, et que main est à jour (git pull). Sinon, ta branche partirait d'un mauvais point de départ.

Étape 06 / 15

Changer de branche : git switch

$ git switch <nom-branche>

$ git switch fix/menu-mobile

Switched to branch 'fix/menu-mobile'

Quand tu changes de branche, Git met à jour les fichiers de ton dossier pour qu'ils correspondent à cette branche. C'est normal de voir des fichiers changer ou disparaître : ils sont toujours là, sur l'autre branche.

Le raccourci le plus utilisé : créer une branche et basculer dessus en une seule commande, avec -c (create) :

$ git switch -c feature/galerie

Switched to a new branch 'feature/galerie'

Concept

HEAD : le repère qui indique où tu te trouves. En général, HEAD pointe vers ta branche actuelle. Quand tu fais un commit, la branche avance, et HEAD suit. C'est le HEAD que tu vois dans (HEAD -> main) avec git log.

Avant le commit

A
HEAD
B
main

Après le commit

A
B
HEAD
C
main

C = nouveau commit

Quand tu commites, la branche avance sur le nouveau commit, et HEAD suit.

Astuce

Dans beaucoup de tutoriels, tu verras git checkout <branche> et git checkout -b <branche>. C'est l'ancienne façon de faire, et elle marche toujours. git switch a été créé pour être plus clair.

Attention

Avant de changer de branche, commite tes modifications en cours. Sinon, Git peut refuser de changer (pour ne pas écraser ton travail), ou emporter tes modifications sur l’autre branche.

Quelle commande crée une branche ET bascule dessus ?

Étape 07 / 15

Bien nommer tes branches

Le nom d'une branche doit dire ce que tu fais dessus. La convention la plus répandue : un préfixe, une barre oblique, puis une description courte avec des tirets.

  • feature/ pour une nouvelle fonctionnalité : feature/page-contact
  • fix/ pour corriger un bug : fix/menu-mobile
  • docs/ pour la documentation : docs/readme-installation
  • chore/ pour la maintenance : chore/mise-a-jour-dependances

À pratiquer

Pas d'espaces ni d'accents dans un nom de branche. Utilise des minuscules et des tirets.

Étape 08 / 15

Renommer une branche

Une faute de frappe dans le nom ? Renomme la branche avec l’option -m (move) :

$ git branch -m <ancien-nom> <nouveau-nom>

$ git branch -m feature/galrie feature/galerie

Si tu es déjà sur la branche à renommer, le nouveau nom suffit :

$ git branch -m <nouveau-nom>

Étape 09 / 15

Supprimer une branche

Une fois fusionnée, une branche ne sert plus. Supprime-la avec l’option -d (delete) :

$ git branch -d <nom-branche>

$ git branch -d fix/menu-mobile

Deleted branch fix/menu-mobile (was 7a3e9c2).

Si la branche contient des commits qui n'ont pas été fusionnés, Git refuse, pour te protéger :

$ git branch -d test/nouvelle-police

error: the branch 'test/nouvelle-police' is not fully merged
hint: If you are sure you want to delete it, run 'git branch -D test/nouvelle-police'

Si tu es sûr de vouloir abandonner ce travail, force la suppression avec -D (en majuscule) :

$ git branch -D test/nouvelle-police

Attention

-D supprime la branche même si son travail n'a jamais été fusionné. Ces commits deviennent très difficiles à retrouver. Garde-le pour du travail que tu abandonnes vraiment.

Astuce

Tu ne peux pas supprimer la branche sur laquelle tu te trouves. Change d’abord de branche, par exemple avec git switch main.

Quelle option supprime une branche seulement si son travail a été fusionné ?

Étape 10 / 15

Fusionner des branches : git merge

Ta branche est terminée ? Rapatrie son travail dans main avec git merge. La règle à retenir : tu te places sur la branche qui reçoit, puis tu fusionnes la branche qui apporte le travail.

$ git merge <branche-a-fusionner>

# 1. Se placer sur la branche qui reçoit

$ git switch main

# 2. Fusionner la branche terminée

$ git merge fix/menu-mobile

Updating 8c4e2f1..7a3e9c2
Fast-forward
 style.css | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

Les commits de fix/menu-mobile font maintenant partie de main. La branche existe toujours : tu peux la supprimer avec git branch -d.

Selon la situation, Git fusionne de deux façons.

Cas 1 : l'avance rapide (fast-forward). main n'a pas bougé depuis la création de ta branche. Git avance simplement l'étiquette main jusqu'au dernier commit de ta branche. Aucun nouveau commit n'est créé.

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éé.

Cas 2 : le commit de fusion (merge commit). main a reçu d’autres commits pendant que tu travaillais. Git crée un nouveau commit qui rassemble les deux lignes. Ce commit a deux parents.

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

$ git merge feature/galerie

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

Astuce

Pour un commit de fusion, Git peut ouvrir un éditeur pour le message. Le message proposé (Merge branch 'feature/galerie') convient très bien : enregistre et ferme l'éditeur.

Concept

Si les deux branches ont modifié la même ligne du même fichier, Git ne peut pas choisir à ta place : c’est un conflit. On apprend à le résoudre au chapitre 5.

Tu veux rapatrier feature/galerie dans main. Où dois-tu être avant de lancer git merge feature/galerie ?

Étape 11 / 15

Visualiser les branches : git log --graph

Pour voir les branches et leurs commits sous forme de graphe dans le terminal :

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

*   c4d8e2a (HEAD -> main) Merge branch 'feature/galerie'
|\
| * 2b7f1e9 (feature/galerie) Ajouter la galerie photo
* | 7a3e9c2 Corriger le menu sur mobile
|/
* 8c4e2f1 Ajouter le formulaire de contact

Comment le lire :

  • Chaque * est un commit.
  • Les traits | / \ relient les commits : on voit où les branches se séparent et se rejoignent.
  • Les noms entre parenthèses sont les branches. HEAD -> main indique où tu es.

Astuce

Des outils comme GitHub Desktop, ou l'extension Git Graph de VS Code, dessinent ce graphe avec des couleurs et des lignes. C'est la même information.

Étape 12 / 15

Récap : les branches

1

git switch main puis git pull : tu pars d’une base à jour

2

git switch -c feature/ma-fonctionnalite : tu crées ta branche

3

git add et git commit : tu travailles sur ta branche

4

git switch main puis git merge feature/ma-fonctionnalite : tu fusionnes

5

git branch -d feature/ma-fonctionnalite : tu fais le ménage

Ton aide-mémoire du chapitre :

$ git branch # lister les branches locales

$ git branch -a # lister aussi les branches distantes

$ git branch <nom> # créer une branche

$ git switch <nom> # changer de branche

$ git switch -c <nom> # créer et changer

$ git branch -m <ancien> <nouveau> # renommer

$ git branch -d <nom> # supprimer (si fusionnée)

$ git branch -D <nom> # forcer la suppression

$ git merge <nom> # fusionner dans la branche actuelle

$ git log --oneline --graph --all # voir le graphe

git branch
— Lister les branches
git switch -c
— Créer une branche et basculer dessus
git branch -m
— Renommer une branche
git branch -d
— Supprimer une branche fusionnée
git merge
— Fusionner dans la branche actuelle

Étape 13 / 15

Erreurs fréquentes

  • Fusionner depuis la mauvaise branche : git merge rapatrie le travail dans la branche où tu es. Vérifie avec git status avant de lancer git merge.
  • Créer une branche depuis une autre branche que main sans le vouloir : ta nouvelle branche emporte des commits qui ne la concernent pas.
  • Travailler directement sur main : même pour un petit changement, une branche est plus sûre.
  • Changer de branche avec des modifications non commitées : commite-les d'abord.
  • Utiliser -D par réflexe : préfère -d, qui te prévient si du travail n’a pas été fusionné.

Étape 14 / 15

Bonus : sous le capot

Astuce

Partie facultative, pour les curieux. Tu peux passer directement au quiz.

Une branche est vraiment une simple étiquette : c'est un petit fichier texte qui contient l'identifiant d'un commit. Tu peux le lire :

$ cat .git/refs/heads/main

c4d8e2a9f1b3e5d7c9a2b4f6e8d0c1a3b5e7f9d2

Quand tu fais un commit sur main, Git remplace simplement cet identifiant par celui du nouveau commit. C'est pour ça que créer une branche est instantané.

HEAD est lui aussi un fichier. Il contient le nom de ta branche actuelle :

$ cat .git/HEAD

ref: refs/heads/main

Attention

HEAD détaché (detached HEAD) : si tu te places directement sur un commit au lieu d'une branche (par exemple avec git checkout 3f2a1b4 pour regarder une ancienne version), HEAD pointe vers ce commit et plus vers une branche. Tu peux regarder sans risque. Mais si tu commites, aucune branche ne garde ces commits. Pour revenir en sécurité : git switch main. Pour garder ce que tu as fait : git switch -c nouvelle-branche.

Étape 15 / 15

Teste tes connaissances

Vérifie que tu sais créer, changer et fusionner des branches. Clique sur la réponse qui te semble correcte : chaque réponse est expliquée.

Quiz · Chapitre 4

1. Qu’est-ce qu’une branche Git ?

2. Quelle commande crée la branche fix/menu ET bascule dessus ?

3. Tu veux intégrer le travail de feature/galerie dans main. Que fais-tu ?

4. git branch -d test refuse de supprimer la branche. Pourquoi ?

5. Quand Git fait-il une fusion en avance rapide (fast-forward) ?

6. Dans git log --oneline, que signifie (HEAD -> main) ?

Chapitre 4 sur 5

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

Ton avis compte

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

Pour qu'on puisse te répondre si besoin.