Ce guide vous apprend à enregistrer vos modifications dans Git, étape
par étape. Vous allez suivre le cycle de travail quotidien : vérifier
l'état de vos fichiers (status), choisir ce qui entre dans le prochain
commit (add), relire les différences (diff), puis créer le commit.
Vous apprendrez aussi à exclure les fichiers indésirables avec
.gitignore.
Prérequis : un dépôt Git initialisé. Avoir compris les 3 états de Git (Working Directory, Staging Area, Repository).
Ce que vous allez apprendre
Section intitulée « Ce que vous allez apprendre »- Le cycle de vie des fichiers : non suivi → non modifié → modifié → indexé
git status: voir l'état de chaque fichiergit add: placer des modifications dans la Staging Areagit diff: inspecter ce qui a changégit commit: enregistrer un snapshot dans l'historique.gitignore: exclure les fichiers qui ne doivent pas être versionnés
Le cycle de vie des fichiers
Section intitulée « Le cycle de vie des fichiers »Git range chaque fichier de votre projet dans l'un de quatre états : non suivi, non modifié, modifié ou indexé. Le schéma montre les trois endroits où se trouve votre travail : le répertoire de travail (vos fichiers), la Staging Area (aussi appelée index, ce qui partira au prochain commit) et le dépôt (l'historique). Les flèches indiquent les commandes qui font passer un fichier de l'un à l'autre.
Un fichier non suivi (untracked) est un fichier que Git ne connaît
pas encore. Dès que vous l'ajoutez avec git add, Git commence à le suivre
et il devient indexé.
Après un commit, le fichier est non modifié jusqu'à votre prochaine
modification, qui le rend modifié : il attend alors un nouveau
git add.
Vérifier l'état avec git status
Section intitulée « Vérifier l'état avec git status »Vous lancerez git status très souvent : elle montre dans quel état se
trouve chaque fichier.
git statusSortie attendue (dépôt avec des fichiers dans différents états) :
On branch mainChanges to be committed: (use "git restore --staged <file>..." to unstage) new file: index.html
Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: style.css
Untracked files: (use "git add <file>..." to include in what will be committed) script.jsCette sortie vous indique trois choses :
index.htmlest dans la Staging Area, prêt à être committéstyle.cssest modifié mais pas encore indexéscript.jsest non suivi, Git ne le connaît pas encore
Indexer des fichiers avec git add
Section intitulée « Indexer des fichiers avec git add »La commande git add déplace des fichiers du Working Directory vers
la Staging Area. C'est l'étape de sélection : vous choisissez
exactement quelles modifications inclure dans votre prochain commit.
Ajouter un fichier spécifique
Section intitulée « Ajouter un fichier spécifique »Nommer le fichier est le réflexe sûr : vous indexez exactement ce que vous voulez, et rien d'autre. Il convient surtout quand votre répertoire contient des modifications en cours que vous n'êtes pas prêt à committer.
git add index.htmlAjouter plusieurs fichiers
Section intitulée « Ajouter plusieurs fichiers »Vous pouvez écrire plusieurs noms sur la même ligne : Git les indexe tous
en une passe. Cette forme vous laisse le contrôle de ce qui entre dans le
commit, ce que git add . ne permet pas.
git add index.html style.css script.jsAjouter tous les fichiers modifiés et non suivis
Section intitulée « Ajouter tous les fichiers modifiés et non suivis »git add .Cette commande ajoute tout le contenu du répertoire courant et de ses
sous-répertoires. C'est pratique, mais vérifiez d'abord avec git status
que vous n'allez pas indexer des fichiers indésirables.
Que se passe-t-il si vous modifiez un fichier après git add ?
Section intitulée « Que se passe-t-il si vous modifiez un fichier après git add ? »Le commit enregistre ce qui est dans la Staging Area, pas ce qui est sur
votre disque. Si vous modifiez style.css après l'avoir indexé, la nouvelle
modification reste hors de l'index jusqu'à un nouveau git add. git status
affiche alors le fichier dans les deux listes :
Changes to be committed: (use "git restore --staged <file>..." to unstage) modified: style.css
Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: style.cssLa première liste décrit la version indexée, celle qui partira au prochain
commit. La seconde décrit les changements plus récents, qui ne partiront pas.
Relancez git add style.css pour que la version finale soit enregistrée.
Ajouter des parties d'un fichier (staging interactif)
Section intitulée « Ajouter des parties d'un fichier (staging interactif) »Pour n'indexer que certaines modifications d'un fichier, utilisez le mode patch :
git add -p style.cssGit vous présente chaque bloc de modifications (appelé hunk) et vous demande quoi en faire :
diff --git a/style.css b/style.cssindex 5324dac..f540e30 100644--- a/style.css+++ b/style.css@@ -1,5 +1,6 @@ body { font-family: sans-serif;+ color: #333; margin: 0; padding: 0; }(1/1) Stage this hunk [y,n,q,a,d,e,p,?]?Les options principales :
| Touche | Action |
|---|---|
y | Indexer ce bloc |
n | Ne pas indexer ce bloc |
q | Quitter (ne plus proposer de blocs) |
s | Découper le bloc en morceaux plus petits, quand c'est possible |
Le staging interactif vous permet de créer des commits propres et ciblés, même quand vous avez fait plusieurs modifications dans le même fichier.
Inspecter les différences avec git diff
Section intitulée « Inspecter les différences avec git diff »Avant de committer, inspectez ce qui a changé pour vérifier que vos modifications sont correctes.
Voir les modifications non indexées
Section intitulée « Voir les modifications non indexées »git diffCette commande compare le Working Directory avec la Staging Area. Elle
montre ce que vous avez modifié mais pas encore ajouté avec
git add.
Sortie attendue :
diff --git a/style.css b/style.cssindex 5324dac..f540e30 100644--- a/style.css+++ b/style.css@@ -1,5 +1,6 @@ body { font-family: sans-serif;+ color: #333; margin: 0; padding: 0; }Les lignes préfixées par + sont des ajouts, celles par - sont des
suppressions. Le contexte (lignes sans préfixe) vous aide à situer
les modifications.
Voir les modifications indexées (prêtes à committer)
Section intitulée « Voir les modifications indexées (prêtes à committer) »git diff --stagedCette commande compare la Staging Area avec le dernier commit. Elle
montre exactement ce qui sera enregistré au prochain git commit.
Résumé des commandes diff
Section intitulée « Résumé des commandes diff »La distinction à retenir porte sur les deux points de comparaison.
git diff seul regarde ce qui n'est pas encore indexé, git diff --staged
regarde ce qui l'est déjà. Cette différence déroute souvent les débutants :
un git diff qui n'affiche rien ne signifie pas que le travail est vide,
mais souvent que tout est déjà dans la Staging Area. La troisième
ligne, git diff HEAD, cumule les deux et montre l'écart total avec le
dernier commit.
| Commande | Compare | Montre |
|---|---|---|
git diff | Working Dir ↔ Staging | Modifications non indexées |
git diff --staged | Staging ↔ Dernier commit | Ce qui sera committé |
git diff HEAD | Working Dir ↔ Dernier commit | Toutes les modifications des fichiers suivis |
Voici git diff HEAD dans le dépôt de l'exemple de git status plus
haut : index.html est indexé, style.css est modifié, et script.js
n'est pas suivi.
git diff HEADdiff --git a/index.html b/index.htmlnew file mode 100644index 0000000..bd54434--- /dev/null+++ b/index.html@@ -0,0 +1,3 @@+<!DOCTYPE html>+<html>+</html>diff --git a/style.css b/style.cssindex 5324dac..f540e30 100644--- a/style.css+++ b/style.css@@ -1,5 +1,6 @@ body { font-family: sans-serif;+ color: #333; margin: 0; padding: 0; }Le diff réunit le fichier indexé et le fichier modifié, mais script.js
n'y figure pas : tant qu'un fichier n'est pas suivi, git diff HEAD ne
le voit pas. Indexez-le avec git add script.js pour qu'il apparaisse.
Créer un commit
Section intitulée « Créer un commit »Un commit enregistre le contenu de la Staging Area comme un nouveau snapshot dans l'historique. Chaque commit est identifié par un SHA unique et contient un message descriptif.
Commit avec message en ligne
Section intitulée « Commit avec message en ligne »Avec l'option -m, le message tient sur une ligne et Git n'ouvre pas
d'éditeur. Elle convient aux modifications qu'une phrase décrit
entièrement. Dès que le changement mérite d'expliquer le pourquoi,
préférez la forme sans -m, détaillée juste après.
git commit -m "Ajouter la page d'accueil et les styles de base"Sortie obtenue avec Git 2.47.3, pour le tout premier commit d'un dépôt :
[main (root-commit) 4335e40] Ajouter la page d'accueil et les styles de base 2 files changed, 45 insertions(+) create mode 100644 index.html create mode 100644 style.cssLa mention (root-commit) n'apparaît que pour le premier commit, celui
qui n'a pas de parent. Les commits suivants affichent seulement
[main 3f7a2b1], avec leur propre SHA abrégé.
Commit avec message détaillé
Section intitulée « Commit avec message détaillé »Pour les modifications plus complexes, ouvrez votre éditeur pour écrire un message sur plusieurs lignes :
git commitGit ouvre l'éditeur configuré. Écrivez un titre court (50 caractères max), une ligne vide, puis une description détaillée :
Ajouter l'authentification des utilisateurs
- Créer le formulaire de connexion (login.html)- Valider la saisie côté client (auth.js)- Mettre en forme le formulaire (auth.css)Raccourci : add + commit en une seule commande
Section intitulée « Raccourci : add + commit en une seule commande »Pour les fichiers déjà suivis par Git (pas les nouveaux fichiers) :
git commit -am "Corriger la couleur du texte"L'option -a ajoute automatiquement à la Staging Area les fichiers déjà
suivis qui ont été modifiés, puis committe. Les fichiers non suivis
(untracked) ne sont pas inclus.
Modifier le dernier commit
Section intitulée « Modifier le dernier commit »Vous avez oublié un fichier ou fait une faute dans le message ?
git add fichier-oublie.cssgit commit --amendGit ouvre l'éditeur pour modifier le message, et le fichier oublié est inclus dans le commit. Le SHA du commit change, car son contenu est différent.
Écrire de bons messages de commit
Section intitulée « Écrire de bons messages de commit »Un bon message de commit aide à comprendre l'historique du projet. Voici des conventions courantes. Cette formation écrit les titres à l'infinitif (« Ajouter », « Corriger »). L'impératif (« Ajoute ») ou la forme nominale (« Ajout de la page de contact », utilisée dans les exemples d'historique de consulter l'historique) sont aussi courants : l'essentiel est qu'un dépôt garde un seul registre.
| Règle | Exemple |
|---|---|
| Titre court (50 car. max) | Ajouter la page de contact |
| Verbe à l'infinitif | Ajouter plutôt que Ajouté |
| Ligne vide après le titre | Sépare le titre du corps |
| Corps optionnel (72 car./ligne) | Explique le pourquoi, pas le quoi |
Retirer des fichiers de l'index
Section intitulée « Retirer des fichiers de l'index »Désindexer un fichier (sans perdre les modifications)
Section intitulée « Désindexer un fichier (sans perdre les modifications) »Si vous avez ajouté un fichier par erreur à la Staging Area :
git restore --staged style.cssLe fichier revient à l'état "modifié" dans le Working Directory. Vos modifications ne sont pas perdues.
Supprimer un fichier du suivi Git
Section intitulée « Supprimer un fichier du suivi Git »Pour supprimer un fichier et l'enlever du suivi Git :
git rm ancien-fichier.txtPour arrêter de suivre un fichier sans le supprimer du disque (utile si vous l'avez committé par erreur) :
git rm --cached fichier-secret.envLe fichier reste sur votre disque mais Git ne le suit plus. Pensez à
l'ajouter au .gitignore pour éviter de le ré-indexer. Attention : cette
commande ne retire rien des commits déjà faits. Un secret committé par
erreur reste lisible dans l'historique et doit d'abord être révoqué, comme
l'explique la leçon
Pourquoi versionner.
Configurer le .gitignore
Section intitulée « Configurer le .gitignore »Le fichier .gitignore indique à Git quels fichiers et dossiers
ignorer. Ces fichiers n'apparaîtront plus dans git status et ne seront
jamais indexés par git add ., sauf s'ils sont déjà suivis.
Cette section couvre ce qu'il faut savoir pour démarrer. Pour les
trois sources de règles, la vérification de ce que Git prend réellement
en compte avec git check-ignore, et le cas du fichier déjà suivi
qu'aucune règle ne filtre plus, voyez le guide dédié
ignorer des fichiers avec .gitignore.
Syntaxe de base
Section intitulée « Syntaxe de base »Chaque ligne du .gitignore est un motif. Deux caractères font tout
le travail : * remplace n'importe quelle suite de caractères, et / en
fin de ligne désigne un dossier entier. Le point le plus
contre-intuitif est le !, qui réintègre un fichier qu'un motif
précédent excluait ; l'ordre des lignes compte donc, une exception doit
venir après la règle qu'elle contredit.
# Commentaire*.log # Tous les fichiers .lognode_modules/ # Tout le dossier node_modules!important.log # Exception : suivre ce fichier malgré *.logbuild/ # Dossier de build.env # Fichier d'environnement (secrets)Les patterns les plus courants
Section intitulée « Les patterns les plus courants »Ces motifs couvrent les besoins courants. Regardez surtout les deux
derniers, plus subtils : doc/**/*.pdf utilise le double astérisque
pour traverser tous les sous-dossiers, alors qu'un / en tête, comme dans
/TODO, ancre le motif à la racine du dépôt et n'affecte pas les
fichiers TODO situés plus profond. Confondre ces deux comportements
explique souvent un fichier qu'on croyait ignoré et qui apparaît quand même
dans git status.
| Pattern | Correspond à |
|---|---|
*.log | Tous les fichiers terminant par .log |
build/ | Le dossier build et tout son contenu |
doc/**/*.pdf | Tous les .pdf dans doc/ et ses sous-dossiers |
!README.md | Exception : ne pas ignorer ce fichier |
/TODO | Seulement le fichier TODO à la racine |
Modèles .gitignore par langage
Section intitulée « Modèles .gitignore par langage »GitHub maintient une collection de modèles .gitignore pour chaque
langage et framework :
github.com/github/gitignore.
Quelques exemples courants :
__pycache__/*.py[cod].venv/*.egg-info/dist/.envnode_modules/dist/.env*.logcoverage//bin/*.exe*.testgo.workDépannage : problèmes courants
Section intitulée « Dépannage : problèmes courants »La plupart des blocages du cycle add puis commit se résument à
quelques symptômes récurrents. Lisez ce tableau de la colonne de gauche
vers la droite : partez du message ou du comportement que vous observez,
puis appliquez la solution. Un cas déroutant est le git diff qui
n'affiche rien, expliqué plus haut : il vient presque toujours de
modifications déjà indexées.
| Symptôme | Cause probable | Solution |
|---|---|---|
git add n'ajoute pas un fichier | Le fichier est dans .gitignore | Vérifiez .gitignore ou utilisez git add -f fichier |
| Fichier committé par erreur | Déjà dans l'historique | git rm --cached fichier + ajouter au .gitignore |
git diff ne montre rien | Modifications déjà indexées | Utilisez git diff --staged |
nothing to commit, working tree clean | Tous les fichiers sont committés | Normal : faites une modification et recommencez |
| Message de commit erroné | Faute de frappe | git commit --amend (si pas encore poussé) |
À retenir
Section intitulée « À retenir »git statusse lance avant chaqueaddet chaquecommitgit addplace les modifications dans la Staging Area ;-pchoisit les blocs un par un, et une modification faite après l'indexation demande un nouveaugit addgit diff(non indexé) etgit diff --staged(indexé) montrent ce qui va être enregistrégit commit -m "message"enregistre le snapshot dans l'historique.gitignoreprotège votre dépôt des fichiers indésirables, créez-le avant le premier commit- Ne committez jamais de secrets :
.env, clés, tokens → dans le.gitignore
Contrôle de connaissances
Section intitulée « Contrôle de connaissances »Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.
Contrôle de connaissances
Validez vos connaissances avec ce quiz interactif
Informations
- Le chronomètre démarre au clic sur Démarrer
- Questions à choix multiples, vrai/faux et réponses courtes
- Vous pouvez naviguer entre les questions
- Les résultats détaillés sont affichés à la fin
Lance le quiz et démarre le chronomètre
Vérification
(0/0)Score par domaine
Un domaine regroupe plusieurs guides et reçoit plusieurs questions : son score est plus fiable qu'un score par thème, qui porte souvent sur une seule question.
Bilan
Points forts
Aucun sujet réussi à 80 % sur au moins deux questions pour l’instant.
Points faibles
Aucun sujet sous le seuil de réussite.
À faire ensuite
Des indices pour retenter votre chance ?
Continuer le cours : Ignorer des fichiers avec .gitignore
Continuer le cours : Consulter l'historique : log, show, HEAD
Continuer le cours : Pull requests et code review
Nouveau quiz complet avec des questions aléatoires
Retravailler uniquement les questions ratées
Retour à la liste des certifications