Dépôt
Le projet suivi par Git, avec tout son historique, dans le dossier caché .git.
Informatique · Outils du développeur
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 quizLe problème
Sans outil, on finit avec rapport_final_v3_VRAIMENT_final.docx. À plusieurs, chacun écrase le travail des autres.
Trois versions, aucune réponse : laquelle est la bonne ?
Après cette fiche, tu sais
Le plan
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 ?
Rien ne se perd
Notion 1 · Un historique fiable
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.
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.
Le projet suivi par Git, avec tout son historique, dans le dossier caché .git.
Un instantané de tout le projet, avec un message, un auteur, une date et un ou plusieurs parents.
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
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
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.
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.
git add.Et v3 ?
git add. La scène suivante te le montre pas à pas.Fais défiler : chaque étape exécute une commande, et la version du fichier (v1, v2, v3) change de zone.
Tu modifies rapport.md : la version v2 n'existe que dans ton répertoire de travail. L'index garde v1, celle du dernier commit.
git add copie v2 dans l'index : c'est elle qui partira au prochain commit.
Tu modifies encore (v3) sans refaire git add. git status cite le fichier deux fois : indexé (v2) et modifié (v3).
git commit enregistre l'index, donc v2, dans le commit e4f5a6b. v3 reste seulement dans ton répertoire.
git restore remet dans ton répertoire la version de l'index (v2) : v3 est perdue pour de bon.
git push envoie e4f5a6b sur le dépôt distant ; origin/main avance.
Quatre sorties réelles de git status (Git 2.47). Que se passe-t-il ?
Une branche, c'est une étiquette
Notion 3 · Branches
Une branche n'est qu'une étiquette posée sur un commit. À chaque nouveau commit, l'étiquette de la branche courante avance sur lui.
HEAD
HEAD indique où tu te trouves : en général, il désigne la branche courante, donc son dernier commit.
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.
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.
Au départ
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.
main.feature et bascule dessus.feature.main et fais-y un commit.feature dans main.Fusionner, c'est raccorder
Notion 4 · Fusion
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.
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.
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.
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
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
Fais défiler : main veut une meringue, feature une tarte. Trois façons de trancher, puis la fin de la fusion.
Le conflit
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
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.
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.
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.
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.
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
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
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
Fais défiler : Bob pousse avant toi. Ton push est refusé, et c'est une bonne nouvelle. Voici comment s'en sortir.
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.
Bob pousse son commit C : le serveur avance. Chez toi rien ne bouge, origin/main est encore sur A.
Tu fais le commit D, sans réseau : il n'existe que sur ta machine.
git push est refusé : le serveur a C, que tu n'as pas. Pousser écraserait le travail de Bob.
git fetch télécharge C et déplace origin/main. Ta branche main n'a pas bougé : les deux ont divergé.
git merge origin/main crée le commit M, à deux parents, D et C. C'est ce que fait git pull --no-rebase.
Le serveur peut passer de C à M sans rien perdre : le push passe.
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
Remets les cinq lignes dans l'ordre de la séquence. Touche deux lignes pour les échanger.
Annuler sans rien casser
Notion 6 · Annuler
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é
Un commit déjà poussé
Pour un commit publié, on utilise git revert : il ajoute un commit inverse et ne réécrit rien.4
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.
| Situation | Commande |
|---|---|
| Jeter une modification pas encore indexée | git restore f.txt |
| Retirer un fichier de l'index, en gardant la modification | git 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és | git reset --soft HEAD~1 |
| Idem, changements gardés mais non indexés | git reset HEAD~1 |
| Remettre tous les fichiers suivis comme au dernier commit | git 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 |
Fais défiler : on défait le commit C avec --soft, --mixed, --hard, puis revert. Regarde ce que devient sa modification dans chaque zone.
Avant
--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
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
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
La plupart se rattrapent. Sauf la première : un secret poussé est un secret public.
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.
Il n'agit que sur les fichiers non suivis. Pour un fichier déjà commité : git rm --cached fichier, puis un commit.
« modif », « fix », « aaa ». Un bon message dit ce que fait le commit : « Ajoute la page de contact ».
Un commit, un changement cohérent, facile à relire et à annuler.
Une branche par fonctionnalité, fusionnée quand elle est prête.
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
Cherche d'abord, puis ouvre la correction.
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.
git 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.
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.
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
Teste-toi maintenant
--rebase, --no-rebase et réglage pull.rebase, consulté le 8 octobre 2026. git-scm.com--continue et --abort, résolution des conflits pendant un rebase, consulté le 8 octobre 2026. git-scm.com--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.comFiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026.