Aller au contenu
English
Compte : non connecté, synchronisation possible Mon apprentissage
Selectionner le thème
English
Read in English

Enregistrer des modifications avec Git : add, commit, status

Par mis à jour le

Améliorer cette page

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

  • Le cycle de vie des fichiers : non suivi → non modifié → modifié → indexé
  • git status : voir l'état de chaque fichier
  • git add : placer des modifications dans la Staging Area
  • git 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

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.

Les trois états de Git : git add fait passer les fichiers modifiés du répertoire de travail à la zone de staging, git commit les enregistre dans le dépôt .git ; git restore --staged et git restore font le chemin inverse.git addgit commitgit restore --stagedgit restore fichierRépertoire de travailfichiers modifiésZone de stagingprochaine photoDépôt .githistorique complet
Source · SVG
Échap pour fermer, + et − pour zoomer, défilement pour se déplacer. 100 %

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.

Vous lancerez git status très souvent : elle montre dans quel état se trouve chaque fichier.

Fenêtre de terminal
git status

Sortie attendue (dépôt avec des fichiers dans différents états) :

On branch main
Changes 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.js

Cette sortie vous indique trois choses :

  • index.html est dans la Staging Area, prêt à être committé
  • style.css est modifié mais pas encore indexé
  • script.js est non suivi, Git ne le connaît pas encore

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.

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.

Fenêtre de terminal
git add index.html

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.

Fenêtre de terminal
git add index.html style.css script.js
Fenêtre de terminal
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.css

La 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 :

Fenêtre de terminal
git add -p style.css

Git vous présente chaque bloc de modifications (appelé hunk) et vous demande quoi en faire :

diff --git a/style.css b/style.css
index 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 :

ToucheAction
yIndexer ce bloc
nNe pas indexer ce bloc
qQuitter (ne plus proposer de blocs)
sDé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.

Avant de committer, inspectez ce qui a changé pour vérifier que vos modifications sont correctes.

Fenêtre de terminal
git diff

Cette 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.css
index 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) »
Fenêtre de terminal
git diff --staged

Cette commande compare la Staging Area avec le dernier commit. Elle montre exactement ce qui sera enregistré au prochain git commit.

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.

CommandeCompareMontre
git diffWorking Dir ↔ StagingModifications non indexées
git diff --stagedStaging ↔ Dernier commitCe qui sera committé
git diff HEADWorking Dir ↔ Dernier commitToutes 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.

Fenêtre de terminal
git diff HEAD
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..bd54434
--- /dev/null
+++ b/index.html
@@ -0,0 +1,3 @@
+<!DOCTYPE html>
+<html>
+</html>
diff --git a/style.css b/style.css
index 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.

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.

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.

Fenêtre de terminal
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.css

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

Pour les modifications plus complexes, ouvrez votre éditeur pour écrire un message sur plusieurs lignes :

Fenêtre de terminal
git commit

Git 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)

Pour les fichiers déjà suivis par Git (pas les nouveaux fichiers) :

Fenêtre de terminal
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.

Vous avez oublié un fichier ou fait une faute dans le message ?

Fenêtre de terminal
git add fichier-oublie.css
git commit --amend

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

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ègleExemple
Titre court (50 car. max)Ajouter la page de contact
Verbe à l'infinitifAjouter plutôt que Ajouté
Ligne vide après le titreSépare le titre du corps
Corps optionnel (72 car./ligne)Explique le pourquoi, pas le quoi

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 :

Fenêtre de terminal
git restore --staged style.css

Le fichier revient à l'état "modifié" dans le Working Directory. Vos modifications ne sont pas perdues.

Pour supprimer un fichier et l'enlever du suivi Git :

Fenêtre de terminal
git rm ancien-fichier.txt

Pour arrêter de suivre un fichier sans le supprimer du disque (utile si vous l'avez committé par erreur) :

Fenêtre de terminal
git rm --cached fichier-secret.env

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

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.

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 .log
node_modules/ # Tout le dossier node_modules
!important.log # Exception : suivre ce fichier malgré *.log
build/ # Dossier de build
.env # Fichier d'environnement (secrets)

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.

PatternCorrespond à
*.logTous les fichiers terminant par .log
build/Le dossier build et tout son contenu
doc/**/*.pdfTous les .pdf dans doc/ et ses sous-dossiers
!README.mdException : ne pas ignorer ce fichier
/TODOSeulement le fichier TODO à la racine

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/
.env

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ômeCause probableSolution
git add n'ajoute pas un fichierLe fichier est dans .gitignoreVérifiez .gitignore ou utilisez git add -f fichier
Fichier committé par erreurDéjà dans l'historiquegit rm --cached fichier + ajouter au .gitignore
git diff ne montre rienModifications déjà indexéesUtilisez git diff --staged
nothing to commit, working tree cleanTous les fichiers sont committésNormal : faites une modification et recommencez
Message de commit erronéFaute de frappegit commit --amend (si pas encore poussé)
  • git status se lance avant chaque add et chaque commit
  • git add place les modifications dans la Staging Area ; -p choisit les blocs un par un, et une modification faite après l'indexation demande un nouveau git add
  • git diff (non indexé) et git diff --staged (indexé) montrent ce qui va être enregistré
  • git commit -m "message" enregistre le snapshot dans l'historique
  • .gitignore protè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

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

10 questions
6 min.
70% requis

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