Aller au contenu principal

Prise en main de Git · Chapitre 3 / 5

Enregistrer tes modifications

Un commit, c'est une version enregistrée de ton projet. Tu apprends à en créer, à lire l'historique, à corriger une erreur et à tout envoyer sur GitHub.

Chapitre 3 / 5

Étape 01 / 13

Dans ce chapitre

Tes fichiers sont prêts dans la staging area. Il est temps de les enregistrer pour de bon dans l'historique, puis de les envoyer sur GitHub.

À la fin de ce chapitre, tu sauras :

  • Créer un commit et écrire un message clair
  • Lire l'historique avec git log
  • Corriger ton dernier commit
  • Revenir à une version précédente
  • Ignorer des fichiers avec .gitignore
  • Envoyer tes commits sur GitHub avec git push, et récupérer ceux des autres avec git pull

Étape 02 / 13

Un commit, c'est quoi ?

Concept

Commit : une version enregistrée de ton projet. C’est une photo complète de tous les fichiers suivis, au moment où tu la prends.

Un commit contient :

  • Une photo (en anglais snapshot) de tous tes fichiers suivis
  • Un message qui explique ce que tu as fait
  • L'auteur (le nom et l'email configurés au chapitre 1) et la date
  • Un identifiant unique, appelé hash, par exemple 8c4e2f1
  • Un lien vers le commit précédent, son parent : c'est ce qui forme l'historique

Voici à quoi ressemble un commit dans l’historique :

# Un commit, tel que Git l'affiche

commit 8c4e2f1a7b3d9e0f5a6c2b1d4e7f8a9b0c1d2e3f (HEAD -> main)
Author: Camille Martin <camille@example.com>
Date:   Mon Oct 19 10:24:18 2026 +0200

    Ajouter le formulaire de contact

L'analogie

Dans le cahier du photographe, un commit, c'est une page : la photo collée, la date et la légende écrite en dessous. Les pages se suivent dans l'ordre, et on ne les arrache pas.

Étape 03 / 13

Créer un commit : git commit

Un commit enregistre tout ce qui se trouve dans la staging area. Tu dois donc avoir fait git add avant. La commande :

$ git commit -m "<message>"

L'option -m (pour message) te permet d'écrire le message directement dans la commande. Par exemple, pour le tout premier commit de mon-portfolio :

$ git add index.html style.css README.md

$ git commit -m "Ajouter la page d'accueil"

[main (root-commit) 3f2a1b4] Ajouter la page d'accueil
 3 files changed, 42 insertions(+)
 create mode 100644 README.md
 create mode 100644 index.html
 create mode 100644 style.css

Git te répond avec un résumé :

  • main : la branche sur laquelle le commit est créé
  • root-commit : c'est le tout premier commit du dépôt (cette mention n'apparaît qu'une fois)
  • 3f2a1b4 : le début de l'identifiant du commit
  • 3 files changed, 42 insertions(+) : 3 fichiers concernés, 42 lignes ajoutées

Astuce

Si tu oublies -m, Git ouvre un éditeur de texte dans le terminal pour que tu écrives le message. Si tu es bloqué dans cet éditeur (souvent Vim) : appuie sur Échap, tape :q! puis Entrée. Tu sors sans commiter, et tu peux relancer la commande avec -m.

Si la staging area est vide, Git ne crée rien et te le dit :

$ git commit -m "Mettre à jour le menu"

On branch main
Changes not staged for commit:
	modified:   index.html

no changes added to commit (use "git add" and/or "git commit -a")

Qu'enregistre git commit ?

Étape 04 / 13

Écrire un bon message de commit

Dans six mois, toi ou un collègue lirez l'historique pour comprendre ce qui s'est passé. Le message est là pour ça. Quelques règles simples :

  • Commence par un verbe à l'infinitif : Ajouter, Corriger, Supprimer, Mettre à jour.
  • Reste court : une cinquantaine de caractères au maximum.
  • Sois précis : on doit comprendre le changement sans ouvrir les fichiers.
  • Un commit = un seul sujet. Si ton message contient « et », c'est peut-être deux commits.

Quelques exemples :

  • Bon : « Corriger l'affichage du menu sur mobile »
  • Bon : « Ajouter le formulaire de contact »
  • À éviter : « fix » (on ne sait pas ce qui est corrigé)
  • À éviter : « modifs » ou « wip » (aucune information)
  • À éviter : « Ajouter le formulaire et corriger le menu et changer les couleurs » (trois sujets)

À pratiquer

Commite souvent, par petites étapes. Un petit commit est facile à comprendre, à vérifier et à annuler si besoin.

Quel message de commit est le plus utile ?

Étape 05 / 13

Voir l'historique : git log

git log affiche la liste des commits, du plus récent au plus ancien :

$ git log

commit 8c4e2f1a7b3d9e0f5a6c2b1d4e7f8a9b0c1d2e3f (HEAD -> main)
Author: Camille Martin <camille@example.com>
Date:   Mon Oct 19 10:24:18 2026 +0200

    Ajouter le formulaire de contact

commit 5b9d3a7e2c1f8b4a6d0e9c3f7a2b5d8e1c4f6a90
Author: Camille Martin <camille@example.com>
Date:   Sun Oct 18 16:02:51 2026 +0200

    Corriger le menu sur mobile

Pour une vue compacte, une ligne par commit :

$ git log --oneline

8c4e2f1 (HEAD -> main) Ajouter le formulaire de contact
5b9d3a7 Corriger le menu sur mobile
3f2a1b4 Ajouter la page d'accueil

(HEAD -> main) indique où tu te trouves : sur la branche main, au commit le plus récent. On reparlera de HEAD au chapitre 4.

Astuce

Quand l'historique est long, git log s'affiche page par page. Défile avec les flèches ou la barre d'espace, et appuie sur la touche q pour quitter.

Pour voir le détail d’un commit précis, utilise git show avec son identifiant :

$ git show 5b9d3a7

# Affiche le message du commit, puis les lignes modifiées (comme git diff)

git log affiche une longue liste et tu ne peux plus taper de commande. Que fais-tu ?

Étape 06 / 13

Corriger le dernier commit : --amend

Une faute de frappe dans le message ? Un fichier oublié ? Tant que tu n'as pas envoyé le commit sur GitHub, tu peux corriger le dernier commit avec l'option --amend.

Changer le message du dernier commit :

$ git commit --amend -m "Ajouter le formulaire de contact"

Ajouter un fichier oublié dans le dernier commit, sans changer le message :

$ git add contact.css

$ git commit --amend --no-edit

Attention

--amend remplace le dernier commit par un nouveau, avec un nouvel identifiant. Ne l'utilise pas sur un commit déjà envoyé avec git push : l'historique de GitHub ne correspondrait plus au tien.

« Je peux utiliser --amend sans risque sur un commit déjà envoyé avec git push. » Vrai ou faux ?

Étape 07 / 13

Revenir à une version précédente

Tu veux annuler un ou plusieurs commits ? Il y a deux cas.

Cas 1 : les commits sont seulement sur ton ordinateur (pas encore envoyés). Utilise git reset avec l'identifiant du commit où tu veux revenir :

$ git reset <id-du-commit>

$ git reset 5b9d3a7

Unstaged changes after reset:
M	index.html

Les commits qui venaient après 5b9d3a7 disparaissent de l'historique. Mais leurs modifications ne sont pas perdues : elles sont revenues dans tes fichiers, comme si tu ne les avais pas encore enregistrées. Tu peux les corriger, puis refaire un commit propre.

Attention

Tu verras parfois git reset --hard. Cette option efface aussi les modifications de tes fichiers, sans retour possible. Évite-la tant que tu débutes.

Cas 2 : les commits sont déjà sur GitHub. Ne réécris pas un historique partagé. Utilise plutôt git revert, qui crée un nouveau commit faisant exactement l'inverse :

$ git revert --no-edit 8c4e2f1

[main 1e6b2d9] Revert "Ajouter le formulaire de contact"
 1 file changed, 30 deletions(-)

L'option --no-edit garde le message proposé par Git. L'erreur reste visible dans l'historique, avec sa correction juste après : tout le monde comprend ce qui s'est passé.

Astuce

Pour retrouver l'identifiant d'un commit, utilise git log --oneline. Les 7 premiers caractères suffisent.

Le commit à annuler est déjà sur GitHub. Quelle commande utiliser ?

Étape 08 / 13

Ignorer des fichiers : .gitignore

Certains fichiers ne doivent jamais être enregistrés dans Git :

  • Les fichiers secrets : mots de passe, clés d'accès (souvent dans un fichier .env)
  • Les dépendances téléchargées, lourdes et faciles à réinstaller : le dossier node_modules/
  • Les fichiers créés automatiquement par ton système ou tes outils : .DS_Store sur macOS, fichiers .log

Pour que Git les ignore, crée un fichier nommé .gitignore à la racine du projet, et écris un modèle par ligne :

# Contenu du fichier .gitignore

# Secrets
.env

# Dépendances
node_modules/

# Fichiers système et journaux
.DS_Store
*.log

# Exception : ce fichier-là, on le garde
!important.log

Comment lire ces modèles :

  • .env : ignore le fichier .env
  • node_modules/ : ignore tout le dossier node_modules
  • *.log : l'étoile remplace n'importe quel nom, donc tous les fichiers qui finissent par .log
  • !important.log : le point d'exclamation crée une exception, ce fichier est gardé
  • # : une ligne de commentaire, ignorée par Git

Le fichier .gitignore, lui, doit être enregistré : toute l’équipe en profite.

$ git add .gitignore

$ git commit -m "Ajouter le fichier .gitignore"

Attention

.gitignore n'agit que sur les fichiers pas encore suivis. Si tu as déjà commité un fichier par erreur, retire-le du suivi avec git rm --cached <fichier> (il reste sur ton disque), puis commite. Et si c'était un mot de passe, change-le : il reste visible dans l'historique.

.env
— Ignore le fichier .env
node_modules/
— Ignore tout le dossier node_modules
*.log
— Ignore tous les fichiers qui finissent par .log
!important.log
— Garde ce fichier malgré la règle

Étape 09 / 13

Envoyer tes commits sur GitHub : git push

Tes commits sont sur ton ordinateur. Pour les envoyer sur le dépôt distant relié au chapitre 1, utilise git push. La première fois, précise où envoyer :

$ git push -u origin main

Enumerating objects: 9, done.
Counting objects: 100% (9/9), done.
Writing objects: 100% (9/9), 1.20 KiB | 1.20 MiB/s, done.
Total 9 (delta 1), reused 0 (delta 0)
To https://github.com/camille-dev/mon-portfolio.git
 * [new branch]      main -> main
branch 'main' set up to track 'origin/main'.

origin est le dépôt distant, main la branche. L'option -u mémorise ce lien : les fois suivantes, un simple git push suffit.

$ git push

Astuce

La première fois, GitHub te demande de te connecter. Ton mot de passe GitHub ne fonctionne pas dans le terminal. Le plus simple : installe GitHub CLI et lance gh auth login, ou utilise GitHub Desktop. Tu peux aussi créer un jeton d'accès (token) dans les réglages de GitHub.

À l'inverse, pour récupérer les commits que d'autres ont envoyés sur GitHub :

$ git pull

Updating 8c4e2f1..d71a3c9
Fast-forward
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

À pratiquer

Bonne habitude : git pull avant de commencer à travailler, git push quand tu as fini. Ton dépôt local et GitHub restent synchronisés.

Que fait l'option -u dans git push -u origin main ?

Étape 10 / 13

Récap : enregistrer tes modifications

1

git add : tu prépares tes fichiers

2

git commit -m "message" : tu enregistres une version

3

git log --oneline : tu vérifies l'historique

4

git push : tu envoies tes commits sur GitHub

Ton aide-mémoire du chapitre :

$ git commit -m "message" # enregistrer la staging area

$ git commit --amend -m "message" # corriger le dernier commit

$ git log # historique détaillé

$ git log --oneline # historique compact

$ git show <id> # détail d'un commit

$ git reset <id> # revenir à un commit (non envoyé)

$ git revert <id> # annuler un commit déjà envoyé

$ git rm --cached <fichier> # ne plus suivre un fichier

$ git push # envoyer sur le dépôt distant

$ git pull # récupérer depuis le dépôt distant

git commit -m
— Enregistrer une version
git log --oneline
— Voir l'historique en bref
git commit --amend
— Corriger le dernier commit
git revert
— Annuler un commit déjà partagé
git push
— Envoyer tes commits sur GitHub

Étape 11 / 13

Erreurs fréquentes

  • Commiter sans git add : Git répond « no changes added to commit ». Prépare d'abord tes fichiers avec git add.
  • Des messages vagues comme « fix » ou « update » : dans un mois, plus personne ne sait ce qu'ils contiennent.
  • Faire un énorme commit en fin de journée : préfère plusieurs petits commits, un par sujet.
  • Utiliser --amend ou git reset sur des commits déjà envoyés : ton historique ne correspond plus à celui de GitHub. Utilise git revert à la place.
  • Commiter un fichier .env avec des mots de passe : ajoute-le au .gitignore dès le début du projet.
  • « rejected (fetch first) » au moment du git push : GitHub a des commits que tu n'as pas encore. Fais git pull, puis git push.

Étape 12 / 13

Bonus : sous le capot

Astuce

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

Chaque commit a un identifiant comme 8c4e2f1a7b3d9e0f5a6c2b1d4e7f8a9b0c1d2e3f. On l'appelle hash (ou SHA). Git le calcule à partir du contenu du commit : les fichiers, le message, l'auteur, la date et le parent.

Conséquence : si un seul caractère change, le hash change complètement. C'est une empreinte digitale. Deux contenus différents n'ont pas le même hash, et Git repère immédiatement toute modification.

Un commit est fait de plusieurs objets rangés dans .git/objects :

  • Blob : le contenu d'un fichier (sans son nom)
  • Tree : un dossier, c'est-à-dire la liste des noms de fichiers et de leurs blobs
  • Commit : un lien vers le tree principal, plus le message, l'auteur, la date et le parent

commit

message, auteur, date, parent

pointe vers

tree

le dossier (noms + liens)

contient

blob

le contenu brut du fichier

Un commit pointe vers un tree, qui liste des blobs (et d’autres trees pour les sous-dossiers).

Tu peux inspecter le dernier commit avec git cat-file :

$ git cat-file -p HEAD

tree 9f3b2e1d7c6a5b4e8f0d1c2a3b4e5f6a7b8c9d0e
parent 5b9d3a7e2c1f8b4a6d0e9c3f7a2b5d8e1c4f6a90
author Camille Martin <camille@example.com> 1792398258 +0200
committer Camille Martin <camille@example.com> 1792398258 +0200

Ajouter le formulaire de contact

Concept

Si un fichier n'a pas changé entre deux commits, Git ne le recopie pas : il réutilise le même blob. Chaque commit est une photo complète du projet, mais le stockage reste léger.

$ git hash-object

0d462e0

Le hash dépend de tout le contenu : une lettre en plus, en moins, ou en majuscule, et le résultat est complètement différent. Mais le même contenu redonne toujours le même hash — c'est ce qui garantit l'intégrité de ton historique.

Étape 13 / 13

Teste tes connaissances

Vérifie que tu sais enregistrer, corriger et partager tes versions. Clique sur la réponse qui te semble correcte : chaque réponse est expliquée.

Quiz · Chapitre 3

1. Que fait git commit -m "message" ?

2. Quel message de commit est le plus utile ?

3. Tu viens de commiter (sans avoir poussé) et tu as oublié un fichier. Que fais-tu ?

4. Un commit fautif est déjà sur GitHub. Quelle est la façon sûre de l’annuler ?

5. Quelle ligne de .gitignore ignore tous les fichiers qui finissent par .log ?

6. À quoi sert l’option -u dans git push -u origin main ?

Chapitre 3 sur 5

L'enquête ne fait que commencer, la suite t'attend...

Ton avis compte

Aide-nous à améliorer cette formation en partageant ton retour.

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