Aller au contenu principal

Prise en main de Git · Chapitre 2 / 5

Suivre tes modifications

Git range tes fichiers dans 3 zones. Dans ce chapitre, tu apprends à lire leur état et à choisir précisément ce que tu vas enregistrer.

Chapitre 2 / 5

Étape 01 / 13

Dans ce chapitre

Ton dépôt est prêt. Avant d'enregistrer une version, il faut comprendre comment Git voit tes fichiers. C'est le sujet de ce chapitre.

À la fin de ce chapitre, tu sauras :

  • Expliquer les 3 zones de Git : working directory, staging area et repository
  • Lire la réponse de git status
  • Préparer des fichiers avec git add
  • Retirer un fichier de la préparation avec git restore --staged
  • Voir ce qui a changé avec git diff
  • Annuler une modification avec git restore

Astuce

On continue avec le projet mon-portfolio du chapitre 1. Si tu arrives directement ici, crée un dossier avec un fichier index.html et lance git init dedans.

Étape 02 / 13

Les 3 zones de Git

Git range tes fichiers dans 3 zones. Chaque commande fait passer des fichiers d'une zone à l'autre. Si tu retiens ce schéma, tu comprendras toutes les commandes de ce cours.

  • Working directory (dossier de travail) : ton dossier, là où tu modifies tes fichiers.
  • Staging area (zone de préparation) : là où tu ranges les fichiers à mettre dans ta prochaine version.
  • Repository (dépôt) : l'historique de toutes les versions enregistrées, dans le dossier .git.

Working Directory

ton dossier de travail

git add

Staging Area

la zone de préparation

git commit

Repository

l'historique (.git)

Chaque commande fait passer tes fichiers d’une zone à la suivante.

L'analogie

Reprenons notre photographe. L'appareil photo, c'est le working directory : tu prends autant de photos que tu veux. Le plateau de sélection, c'est la staging area : tu y poses les photos que tu veux garder. Le cahier, c'est le repository : tu y colles ta sélection, avec la date et une légende. Tu ne colles jamais tout, seulement ce que tu as choisi.

1

Tu modifies tes fichiers dans le working directory

2

git add les place dans la staging area

3

git commit les enregistre dans le repository (chapitre 3)

📷 L'appareil photo
— Working directory (ton dossier)
🗂️ Le plateau de sélection
— Staging area (la préparation)
📖 Le cahier
— Repository (l'historique)

Étape 03 / 13

Le working directory : ton espace de travail

Le working directory, c'est simplement le dossier de ton projet, tel que tu le vois dans ton explorateur de fichiers ou dans ton éditeur. Par exemple :

# Le dossier mon-portfolio

📁 mon-portfolio
├── 📁 .git
├── 📁 images
│   └── 📄 photo.jpg
├── 📄 index.html
├── 📄 style.css
└── 📄 README.md

Tu y travailles comme d'habitude : tu crées, modifies et supprimes des fichiers. Git observe ce dossier, mais il n'enregistre rien tout seul. C'est toi qui décides quand et quoi enregistrer.

Pour Git, chaque fichier est dans l'un de ces états :

  • Non suivi (untracked) : un nouveau fichier que Git n'a jamais enregistré.
  • Modifié (modified) : un fichier déjà suivi, changé depuis la dernière version enregistrée.
  • Préparé (staged) : un fichier placé dans la staging area, prêt à être enregistré.
  • Enregistré (committed) : un fichier identique à la dernière version enregistrée. Git n'a rien à signaler.

Étape 04 / 13

Vérifier l'état du dépôt : git status

Concept

git status est ta boussole. Il te dit sur quelle branche tu es et dans quel état sont tes fichiers. Lance-le aussi souvent que tu veux : il ne modifie rien.

Voici sa réponse dans un projet qui a déjà quelques versions enregistrées :

$ git status

On branch main

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	modified:   README.md

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:   index.html

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	contact.html

La réponse est découpée en sections. Chacune correspond à un état :

  • Changes to be committed : les fichiers dans la staging area, prêts à être enregistrés. Ici, README.md.
  • Changes not staged for commit : les fichiers modifiés, mais pas encore préparés. Ici, index.html.
  • Untracked files : les nouveaux fichiers que Git ne suit pas encore. Ici, contact.html.

Astuce

Dans la plupart des terminaux, les fichiers préparés s'affichent en vert et les autres en rouge. Fie-toi surtout au titre de chaque section : il dit la même chose, sans dépendre des couleurs. Entre parenthèses, Git t'indique même la commande à utiliser ensuite.

Quand tout est enregistré, git status te le dit :

$ git status

On branch main
nothing to commit, working tree clean

Dans git status, sous quel titre apparaît un nouveau fichier que Git n'a jamais suivi ?

Étape 05 / 13

La staging area : une zone tampon

Pourquoi ne pas tout enregistrer d’un coup ? Parce qu’une bonne version raconte une seule chose.

Imagine : tu as corrigé une faute dans README.md et, en même temps, tu as commencé à refaire le menu dans index.html. Ce sont deux sujets différents. La staging area te permet de les enregistrer séparément : d'abord la correction du README, puis le nouveau menu quand il sera fini.

L'analogie

La staging area, c'est comme le panier d'un site de courses en ligne. Tu y ajoutes des articles, tu en retires, tu vérifies. Rien n'est acheté tant que tu ne valides pas la commande. Ici, valider la commande, c'est faire un commit.

Concept

Tu croiseras aussi le mot index : c'est un autre nom de la staging area. « Indexer un fichier » veut dire « le placer dans la staging area ».

Étape 06 / 13

Ajouter des fichiers : git add

Pour placer un ou plusieurs fichiers dans la staging area, utilise git add suivi des noms de fichiers :

$ git add <fichier1> <fichier2> ...

Par exemple, pour préparer uniquement la correction du README :

$ git add README.md

$ git status

On branch main

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	modified:   README.md

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:   index.html

README.md est passé dans la section Changes to be committed. index.html n'a pas bougé : il ne sera pas dans la prochaine version.

Pour ajouter d'un coup tous les fichiers nouveaux et modifiés du dossier, utilise un point :

$ git add .

Attention

git add . ajoute tout, y compris des fichiers que tu ne voulais peut-être pas enregistrer (fichiers temporaires, mots de passe...). Lance toujours git status avant, pour savoir ce que tu ajoutes. Au chapitre 3, tu apprendras à exclure des fichiers avec .gitignore.

Astuce

git add ne fait que préparer. Rien n'est encore enregistré dans l'historique : ce sera le rôle de git commit.

Tu veux préparer uniquement README.md, pas les autres fichiers modifiés. Quelle commande ?

Étape 07 / 13

Retirer des fichiers de la staging area

Tu as ajouté un fichier par erreur ? Pas de panique : git restore --staged le retire de la staging area.

$ git restore --staged <fichier1> <fichier2> ...

$ git restore --staged index.html

Le fichier retourne dans la section Changes not staged for commit. Tes modifications sont toujours là, dans le fichier : tu as seulement changé d’avis sur ce que tu veux enregistrer.

Pour vider complètement la staging area :

$ git restore --staged .

Astuce

Dans d'anciens tutoriels, tu croiseras git reset HEAD <fichier>. Ça fait la même chose : git restore --staged est la version moderne, plus facile à retenir.

« git restore --staged efface tes modifications. » Vrai ou faux ?

Étape 08 / 13

Voir ce qui a changé : git diff

git status te dit quels fichiers ont changé. git diff te montre ce qui a changé à l’intérieur, ligne par ligne :

$ git diff

diff --git a/index.html b/index.html
index 3b18e51..a8c4f2d 100644
--- a/index.html
+++ b/index.html
@@ -5,3 +5,3 @@
 <body>
-  <h1>Bienvenue</h1>
+  <h1>Bienvenue sur mon portfolio</h1>
 </body>

Comment lire ce résultat :

  • Une ligne qui commence par - a été supprimée.
  • Une ligne qui commence par + a été ajoutée.
  • Les lignes sans signe sont là pour le contexte : elles n'ont pas changé.
  • Une ligne modifiée apparaît donc deux fois : l'ancienne version avec -, la nouvelle avec +.

Par défaut, git diff montre les changements qui ne sont pas encore dans la staging area. Deux variantes utiles :

# Les changements d'un seul fichier

$ git diff index.html

# Ce qui est dans la staging area, donc ce qui sera enregistré

$ git diff --staged

À pratiquer

Bonne habitude : lance git diff --staged juste avant d’enregistrer. Tu vérifies exactement ce qui va partir dans la nouvelle version.

Astuce

Si la réponse est longue, Git l'affiche page par page. Utilise les flèches pour défiler et appuie sur la touche q pour quitter.

Dans la réponse de git diff, que signifie une ligne qui commence par + ?

Étape 09 / 13

Annuler une modification : git restore

Tu as modifié un fichier et, finalement, tu veux revenir à sa dernière version enregistrée ? Utilise git restore, sans option :

$ git restore <fichier>

$ git restore index.html

index.html revient exactement à son état de la dernière version enregistrée.

Attention

Attention, c'est définitif. Les modifications annulées avec git restore n'ont jamais été enregistrées : Git ne peut pas les retrouver. Vérifie avec git diff avant d'annuler.

Pour ne pas confondre les deux usages :

  • git restore --staged <fichier> : retire le fichier de la staging area. Tes modifications sont gardées.
  • git restore <fichier> : efface tes modifications. Le fichier revient à la dernière version enregistrée.

« Les modifications annulées avec git restore peuvent être récupérées. » Vrai ou faux ?

Étape 10 / 13

Récap : suivre tes modifications

1

Tu modifies tes fichiers dans le working directory

2

git status : tu regardes où en sont tes fichiers

3

git diff : tu vérifies ce qui a changé

4

git add : tu prépares ce que tu veux enregistrer

5

git diff --staged : tu relis ta préparation

Ton aide-mémoire du chapitre :

$ git status # l'état de tes fichiers

$ git add <fichier> # préparer un fichier

$ git add . # préparer tout le dossier

$ git restore --staged <fichier> # retirer de la préparation

$ git diff # changements non préparés

$ git diff --staged # changements préparés

$ git restore <fichier> # annuler les modifications (définitif)

git status
— Voir l'état de tes fichiers
git add
— Préparer un fichier
git restore --staged
— Retirer un fichier de la préparation
git diff
— Voir les lignes modifiées
git restore
— Annuler les modifications d’un fichier

Étape 11 / 13

Erreurs fréquentes

  • Faire git add . sans regarder : tu prépares des fichiers que tu ne voulais pas. Lance git status avant.
  • Croire que git add enregistre : il prépare seulement. Tant que tu n'as pas fait de commit, rien n'est dans l'historique.
  • Modifier un fichier après git add : la staging area garde la version du moment où tu as fait git add. Le fichier apparaît alors dans deux sections de git status. Refais git add pour inclure tes derniers changements.
  • Confondre git restore et git restore --staged : le premier efface tes modifications, le second les garde.
  • Rester bloqué dans git diff : appuie sur q pour revenir au terminal.

Étape 12 / 13

Bonus : sous le capot

Astuce

Partie facultative, pour les curieux. Tu peux passer directement au quiz.

Quand tu fais git add, Git ne se contente pas de noter le nom du fichier. Il copie tout de suite son contenu dans le dossier .git/objects, sous la forme d’un objet appelé blob.

La staging area, elle, est un simple fichier : .git/index. Il contient la liste des fichiers préparés, avec pour chacun l'identifiant du blob correspondant. Tu peux l'afficher :

$ git ls-files --stage

100644 8b137891791fe96927ad78e64b0aad7bded08bdc 0	README.md
100644 a8c4f2d6e1b3907f5d2c4e8a1b6f3d9c0e7a2b54 0	index.html
100644 3c6e1f9a2d8b4057e1c3a9f6d2b8e4c7a1f5d3e0 0	style.css

La longue suite de chiffres et de lettres est l'identifiant (le hash) du contenu de chaque fichier. On verra au chapitre 3 comment Git s'en sert pour reconnaître chaque version.

Concept

Voilà pourquoi modifier un fichier après git add ne change pas ce qui est préparé : Git a déjà copié le contenu au moment du git add.

Étape 13 / 13

Teste tes connaissances

Vérifie que tu sais lire l'état de tes fichiers et préparer un commit. Clique sur la réponse qui te semble correcte : chaque réponse est expliquée.

Quiz · Chapitre 2

1. Dans quel ordre tes fichiers passent-ils d’une zone à l’autre ?

2. Dans git status, un fichier apparaît sous « Changes not staged for commit ». Ça veut dire…

3. Tu as fait git add style.css par erreur. Comment le retirer de la staging area sans perdre tes modifications ?

4. Dans la réponse de git diff, une ligne commence par -. Cela signifie…

5. Tu modifies index.html juste après avoir fait git add index.html. Que contient la staging area ?

6. Quelle commande montre ce qui sera enregistré au prochain commit ?

Chapitre 2 terminé

Prochaine étape : ton premier commit

Au chapitre 3, tu enregistres tes premières versions, tu lis l’historique et tu envoies ton travail sur GitHub.

Laisser un avis sur ce chapitre (optionnel)

Pour qu'on puisse te répondre si besoin.

Chapitre 2 sur 5