Informatique · Outils du développeur

Git : versions, branches et travail en équipe

Garder l'historique de son code, essayer une idée sans rien casser, travailler à plusieurs : c'est le rôle de Git.

Déjà à l'aise ? Aller au quiz

Le problème

Sans outil, on finit avec rapport_final_v3_VRAIMENT_final.docx. À plusieurs, chacun écrase le travail des autres.

rapport_v1.docx rapport_final.docx rapport_final_v3_VRAIMENT_final.docx

Trois versions, aucune réponse : laquelle est la bonne ?

Après cette fiche, tu sais

  • faire passer un fichier par les trois zones de Git : répertoire de travail, index, dépôt ;
  • créer une branche, changer de branche et fusionner, en sachant quand Git fait un fast-forward ;
  • résoudre un conflit de fusion ;
  • travailler avec un dépôt distant : clone, fetch, pull, push, et réagir à un push refusé ;
  • choisir la bonne commande pour annuler une erreur, sans casser le travail des autres.
Tu fais git add rapport.md, puis tu modifies encore le fichier, puis git commit. Quelle version part dans le commit : celle d'avant ou celle d'après la deuxième modification ?

Celle d'avant, je crois ? Ou la dernière ?

Garde ta réponse en tête : la scène des trois zones la vérifie.

Rien ne se perd

Notion 1 · Un historique fiable

Garder chaque version

Git garde l'historique complet d'un projet : chaque version, son auteur, sa date et son pourquoi. On peut revenir en arrière, ou tester une idée dans une branche à part.

v1 v2 v3 v4 chaque commit garde un lien vers le précédent

Une histoire

Git a été créé en 2005 par Linus Torvalds pour développer le noyau Linux.1 Il est distribué : chaque copie contient tout l'historique, si bien que presque tout marche sans réseau.

ta copie tout l'historique plateforme GitHub, GitLab héberge, n'est pas Git
40 caractères hexadécimaux dans l'empreinte complète (SHA-1) d'un commit.1

Dépôt

Le projet suivi par Git, avec tout son historique, dans le dossier caché .git.

Commit

Un instantané de tout le projet, avec un message, un auteur, une date et un ou plusieurs parents.

Empreinte

Chaque commit porte une empreinte SHA-1, comme 24b9da6552252987aa493b52f8696cd6d3b00373. Les 7 premiers caractères suffisent souvent.1

Trois zones pour un fichier

Notion 2 · Trois zones

Trois zones, trois états

Sur ta machine, un projet Git a trois zones : le répertoire de travail, l'index (zone de préparation) et le dépôt.1

répertoire de travail index préparation dépôt .git git add git commit le chemin d'un fichier, du répertoire vers le dépôt

Un fichier, trois états

Un fichier modifié n'est pas encore indexé. Une fois indexé, il attend le commit. Une fois validé, il fait partie de l'historique.

modifié indexé validé git add git commit une modification ne part dans le commit qu'après git add

Le cycle de base

# où en sont mes fichiers ?
git status
# ce qui a changé et n'est pas encore indexé
git diff
git add rapport.md
git commit -m "Ajoute l'introduction"
# l'historique, un commit par ligne
git log --oneline

Un quatrième lieu entre en jeu dès qu'on travaille à plusieurs : le dépôt distant, sur un serveur, souvent nommé origin.

Tu te demandais quelle version part dans le commit ? C'est v2, la version indexée par git add.

Et v3 ?

v3 attend un nouveau git add. La scène suivante te le montre pas à pas.

Suis rapport.md d'une zone à l'autre

Fais défiler : chaque étape exécute une commande, et la version du fichier (v1, v2, v3) change de zone.

Répertoire de travail Index (zone de préparation) Dépôt local (.git) Dépôt distant (origin)
Étape 1 sur 6 · modifier

Tu modifies rapport.md : la version v2 n'existe que dans ton répertoire de travail. L'index garde v1, celle du dernier commit.

Étape 2 sur 6 · git add

git add copie v2 dans l'index : c'est elle qui partira au prochain commit.

Étape 3 sur 6 · modifier encore

Tu modifies encore (v3) sans refaire git add. git status cite le fichier deux fois : indexé (v2) et modifié (v3).

Étape 4 sur 6 · git commit

git commit enregistre l'index, donc v2, dans le commit e4f5a6b. v3 reste seulement dans ton répertoire.

Étape 5 sur 6 · git restore

git restore remet dans ton répertoire la version de l'index (v2) : v3 est perdue pour de bon.

Étape 6 sur 6 · git push

git push envoie e4f5a6b sur le dépôt distant ; origin/main avance.

Exercice · lire

Que dit git status ?

Quatre sorties réelles de git status (Git 2.47). Que se passe-t-il ?

Une branche, c'est une étiquette

Notion 3 · Branches

Des étiquettes qui avancent

Une branche n'est qu'une étiquette posée sur un commit. À chaque nouveau commit, l'étiquette de la branche courante avance sur lui.

A B C main main le commit ne bouge pas : seule l'étiquette avance

HEAD

HEAD indique où tu te trouves : en général, il désigne la branche courante, donc son dernier commit.

HEAD feature D HEAD suit la branche : c'est elle qui avance

Les commandes

# liste les branches
git branch
# crée feature et y va
git switch -c feature
# revient sur main
git switch main
# fusionne feature dans la branche courante
git merge feature

git switch

git switch existe depuis Git 2.23, sorti en 2019.4 L'ancienne forme git checkout -b feature marche toujours.

Lire l'historique

git log --oneline liste les commits, du plus récent au plus ancien, avec leurs étiquettes.

$ git log --oneline f6a7b8c(HEAD → main) Merge branch 'feature' e5f6a7bE d4e5f6a(feature) D c3d4e5fC b2c3d4eB

Scène 1 · Deux branches, puis une fusion

Fais défiler : les commandes s'enchaînent et les étiquettes bougent. Choisis ensuite le scénario sans commit sur main pour voir un fast-forward.

Scène 1 · Branches

Au départ

À toi : le simulateur

Touche les commandes, ou tape-les, et suis la mission. Observe quand Git crée un commit de fusion, et quand il se contente d'avancer une étiquette.

Mission
  1. Fais deux commits sur main.
  2. Crée la branche feature et bascule dessus.
  3. Fais un commit sur feature.
  4. Reviens sur main et fais-y un commit.
  5. Fusionne feature dans main.

Fusionner, c'est raccorder

Notion 4 · Fusion

Fusionner, trois cas

git merge feature, lancé depuis main, intègre le travail de feature. Trois cas se présentent.2

Cas 1 · Fast-forward

Si main n'a pas bougé depuis la création de feature, il n'y a rien à mélanger. Git avance simplement l'étiquette main sur le dernier commit de feature.

B C D feature main main aucun nouveau commit : Git déplace seulement l'étiquette

Cas 2 · Fusion à trois points

Si les deux branches ont avancé, Git combine leurs deux derniers commits et leur ancêtre commun. Il crée un commit de fusion, qui a deux parents au lieu d'un.

B E main C D feature M

Cas 3 · Conflit

Si les deux branches ont modifié la même partie d'un fichier, Git ne peut pas choisir à ta place. Il écrit les deux versions entre des marqueurs et attend que tu tranches.

Entrée : salade <<<<<<< HEAD Dessert : meringue double crème ======= Dessert : tarte aux pruneaux >>>>>>> feature

Une autre voie · rebase

git rebase main, lancé depuis feature, rejoue les commits de feature au bout de main. L'historique devient linéaire.7

avant B C D E feature main après B E C' D' feature

Les commandes du rebase

git switch feature
git rebase main
# en cas de conflit : corrige le fichier, puis
git add menu.txt
git rebase --continue
# ou abandonne et reviens à l'état d'avant
git rebase --abort
git switch main
git merge feature

Les commits rejoués sont de nouveaux commits, avec de nouvelles empreintes. Ici, main n'a pas bougé : le merge final est un fast-forward.8 Règle d'or : ne jamais rebaser des commits déjà poussés et utilisés par d'autres.7

Scène 2 · Résoudre un conflit

Fais défiler : main veut une meringue, feature une tarte. Trois façons de trancher, puis la fin de la fusion.

Scène 2 · Conflit

Le conflit

menu.txt
Piège : Git ne vérifie pas les marqueurs

Un git add sur un fichier qui contient encore <<<<<<< le marque comme résolu, et git commit enregistre les marqueurs tels quels (testé avec Git 2.47). Touche « le conflit » puis « conclure » dans la scène pour le voir. Relis toujours le fichier avant git add.

Récupérer avant de pousser

Notion 5 · Dépôts distants

Travailler à plusieurs

Le dépôt distant est un dépôt Git hébergé ailleurs : GitHub, GitLab, un serveur de l'école. Quand tu clones un projet, Git nomme ce distant origin.

origin (serveur) ta machine git clone tout l'historique est copié

Les commandes

# copie tout le dépôt et son historique
git clone https://…/projet.git
# récupère les nouveaux commits, sans rien fusionner
git fetch
# fetch, puis intégration dans ta branche
git pull
# envoie tes commits
git push

Trois commandes, trois sens

fetch télécharge sans rien fusionner. pull fait un fetch, puis intègre la branche distante dans la tienne. push envoie tes commits.

origin ta machine fetch pull push fetch ne fusionne rien ; pull fait fetch puis fusion

Un nom de suivi

Après un fetch, origin/main montre où en est le serveur. Ta branche main, elle, ne bouge pas tant que tu ne fusionnes pas.

A C main origin/main fetch déplace origin/main, pas main

Pull request

Sur GitHub ou GitLab, on propose ses changements par une pull request (ou merge request) : l'équipe relit la branche avant de la fusionner. C'est un outil de la plateforme, pas une commande Git.

fetch

Télécharge les nouveaux commits et met à jour les branches de suivi comme origin/main, sans toucher à ta branche : tu regardes avant d'intégrer.5

pull

Un fetch, puis l'intégration de la branche distante dans la tienne. Si les deux ont avancé, une version récente de Git refuse de choisir seule : git pull --no-rebase fusionne, git pull --rebase rebase.6

push

Envoie tes commits. Refusé si le distant contient des commits que tu n'as pas : récupère-les d'abord, intègre-les, puis pousse.5

Le push refusé

Fais défiler : Bob pousse avant toi. Ton push est refusé, et c'est une bonne nouvelle. Voici comment s'en sortir.

Serveur (origin) Ta machine Bobtoi Bobtoi
Étape 1 sur 7 · le clone

Toi et Bob avez cloné le même dépôt. Chez toi, main et origin/main (ta copie de l'état du serveur) sont sur A.

Étape 2 sur 7 · Bob pousse

Bob pousse son commit C : le serveur avance. Chez toi rien ne bouge, origin/main est encore sur A.

Étape 3 sur 7 · ton commit

Tu fais le commit D, sans réseau : il n'existe que sur ta machine.

Étape 4 sur 7 · push refusé

git push est refusé : le serveur a C, que tu n'as pas. Pousser écraserait le travail de Bob.

Étape 5 sur 7 · git fetch

git fetch télécharge C et déplace origin/main. Ta branche main n'a pas bougé : les deux ont divergé.

Étape 6 sur 7 · la fusion

git merge origin/main crée le commit M, à deux parents, D et C. C'est ce que fait git pull --no-rebase.

Étape 7 sur 7 · push accepté

Le serveur peut passer de C à M sans rien perdre : le push passe.

Piège : « fatal: Need to specify how to reconcile divergent branches »

Ce n'est pas une panne : ta branche et le distant ont avancé tous les deux, et git pull te demande de choisir. git pull --no-rebase fusionne, comme dans la séquence ; git pull --rebase rejoue tes commits. Pour ne plus avoir la question : git config pull.rebase false (fusion).6

Exercice · ordonner

Bob a poussé avant toi

Remets les cinq lignes dans l'ordre de la séquence. Touche deux lignes pour les échanger.

Annuler sans rien casser

Notion 6 · Annuler

Annuler sans casser le travail des autres

Git permet presque toujours de revenir en arrière. La bonne commande dépend de l'endroit où se trouve l'erreur, et d'une question clé : le commit a-t-il déjà été poussé ?3

La question clé

déjà poussé ? non restore, reset, --amend tout ce qui reste local oui revert un commit qui défait

Un commit déjà poussé

Pour un commit publié, on utilise git revert : il ajoute un commit inverse et ne réécrit rien.4

A B C bug C' défait C main revert ajoute C' : rien n'est effacé

Ce qui reste dans chaque zone

Chaque reset touche une zone de plus : --soft ne touche que la branche, --mixed ajoute l'index, --hard ajoute le répertoire de travail.

vert : gardé · jaune : déplacé · rose : perdu branche index fichiers --soft branche index fichiers --mixed branche index fichiers --hard
SituationCommande
Jeter une modification pas encore indexéegit restore f.txt
Retirer un fichier de l'index, en gardant la modificationgit restore --staged f.txt
Corriger le dernier commit (message, fichier oublié), pas encore pousségit commit --amend
Défaire le dernier commit local, changements gardés et indexésgit reset --soft HEAD~1
Idem, changements gardés mais non indexésgit reset HEAD~1
Remettre tous les fichiers suivis comme au dernier commitgit reset --hard
Annuler un commit déjà pousségit revert <commit>
Mettre un travail en cours de côtégit stash, puis git stash pop

Scène 3 · Reculer d'un commit : quatre façons

Fais défiler : on défait le commit C avec --soft, --mixed, --hard, puis revert. Regarde ce que devient sa modification dans chaque zone.

Scène 3 · Annuler

Avant

Piège : réécrire un historique partagé

--amend, reset et rebase remplacent des commits par d'autres. Sur des commits déjà poussés, tes camarades se retrouvent avec un historique qui ne correspond plus au leur. Pour un commit publié, on utilise git revert, qui ajoute un commit inverse et ne réécrit rien.4

Piège : git reset --hard et git restore sont sans retour

Une modification jamais commitée qu'on jette ainsi est perdue. Et git reset --hard, sans argument, laisse en place les fichiers non suivis (jamais ajoutés) : pour eux, c'est git clean.4

Exercice · choisir

Quelle commande ?

Huit situations réelles. Choisis la commande qui convient ; la correction s'affiche tout de suite.

Des erreurs qui se rattrapent

Pièges fréquents

Les erreurs de tous les débutants

La plupart se rattrapent. Sauf la première : un secret poussé est un secret public.

Committer un secret

Mot de passe, clé d'API : l'historique le garde même si tu supprimes le fichier ensuite. Des fichiers comme .env vont dans le .gitignore dès le premier jour.

Croire que .gitignore retire un fichier suivi

Il n'agit que sur les fichiers non suivis. Pour un fichier déjà commité : git rm --cached fichier, puis un commit.

Des messages vides de sens

« modif », « fix », « aaa ». Un bon message dit ce que fait le commit : « Ajoute la page de contact ».

Des commits géants

Un commit, un changement cohérent, facile à relire et à annuler.

Travailler des jours sur main

Une branche par fonctionnalité, fusionnée quand elle est prête.

Forcer l'envoi

git push --force sur une branche partagée écrase le travail des autres. Préfère git push --force-with-lease, qui refuse si la branche distante a changé depuis ta dernière récupération.9

Entraînement

Quatre exercices corrigés

Cherche d'abord, puis ouvre la correction.

1Tu as modifié index.html et style.css. Tu veux committer seulement index.html. Quelles commandes ?Voir le corrigé

git add index.html puis git commit -m "…". Seul ce qui est dans l'index part dans le commit : style.css reste modifié, non indexé, pour un prochain commit. C'est tout l'intérêt de l'index.

2git status affiche a.txt deux fois : dans « Changes to be committed » et dans « Changes not staged for commit ». Comment est-ce possible ?Voir le corrigé

Tu as modifié a.txt, fait git add, puis modifié encore le fichier. L'index contient la première version, le répertoire de travail une plus récente. Un git commit maintenant n'enregistrerait que la version indexée ; refais git add a.txt pour y inclure la dernière.

3Sur main : commits A puis B. On crée feature sur B, qui reçoit C puis D. Pendant ce temps, main reçoit E. Depuis main, git merge feature fait-il un fast-forward ? Et si E n'existait pas ?Voir le corrigé

Les deux branches ont avancé depuis B : pas de fast-forward. Git crée un commit de fusion dont les deux parents sont E et D. Sans E, main serait resté sur B, ancêtre de D : Git ferait un fast-forward, en avançant simplement main sur D, sans nouveau commit. C'est la scène 1, dans ses deux scénarios.

4Tu viens de pousser un commit qui contient un mot de passe. Que fais-tu ?Voir le corrigé

D'abord, changer le mot de passe : il a pu être copié, il est compromis. Ensuite, sache que git revert ne suffit pas : il ajoute un commit qui retire le mot de passe du fichier, mais l'ancien commit le contient toujours. L'effacer vraiment demande de réécrire l'historique avec un outil dédié, puis de forcer l'envoi, ce qui oblige toute l'équipe à se resynchroniser. D'où la règle : jamais de secret dans un commit.

Retenir l'essentiel

À retenir

La fiche en huit lignes

Trois zonesrépertoire de travail, git add, index, git commit, dépôt.
Commitinstantané, message, parent(s) ; empreinte SHA-1.
Brancheétiquette qui avance ; git switch -c nom, git switch nom.
HEADoù tu es : en général, la branche courante.
Fusionfast-forward si main n'a pas bougé, sinon commit à deux parents.
Conflitéditer, retirer les marqueurs, git add, git commit.
Distantclone, fetch, pull (fetch + intégration), push ; push refusé : fetch, fusion, push.
Annulerrestore, --amend, reset (local) ; revert (déjà poussé).

Teste-toi maintenant

Dernière étape : le quiz. Douze questions tirées au hasard parmi vingt-cinq, différentes à chaque partie. Si tu te trompes, lis bien l'explication.
Quiz final

Teste-toi

Sources

  1. Scott Chacon et Ben Straub, Pro Git, 2e édition, Apress, 2014, en ligne sur git-scm.com : « A Short History of Git », « What is Git? », consulté le 8 octobre 2026. git-scm.com (histoire), git-scm.com (trois zones)
  2. Scott Chacon et Ben Straub, Pro Git : « Basic Branching and Merging » (fast-forward, fusion à trois points, conflits), consulté le 8 octobre 2026. git-scm.com
  3. Scott Chacon et Ben Straub, Pro Git : « Undoing Things » (amend, restore), consulté le 8 octobre 2026. git-scm.com
  4. Git, documentation de référence (2026) : git-switch (introduit dans Git 2.23.0, 2019), git-restore, git-reset (modes soft, mixed, hard), git-revert, git-clean (fichiers non suivis), gitignore, consulté le 8 octobre 2026. git-switch, git-restore, git-reset, git-revert, git-clean, gitignore
  5. Scott Chacon et Ben Straub, Pro Git : « Working with Remotes » (fetch ne fusionne rien ; push refusé tant qu'on n'a pas récupéré le travail des autres), consulté le 8 octobre 2026. git-scm.com
  6. Git, documentation de référence, git-pull (version 2.55.0) : par défaut, seulement les avances rapides ; échec si les branches ont divergé ; options --rebase, --no-rebase et réglage pull.rebase, consulté le 8 octobre 2026. git-scm.com
  7. Scott Chacon et Ben Straub, Pro Git : « Rebasing » (rejouer des commits au bout d'une autre branche, nouvelles empreintes, règle de ne pas rebaser ce qui est partagé), consulté le 8 octobre 2026. git-scm.com
  8. Git, documentation de référence, git-rebase : options --continue et --abort, résolution des conflits pendant un rebase, consulté le 8 octobre 2026. git-scm.com
  9. Git, documentation de référence, git-push : option --force-with-lease, qui refuse la mise à jour si la branche distante a changé depuis ta dernière récupération, consulté le 8 octobre 2026. git-scm.com

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026.

Glisser pour continuer vers SOLID et Clean Code
Gymnase 2