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

Consulter l'historique Git avec git log

Par mis à jour le

Améliorer cette page

Ce guide vous apprend à explorer l'historique de vos commits avec git log. Vous allez filtrer par auteur, par date ou par fichier, chercher un mot dans les modifications et mettre en forme la sortie pour la rendre lisible. Ces gestes servent à comprendre l'évolution d'un projet et à retrouver l'origine d'un changement.

Prérequis : un dépôt avec quelques commits.

  • git log : afficher l'historique des commits
  • Options de formatage : --oneline, --graph, --pretty
  • Filtres : par auteur, date, fichier, nombre de commits
  • Recherche : trouver un commit par son contenu ou son message
  • git show : inspecter le contenu détaillé d'un commit

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

Fenêtre de terminal
git log

Sortie attendue :

commit 13b51e7deade1974a855d5e205f983356f89150b (HEAD -> main)
Author: Stéphane ROBERT <stephane@example.com>
Date: Sat Mar 28 14:30:00 2026 +0100
Ajout de la page de contact
commit d756a03e9afeeaa3310f84a7f250597af9059226
Author: Stéphane ROBERT <stephane@example.com>
Date: Sat Mar 28 10:15:00 2026 +0100
Création de la structure du projet
commit 4e527538b41cf8cba24d115df64d337f82e1f28a
Author: Stéphane ROBERT <stephane@example.com>
Date: Fri Mar 27 16:00:00 2026 +0100
Initial commit

Chaque commit affiche son SHA complet, l'auteur, la date et le message. Sur un projet avec beaucoup de commits, cette sortie défile. Appuyez sur q pour quitter le pager.

Les exemples de ce guide viennent d'un petit dépôt de test (le graphe, plus bas, d'une variante avec une branche). Vos SHA, vos dates et vos noms seront différents. (HEAD -> main) indique que vous êtes sur la branche main et que ce commit en est le dernier ; la section « Désigner un commit avec HEAD et HEAD~1 » détaille HEAD.

C'est la mise en forme de lecture courante : chaque commit tient sur une ligne.

Fenêtre de terminal
git log --oneline

Sortie attendue :

13b51e7 (HEAD -> main) Ajout de la page de contact
d756a03 Création de la structure du projet
4e52753 Initial commit

Le SHA est abrégé automatiquement. La longueur n'est pas fixe : Git choisit le nombre de caractères nécessaire pour que l'identifiant reste unique dans votre dépôt, ce que pilote le réglage core.abbrev dont la valeur par défaut est auto. Sur un dépôt qui vient de naître, vous verrez 7 caractères ; sur un dépôt de plusieurs milliers de commits, Git passe à 8 ou plus de lui-même. Ne codez donc jamais « 7 » en dur dans un script qui compare des SHA.

Pour visualiser les branches et les merges dans le terminal :

Fenêtre de terminal
git log --oneline --graph --all --decorate

Sortie attendue (projet avec des branches) :

* 913676d (HEAD -> main) Merge branch 'feature/contact'
|\
| * 999dd51 (feature/contact) Ajout du formulaire de contact
| * 9babff9 Styles du formulaire
|/
* d756a03 Création de la structure du projet
* 4e52753 Initial commit

Les lignes |, \ et / dessinent les branches. L'étoile * marque chaque commit. Ici, feature/contact s'est séparée de main après le commit d756a03, puis le commit de fusion 913676d les a réunies.

Pour un contrôle total sur l'affichage :

Fenêtre de terminal
git log --pretty=format:"%h %an %ar %s"

Sortie attendue :

13b51e7 Stéphane ROBERT 2 hours ago Ajout de la page de contact
d756a03 Stéphane ROBERT 6 hours ago Création de la structure du projet
4e52753 Stéphane ROBERT 1 day ago Initial commit

Le tableau ci-dessous liste les substitutions les plus utiles. Une distinction revient sans arrêt et vaut d'être fixée tout de suite : le préfixe a désigne l'auteur, celui qui a écrit le changement, tandis que le préfixe c désigne le committer, celui qui a créé l'objet commit. Sur un historique ordinaire les deux sont identiques, mais un rebase ou l'application d'un patch envoyé par un tiers les sépare. Si vous cherchez « qui a fait ça », prenez %an ; si vous cherchez « quand est-ce arrivé dans cette branche », prenez %cd.

Les principaux placeholders :

PlaceholderSignificationExemple
%HSHA complet13b51e7deade...
%hSHA abrégé13b51e7
%anNom de l'auteurStéphane ROBERT
%aeEmail de l'auteurstephane@example.com
%arDate relative2 hours ago
%aiDate ISO (avec fuseau)2026-03-28 14:30:00 +0100
%sMessage (première ligne)Ajout de la page de contact
%dNoms de ref (branches, tags)(HEAD -> main)

Un message de commit est parfois vague, et un diff complet parfois trop long à lire. --stat donne entre les deux la liste des fichiers touchés par chaque commit, avec leur nombre de lignes. Il aide à vérifier qu'un commit n'a pas touché autre chose que ce qu'annonce son message : un commit intitulé « correction de typo » qui modifie 400 lignes dans 12 fichiers mérite une inspection.

Fenêtre de terminal
git log --stat --oneline

Sortie attendue :

13b51e7 Ajout de la page de contact
contact.html | 25 +++++++++++++++++++++++++
style.css | 8 ++++++++
2 files changed, 33 insertions(+)

Le --stat affiche la liste des fichiers modifiés avec le nombre de lignes ajoutées (+) et supprimées (-).

Pour afficher le diff complet de chaque commit :

Fenêtre de terminal
git log -p -1

L'option -1 limite à un seul commit. Sans cette limite, git log -p affiche le diff de chaque commit (très verbeux sur un long historique).

Le nombre s'écrit directement collé au tiret, sans nom d'option. Ce filtre s'applique après tous les autres : git log --author="Alice" -5 renvoie les 5 derniers commits d'Alice, pas les commits d'Alice parmi les 5 derniers du dépôt. La distinction change complètement le résultat sur un dépôt à plusieurs contributeurs.

Fenêtre de terminal
git log -5 # Les 5 derniers commits
git log --oneline -10 # Les 10 derniers, format compact
Fenêtre de terminal
git log --author="Stéphane"

Git cherche le pattern dans le nom et l'email de l'auteur. Vous pouvez utiliser des expressions régulières :

Fenêtre de terminal
git log --author="alice\|bob" # Commits d'Alice OU Bob

Ces options acceptent aussi bien une date absolue qu'une expression en anglais du type 2 weeks ago, yesterday ou last monday. Deux précisions évitent des surprises. Les deux bornes sont inclusives, un commit horodaté exactement sur la date passée en argument sort donc bien dans les résultats. Surtout, le filtre porte sur la date du committer, pas sur celle de l'auteur : un commit écrit en janvier puis rejoué par un rebase en juin ressort avec --since="2026-05-01" et reste invisible si vous cherchez dans la fenêtre de janvier.

Fenêtre de terminal
git log --since="2026-03-01" # Depuis le 1er mars
git log --until="2026-03-15" # Jusqu'au 15 mars
git log --since="2 weeks ago" # 2 dernières semaines
git log --since="2026-03-01" --until="2026-03-15" # Période précise

Pour voir uniquement les commits qui ont modifié un fichier précis :

Fenêtre de terminal
git log -- style.css
git log --oneline -- src/auth/

Le -- sépare les options de la liste de chemins. Il est optionnel quand il n'y a pas d'ambiguïté, mais c'est une bonne habitude de toujours le mettre.

Fenêtre de terminal
git log --grep="contact"

Cherche le motif « contact » dans les messages de commit. Le motif est traité comme une expression régulière, pas comme un texte littéral : un point ou une parenthèse dans votre recherche prendra donc sa valeur de métacaractère.

La recherche est sensible à la casse par défaut : ajoutez -i pour l'ignorer. Plusieurs --grep se combinent avec un OU logique, sauf si vous ajoutez --all-match pour exiger que toutes les conditions soient remplies.

Pour trouver le commit qui a ajouté ou supprimé un mot dans le code :

Fenêtre de terminal
git log -S "function login"

L'option -S, surnommée pickaxe, retrouve le moment où une fonction, une variable ou une clé de configuration a été introduite ou retirée. Son critère exact mérite d'être connu : Git ne cherche pas les commits qui mentionnent la chaîne, mais ceux où le nombre d'occurrences a changé. Un commit qui déplace une ligne sans la modifier n'apparaît donc pas, ce qui est précisément l'intérêt de l'option. La chaîne est traitée littéralement ; pour une expression régulière, utilisez -G à la place. La leçon rechercher dans Git développe -S, -G et -L.

Fenêtre de terminal
git log -S "API_KEY" --oneline

Les filtres se combinent naturellement :

Fenêtre de terminal
git log --author="Alice" --since="2026-03-01" --oneline -- src/

Cette commande affiche les commits d'Alice depuis le 1er mars qui ont touché des fichiers dans le dossier src/.

Pour voir le contenu détaillé d'un commit spécifique :

Fenêtre de terminal
git show 13b51e7

Sortie attendue :

commit 13b51e7deade1974a855d5e205f983356f89150b
Author: Stéphane ROBERT <stephane@example.com>
Date: Sat Mar 28 14:30:00 2026 +0100
Ajout de la page de contact
diff --git a/contact.html b/contact.html
new file mode 100644
index 0000000..b9ece5a
--- /dev/null
+++ b/contact.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+...

git show affiche les métadonnées du commit et le diff complet des modifications. Vous pouvez utiliser un SHA abrégé : il suffit tant qu'il reste unique.

Pour voir les fichiers modifiés et leur nombre de lignes, sans le diff complet :

Fenêtre de terminal
git show --stat 13b51e7

Sortie obtenue avec Git 2.47.3 :

commit 13b51e7deade1974a855d5e205f983356f89150b
Author: Stéphane ROBERT <stephane@example.com>
Date: Sat Mar 28 14:30:00 2026 +0100
Ajout de la page de contact
contact.html | 25 +++++++++++++++++++++++++
style.css | 8 ++++++++
2 files changed, 33 insertions(+)

HEAD désigne le commit sur lequel vous êtes, le dernier de la branche courante. HEAD~1 désigne le commit d'avant, son parent, et HEAD~2 remonte de deux commits. Ces noms évitent de recopier un SHA : vous les placez partout où git show ou git log attendent un commit.

Sur l'historique de cette page, git show --stat HEAD affiche le commit 13b51e7 et git show --stat HEAD~1 affiche celui d'avant :

Fenêtre de terminal
git show --stat HEAD~1
commit d756a03e9afeeaa3310f84a7f250597af9059226
Author: Stéphane ROBERT <stephane@example.com>
Date: Sat Mar 28 10:15:00 2026 +0100
Création de la structure du projet
index.html | 4 ++++
style.css | 10 ++++++++++
2 files changed, 14 insertions(+)

Pour vérifier que HEAD~1 pointe bien sur le commit précédent, comparez son SHA complet, que donne git rev-parse, avec la deuxième ligne de git log :

Fenêtre de terminal
git rev-parse HEAD~1
git log --oneline -2
d756a03e9afeeaa3310f84a7f250597af9059226
13b51e7 Ajout de la page de contact
d756a03 Création de la structure du projet

Le SHA complet commence par d756a03 : c'est le commit de la deuxième ligne, donc HEAD~1 désigne bien le commit d'avant. Pour d'autres façons de désigner un commit (HEAD^, plages A..B), voyez la leçon sélection de révisions.

Ce tableau se lit par la colonne de gauche : partez du besoin, pas de l'option. C'est le bon réflexe avec git log, dont les options sont nombreuses mais se combinent librement dans une même ligne de commande. Les cinq premières lignes concernent la mise en forme de la sortie, les cinq suivantes la sélection des commits affichés, et les deux dernières servent à inspecter un commit. Vous mêlerez souvent les deux premières familles, comme un --oneline de mise en forme avec un --author de sélection.

BesoinCommande
Historique de basegit log
Compact (1 ligne/commit)git log --oneline
Avec graphe de branchesgit log --oneline --graph --all
Fichiers modifiés par commitgit log --stat
Diff completgit log -p
Par auteurgit log --author="nom"
Par dategit log --since="date" --until="date"
Par fichiergit log -- chemin/fichier
Par messagegit log --grep="mot"
Par contenu de codegit log -S "code"
Détail d'un commitgit show SHA
Le commit d'avantgit show HEAD~1

Un « git log ne trouve rien » vient souvent de l'une de ces trois causes : la commande cherche là où vous ne croyez pas, le motif n'est pas interprété comme vous le pensez, ou l'historique local n'est pas à jour. Avant de conclure qu'un commit a disparu, relancez la même recherche sans aucun filtre : si le commit apparaît, c'est bien un filtre qui l'écarte, et le tableau ci-dessous vous dira lequel.

SymptômeCause probableSolution
git log ne montre rienAucun commit dans le dépôtVérifiez avec git status puis créez un premier commit
La sortie défile sans finPager actif (normal)Appuyez sur q pour quitter
git log --all ne montre pas les branches distantesBranches pas encore récupéréesgit fetch --all puis relancez
git log -S ne trouve pas le résultat attendu-S cherche une chaîne littérale, les métacaractères ne sont pas interprétésAjoutez --pickaxe-regex, ou utilisez git log -G "motif" qui prend une expression régulière
--grep ne trouve pas un message pourtant présentRecherche sensible à la casseAjoutez -i : git log --grep="contact" -i
--author ne trouve personneLe nom ne correspond pas exactementEssayez avec un fragment : --author="début du nom"
  • git log --oneline est votre vue quotidienne de l'historique
  • git log --graph --all visualise les branches et les merges
  • Filtrez par auteur (--author), date (--since/--until), fichier (-- chemin) ou contenu (-S "code")
  • git show SHA inspecte le contenu détaillé d'un commit
  • HEAD est le dernier commit, HEAD~1 celui d'avant
  • Combinez les filtres pour des recherches précises
  • Créez un alias git lg pour le graphe quotidien

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