Git Log - Comment utiliser Git Log

La commande git log est votre fenêtre sur l'historique d'un projet. Elle liste les commits enregistrés dans le dépôt, du plus récent au plus ancien, et offre un riche ensemble d'options pour filtrer, rechercher et reformater cet historique. Cette page explique ce que git log affiche, comment lire sa sortie par défaut, les options les plus utilisées, et comment les combiner pour répondre à des questions concrètes telles que « qui a modifié ce fichier ? » ou « qu'est-ce qui a été intégré entre deux versions ? »

Ce que git log affiche

git log affiche les instantanés commitées d'un dépôt — l'historique permanent stocké par Git. C'est une distinction importante : git log ne montre jamais le travail non commité. Pour inspecter le répertoire de travail et la zone de staging, utilisez git status ; pour voir les modifications ligne par ligne qui ne sont pas encore commitées, utilisez git diff.

Exécutée sans arguments, la commande remonte depuis le commit actuel (HEAD) jusqu'à chaque parent :

git log

Une entrée typique ressemble à ceci :

commit 1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b (HEAD -> master)
Author: Bob Smith <[email protected]>
Date:   Mon Jun 16 10:24:31 2026 +0400

    Add login form validation

Chaque commit affiche son hash SHA-1 de 40 caractères, l'auteur, la date et le message de commit. Par défaut, la sortie est paginée : appuyez sur Space pour faire défiler, q pour quitter. Les commits sont affichés dans l'ordre chronologique inverse.

Options couramment utilisées

La sortie du log peut être personnalisée de nombreuses façons, du filtrage des commits à leur affichage dans un format entièrement personnalisé. Voici les options les plus utiles :

Commande	Description
`git log`	Affiche l'historique complet des commits dans le format par défaut. Utilisez `Space` pour faire défiler et `q` pour quitter si la sortie s'étend sur plusieurs écrans.
`git log -n <limit>`	Limite le nombre de commits affichés. Par exemple, `git log -n 2` affiche uniquement les 2 commits les plus récents.
`git log --oneline`	Condense chaque commit sur une seule ligne (hash court + résumé) — idéal pour un aperçu rapide.
`git log --stat`	Ajoute la liste des fichiers modifiés ainsi que le nombre de lignes ajoutées et supprimées pour chaque commit.
`git log -p`	Affiche le patch complet (diff) introduit par chaque commit.
`git log --author="<pattern>"`	Filtre les commits par un auteur spécifique. `<pattern>` peut être une chaîne simple ou une expression régulière.
`git log --grep="<pattern>"`	Filtre les commits dont le message correspond à `<pattern>` (chaîne ou regex).
`git log <since>..<until>`	Affiche uniquement les commits accessibles depuis `<until>` mais pas depuis `<since>`. Chaque côté peut être un ID de commit, un nom de branche, un tag, `HEAD` ou toute autre référence de révision.
`git log <file>`	Affiche uniquement les commits qui ont touché le fichier donné — son historique de modifications.
`git log --graph --decorate --oneline`	Dessine un graphe textuel de la structure des branches et des fusions, étiquette les branches et les tags, et affiche une ligne par commit.
`git log --since="<date>"`	Affiche les commits plus récents qu'une date (par exemple `"2 weeks ago"` ou `"2026-01-01"`).
`git log --until="<date>"`	Affiche les commits plus anciens qu'une date.
`git log --all`	Affiche les commits de toutes les branches et références, pas seulement la branche courante.

Un aperçu compact

Pour parcourir rapidement l'historique, --oneline est l'option de référence. Combinée avec --graph et --decorate, elle transforme le log en une carte lisible de vos branches :

git log --graph --decorate --oneline

* 1a2b3c4 (HEAD -> master) Add login form validation
* 9f8e7d6 Fix typo in README
| * 4c5d6e7 (feature) Start checkout flow
|/
* 0a1b2c3 Initial commit

Les astérisques et les lignes de connexion montrent comment les branches ont divergé et fusionné ; (HEAD -> master) et (feature) sont les décorations ajoutées par --decorate.

Filtrer l'historique

La véritable puissance de git log réside dans la capacité à réduire des milliers de commits à ceux qui vous intéressent.

Par auteur et contenu

Pour trouver toutes les modifications apportées par un auteur particulier à un fichier donné, combinez --author, -p et un chemin de fichier :

git log --author="Bob Smith" -p w3docs.txt

Cela affiche le diff complet de chaque modification que Bob a apportée à w3docs.txt. Pour rechercher dans les messages de commit plutôt que dans les auteurs, utilisez --grep :

git log --grep="bugfix"

Par date

git log --since="2 weeks ago" --until="yesterday"

--since et --until acceptent des dates absolues (2026-01-01) ou des expressions relatives conviviales ("3 days ago", "last Monday").

Entre deux références

La syntaxe <since>..<until> (double point) répond à la question « qu'est-ce qui est dans B et pas dans A ? » — parfaite pour comparer des branches avant une fusion :

git log --oneline master..some-feature

Cela liste chaque commit sur some-feature qui n'a pas encore été intégré dans master. Inversez les côtés pour voir l'inverse. Les tags fonctionnant également comme références de révision, la même syntaxe est idéale pour les notes de version :

git log --oneline v1.0..v2.0

Inspecter l'historique d'un fichier

Lorsque vous avez besoin de comprendre comment un fichier a évolué, passez son chemin :

git log --oneline -- src/app.js

Le séparateur -- indique à Git que tout ce qui suit est un chemin, ce qui évite toute ambiguïté lorsqu'un fichier et une branche portent le même nom. Pour voir les modifications réelles en plus de l'historique, ajoutez -p. Si vous avez plutôt besoin de savoir qui a modifié chaque ligne en dernier, utilisez git blame. Pour inspecter le contenu complet d'un commit spécifique, utilisez git show.

Pièges courants

git log n'affiche que l'historique commité. Le travail mis en stash, en staging ou non sauvegardé n'apparaîtra pas — consultez git status et git stash pour cela.
Par défaut, seule la branche courante est affichée. Ajoutez --all pour inclure toutes les branches, ou nommez explicitement une branche ou une référence.
Les commits perdus peuvent souvent être récupérés. Même les commits qu'aucune branche ne pointe peuvent rester accessibles via git reflog.
A..B n'est pas symétrique. master..feature et feature..master retournent des commits différents ; l'ordre est important.

Pratique

Quelles sont les fonctionnalités et options de la commande 'git log' ?

'git log' affiche l'état du répertoire de travail et de la zone de staging.'git log' est utilisé pour lister et filtrer l'historique du projet et rechercher des modifications particulières.'git log --oneline' affiche chaque commit sur une seule ligne pour un aperçu de l'historique du projet.'git log -p' affiche le patch et le diff complet pour chaque commit.'git log --author=' `<pattern>` ' recherche les commits d'un auteur spécifié.'git log <file>' affiche l'historique des modifications apportées à un fichier spécifique.'git log --graph --decorate --oneline' crée un graphe textuel des commits avec les noms des branches et des tags.La commande 'git log' peut être utilisée pour créer de nouvelles branches.