Git branch : maîtrisez les branches Git facilement

Quand on débute avec Git, le concept de branche Git ou Git branch peut rapidement sembler compliqué. Pourtant, elles sont au cœur du développement moderne et permettent de travailler sur de nouvelles fonctionnalités sans risquer de casser son projet principal. Une fois ce fonctionnement compris, Git devient immédiatement plus logique, plus puissant… et beaucoup moins stressant à utiliser.

Dans ce tutoriel, vous allez apprendre à créer une branche Git, changer de branche, fusionner vos modifications et éviter les erreurs préjudiciables. Le tout avec des exemples simples, des explications accessibles et une approche pensée spécialement pour les débutants.

• Utiliser les branches Git et pourquoi elles changent complètement la manière de développer un projet sans stress.
• Prendre de bonnes habitudes de travail dès le début pour tester des fonctionnalités, corriger des bugs et organiser son code proprement.
• Éviter les erreurs classiques des débutants avec Git grâce à des exemples concrets et des manipulations simples à reproduire.

Lorsque l’on découvre Git, il y a souvent un moment où tout devient un peu flou. Vous avez réussi à créer un dépôt, faire quelques commits, envoyer votre projet sur GitHub… puis soudain, vous tombez sur ce mot mystérieux : « branche ».

Et là, c’est la panique…

Pourtant, les branches Git sont probablement l’un des outils les plus puissants du développement moderne. Elles permettent de tester une idée sans casser son projet, de travailler à plusieurs sans se gêner, ou encore de préparer une nouvelle fonctionnalité proprement.

Autrement dit, apprendre à utiliser les branches, c’est passer du simple “je sauvegarde mon code” à une véritable organisation professionnelle.

Comprendre ce qu’est une branche Git

Avant de taper des commandes, il faut comprendre une chose essentielle : une branche est simplement une version parallèle de votre projet.

Imaginez un instant que vous écriviez un livre. Votre version principale est propre, stable et lisible. Mais vous souhaitez tester une nouvelle fin sans risquer de détruire votre travail actuel.

Vous pourriez alors faire une copie du manuscrit pour expérimenter tranquillement.

• Git fonctionne exactement comme cela.

La branche principale contient généralement la version stable du projet. Pendant ce temps, vous pouvez créer d’autres branches pour :

• tester une fonctionnalité,
• corriger un bug,
• essayer une idée,
• travailler à plusieurs développeurs.

Chaque branche évolue indépendamment des autres. C’est justement ce qui rend Git aussi puissant.

Pourquoi utiliser des branches ?

Au début, beaucoup de développeurs débutants travaillent directement sur main. C’est tentant. Mais c’est aussi une excellente manière de transformer son projet en champ de bataille après quelques semaines.

Prenons un exemple concret. Vous avez un site web fonctionnel. Vous voulez ajouter un système de connexion utilisateur.

Si vous modifiez directement main et que quelque chose casse :

• le site peut devenir inutilisable,
• certaines fonctionnalités peuvent disparaître,
• vous risquez de perdre du temps à réparer.

Avec une branche, le problème disparaît.

Vous créez une branche dédiée :

git branch connexion-utilisateur

Puis vous travaillez tranquillement dessus. Pendant ce temps, votre branche principale reste propre et fonctionnelle.

C’est un peu comme bricoler dans une pièce fermée sans salir toute la maison.

La branche principale : main

Quand vous créez un dépôt Git moderne, une branche nommée main est créée automatiquement.

Cette branche représente généralement :

• la version stable du projet,
• le code prêt à être utilisé,
• la base principale du développement.

Vous pouvez vérifier votre branche actuelle avec :

git branch

Exemple :

* main

L’étoile indique la branche active.

• Autrement dit, ici, vous êtes actuellement sur main.

Créer une branche Git

Passons maintenant à la pratique. Pour créer une branche :

git branch nom-branche

Par exemple :

git branch nouvelle-page-contact

Attention cependant : cette commande crée la branche… mais ne vous déplace pas dessus. C’est une erreur très fréquente chez les débutants.

Vous créez une branche, vous commencez à coder… puis vous découvrez une heure plus tard que vous étiez encore sur main. Oui, ça sent le vécu…

Changer de branche avec git checkout

Pour vous déplacer sur une branche :

git checkout nom-branche

Exemple :

git checkout nouvelle-page-contact

Git vous affichera :

Switched to branch 'nouvelle-page-contact'

• Vous travaillez maintenant dans cette branche.

Toutes vos modifications seront enregistrées ici.

Créer et changer de branche en une seule commande

Comme cette manipulation est extrêmement fréquente, Git propose un raccourci :

git checkout -b nom-branche

Exemple :

git checkout -b systeme-commentaires

Cette commande :

1. crée la branche,
2. vous place directement dessus.

C’est la méthode la plus utilisée.

Visualiser toutes les branches

Pour afficher toutes les branches du projet :

git branch

Exemple :

* main
  systeme-commentaires
  correction-footer

La branche active possède toujours une étoile.

Faire des modifications dans une branche

Une branche fonctionne comme un environnement indépendant.

Vous pouvez modifier des fichiers, créer du code, supprimer des éléments… sans affecter les autres branches.

Par exemple :

touch contact.html

Puis :

git add contact.html
git commit -m "Ajout de la page contact"

Ce commit appartient uniquement à la branche actuelle. Si vous revenez sur main, cette modification peut ne pas exister.

Et c’est justement tout l’intérêt.

Mes fichiers changent ?

Quand vous changez de branche avec Git, les fichiers présents dans votre projet changent aussi automatiquement dans votre éditeur de code tel que VS Code.

C’est justement le principe des branches Git : chaque branche possède sa propre version du code.

Prenons un exemple simple. Vous êtes sur main :

git switch main

Votre fichier index.html contient :

<h1>Mon site</h1>

Ensuite, vous créez une nouvelle branche :

git switch -c nouvelle-fonctionnalite

Dans cette branche, vous modifiez le fichier :

<h1>Mon super site</h1>

Puis vous faites un commit.

Maintenant, si vous revenez sur main :

git switch main

Git remet automatiquement les fichiers dans l’état de main.

Dans VS Code, vous reverrez donc :

<h1>Mon site</h1>

Et si vous retournez sur la branche nouvelle-fonctionnalite :

git switch nouvelle-fonctionnalite

Le fichier rechange immédiatement dans VS Code :

<h1>Mon super site</h1>

Donc oui : changer de branche modifie réellement les fichiers présents dans votre dossier de projet. Git remplace automatiquement le contenu des fichiers pour correspondre à la branche sélectionnée.

La première fois qu’on voit ça, c’est souvent un petit moment magique. On a presque l’impression que le projet “se transforme” en direct dans VS Code.

Revenir sur la branche principale

Pour revenir sur main :

git checkout main

Vous retrouvez alors votre projet dans son état précédent. C’est bluffant la première fois. Git gère tout à votre place. En réalité, Git change simplement l’état des fichiers selon la branche sélectionnée.

Comprendre le fonctionnement réel des branches

Beaucoup de débutants imaginent qu’une branche est une copie complète du projet. En réalité, Git est beaucoup plus intelligent.

Une branche est simplement un pointeur vers une suite de commits.

C’est ce qui rend Git extrêmement rapide et léger. Prenons une image simple. Imaginez plusieurs chemins qui partent d’une même route principale :

main
  |
  |---- fonctionnalite-A
  |
  |---- correction-bug

Chaque branche suit son propre chemin. Puis, plus tard, ces chemins peuvent être fusionnés.

Fusionner une branche avec git merge

Une fois votre fonctionnalité terminée, vous allez souvent vouloir la récupérer dans main. C’est ce qu’on appelle une fusion.

Étape 1 : revenir sur main

git checkout main

Étape 2 : fusionner la branche

git merge systeme-commentaires

Git va alors intégrer les modifications dans main. Si tout se passe bien, vous verrez un message indiquant que la fusion a réussi.

Exemple concret de workflow

Imaginons un petit projet de site web. Vous commencez sur main.

Puis vous décidez d’ajouter un menu responsive.

Création de la branche

git checkout -b menu-responsive

Travail sur le projet

Vous modifiez :

• style.css
• index.html
• script.js

Puis :

git add .
git commit -m "Ajout du menu responsive"

Retour sur main

git checkout main

Fusion

git merge menu-responsive

Votre fonctionnalité est maintenant intégrée.

Supprimer une branche

Une fois une branche fusionnée, elle devient souvent inutile.

Vous pouvez donc la supprimer avec :

git branch -d nom-branche

Exemple :

git branch -d menu-responsive

Git supprimera simplement la branche locale.

• Vos commits restent présents dans l’historique.

Attention aux conflits Git

Voici le moment que beaucoup redoutent : Les conflits.

Rassurez-vous : ils sont normaux.

Un conflit apparaît lorsque deux branches modifient la même partie d’un fichier.

Exemple :

Branche A

<h1>Bienvenue</h1>

Branche B

<h1>Bienvenue sur mon site</h1>

Git ne sait pas quelle version conserver.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

• Il affiche alors un conflit.

À quoi ressemble un conflit ?

Git ajoute des marqueurs dans le fichier :

<<<<<<< HEAD
<h1>Bienvenue</h1>
=======
<h1>Bienvenue sur mon site</h1>
>>>>>>> menu-responsive

Cela signifie :

• partie du haut : version actuelle,
• partie du bas : version de l’autre branche.

Vous devez choisir la bonne version manuellement.

Puis :

git add fichier
git commit

Et le conflit est résolu.

Les bonnes pratiques avec les branches

Avec le temps, certaines habitudes deviennent indispensables.

Créez une branche par fonctionnalité

Évitez les branches “fourre-tout”.

Préférez :

ajout-panier
correction-header
optimisation-images

Plutôt que :

modifs-diverses
test-final-v2-bis

Oui, ces noms existent réellement dans certains projets. Et ils font parfois peur.

Faites des commits réguliers

Une branche n’est pas une zone de stockage géante. Essayez de faire des commits propres et logiques :

git commit -m "Ajout du formulaire"

Puis :

git commit -m "Validation des champs"

C’est beaucoup plus clair qu’un gigantesque :

git commit -m "modifs"

Le fameux commit “modifs” reste probablement l’un des grands mystères de l’informatique moderne.

Ne travaillez pas directement sur main

Même seul sur un projet, prenez l’habitude d’utiliser des branches.

Vous développerez des réflexes professionnels. Et surtout, vous éviterez énormément d’erreurs.

Git switch : la méthode moderne

Depuis quelques versions, Git propose une commande plus moderne :

git switch nom-branche

Exemple :

git switch main

Pour créer une branche :

git switch -c nouvelle-branche

Cette syntaxe est souvent plus simple à comprendre pour les débutants.

La commande git switch est un outil récent et simplifié pour naviguer entre les différentes versions (les « branches ») de votre projet. Avant, on utilisait la commande git checkout pour tout faire, ce qui était assez confus.

• Avec switch, l’objectif est clair : changer de branche.

Imaginez que votre projet est un arbre avec plusieurs branches représentant différentes idées ou fonctionnalités ; utiliser git switch vous permet de sauter instantanément d’une branche à l’autre pour travailler sur ce que vous voulez, sans risquer de modifier les mauvais fichiers.

Pour l’utiliser, c’est très intuitif. Si vous voulez rejoindre une branche qui existe déjà, vous tapez simplement :

git switch nom-de-la-branche

Si vous voulez créer une toute nouvelle branche et vous y rendre immédiatement, vous utilisez l’option -c (comme « create »), par exemple : 

git switch -c ma-nouvelle-idee

C’est une commande beaucoup plus sécurisée pour les débutants, car elle se concentre uniquement sur le déplacement entre les branches et évite les erreurs de manipulation de fichiers que l’on pouvait rencontrer avec les anciennes commandes.

Travailler avec les branches sur GitHub

Les branches deviennent encore plus intéressantes lorsqu’on utilise GitHub.

Vous pouvez :

• envoyer vos branches en ligne,
• collaborer avec d’autres développeurs,
• créer des Pull Requests,
• relire du code avant fusion.

Pour envoyer une branche :

git push origin nom-branche

Exemple :

git push origin menu-responsive

Votre branche apparaît alors sur GitHub.

👉 Pour aller plus loin : Comment envoyer son projet sur GitHub depuis le terminal.

Comprendre les Pull Requests

Une Pull Request est une demande de fusion.

Vous dites en quelque sorte :

“J’ai terminé ma fonctionnalité, pouvez-vous la vérifier avant de l’ajouter au projet ?”

C’est une pratique essentielle dans le développement moderne.

Elle permet :

• de relire le code,
• détecter des erreurs,
• discuter des modifications,
• maintenir un projet propre.

Même sur un projet personnel, les Pull Requests peuvent être utiles pour garder une bonne organisation.

Que faire si une branche devient obsolète ?

Parfois, une branche reste longtemps sans être mise à jour. Le problème est que pendant ce temps, main continue d’évoluer.

Votre branche finit alors par prendre du retard. Vous pouvez récupérer les nouveautés avec :

git merge main

Ou utiliser :

git rebase main

Mais attention : rebase demande un peu plus d’expérience.

Pour débuter, concentrez-vous surtout sur merge.

Visualiser l’historique des branches

Git possède une commande très utile :

git log --oneline --graph --all

Elle affiche un historique visuel des branches.

Exemple simplifié :

* commit A
|\
| * commit B
| * commit C
|/
* commit D

Vous voyez immédiatement :

• les branches,
• les fusions,
• les chemins de développement.

C’est extrêmement pratique.

Exemple complet de cycle de travail

Voici un workflow typique utilisé quotidiennement.

D’abord, la mise à jour du projet :

git pull

Puis la création d’une branche :

git switch -c ajout-footer

On passe ensuite au développement avec la modification des fichiers…

Que l’on sauvegarde :

git add .
git commit -m "Ajout du footer responsive"

On effectue un retour sur main :

git switch main

On fusionne les nouveauté avec la branche principale (main) :

git merge ajout-footer

Enfin, on envoi le tout sur GitHub :

git push

Voilà.

Vous venez d’utiliser Git comme un vrai développeur.

Les erreurs fréquentes des débutants

Quand on débute avec Git branch, certaines erreurs reviennent constamment.

Oublier de changer de branche

Vous créez une branche… mais vous restez sur main. Résultat : tout le code arrive au mauvais endroit.

Vérifiez toujours votre branche avec :

git branch

Fusionner trop tard

Plus une branche reste isolée longtemps, plus les conflits deviennent compliqués.

Essayez de fusionner régulièrement.

Utiliser des noms incompréhensibles

Un bon nom doit expliquer le rôle de la branche.

Préférez :

ajout-authentification

Plutôt que :

test2-final-vraiment-final

Oui, encore une fois, ce genre de nom existe réellement. Et généralement… rien n’est “vraiment final”.

Les branches vont changer votre manière de développer

Avant les branches, beaucoup de développeurs travaillaient dans la peur :

• peur de casser le projet,
• peur d’essayer une idée,
• peur de revenir en arrière.

Avec Git branch, cette peur disparaît progressivement.

Vous pouvez expérimenter librement. Tester. Explorer. Créer sans risquer de détruire votre travail principal.

Et c’est précisément ce qui rend Git aussi populaire dans le monde du développement.

Tableau récapitulatif des commande Git pour les branches

Commande Git	Description	Exemple
git branch	Affiche la liste des branches locales	git branch
git branch nom-branche	Crée une nouvelle branche sans changer de branche	git branch ajout-footer
git switch nom-branche	Change de branche	git switch main
git checkout nom-branche	Ancienne commande pour changer de branche	git checkout main
git switch -c nom-branche	Crée une branche et bascule dessus immédiatement	git switch -c systeme-login
git checkout -b nom-branche	Ancienne version pour créer et changer de branche	git checkout -b systeme-login
git branch -d nom-branche	Supprime une branche locale fusionnée	git branch -d ajout-footer
git branch -D nom-branche	Force la suppression d’une branche	git branch -D test
git merge nom-branche	Fusionne une branche dans la branche actuelle	git merge ajout-footer
git branch -m nouveau-nom	Renomme la branche actuelle	git branch -m nouvelle-version
git push origin nom-branche	Envoie une branche sur GitHub/GitLab	git push origin ajout-footer
git push --delete origin nom-branche	Supprime une branche distante	git push --delete origin test
git branch -a	Affiche toutes les branches locales et distantes	git branch -a
git log --oneline --graph --all	Affiche l’historique visuel des branches	git log --oneline --graph --all
git diff branche1 branche2	Compare deux branches	git diff main develop
git stash	Met temporairement de côté des modifications avant de changer de branche	git stash
git stash pop	Restaure les modifications sauvegardées avec stash	git stash pop

FAQ Git branch

---

Apprendre à utiliser les branches Git représente souvent un véritable déclic pour les débutants. On passe d’un simple système de sauvegarde à une méthode de travail organisée, professionnelle et beaucoup plus sereine.

Au début, toutes ces commandes peuvent sembler impressionnantes. Pourtant, après quelques jours de pratique, créer une branche, changer d’environnement ou fusionner du code devient presque naturel.

Le plus important maintenant, ce n’est pas de mémoriser chaque commande par cœur. C’est surtout de pratiquer.

Créez un petit projet test. Ajoutez une fonctionnalité dans une branche. Faites volontairement quelques erreurs. Fusionnez du code. Provoquez même un conflit Git juste pour comprendre comment il fonctionne.

Parce qu’en informatique, on apprend énormément en cassant des choses… tant qu’on peut les réparer ensuite. Et justement, Git est là pour ça.