L’issue s’ouvre déjà remplie avec le titre et l’adresse de cette page.
Ce guide vous explique comment Git range vos fichiers et suit leurs
changements. Comprendre ce modèle interne rend la plupart de ses
messages lisibles et ses erreurs prévisibles. Vous verrez comment Git
enregistre vos données sous forme de snapshots, comment il nomme
chaque version avec un SHA, et par quelles trois zones passent vos
fichiers avant d'entrer dans l'historique.
Aucun prérequis pour lire cette leçon. Pour rejouer git hash-object, il
suffit d'avoir Git installé et un terminal. Les autres sorties
(git status, git cat-file, git log) viennent d'un dépôt que vous
créerez dans la leçon suivante : ici, lisez-les sans les rejouer.
Git enregistre à chaque commit l'état complet de votre projet. Un
commit est un point de sauvegarde, accompagné d'un message qui décrit ce
qui a changé. Les anciens systèmes de version centralisés, comme CVS ou
Subversion (SVN), font autrement : ils raisonnent en deltas, c'est-à-dire
la liste des différences d'une version d'un fichier à la suivante.
À chaque commit, Git prend donc une photo complète de tous les fichiers
suivis : un snapshot. Une photo complète ne veut pas dire une copie
complète. Un fichier inchangé n'est pas dupliqué : Git réutilise la
version déjà enregistrée et s'y réfère.
Le schéma range les mêmes trois fichiers A, B et C de deux façons. Regardez
ce que devient un fichier inchangé : avec les snapshots, il n'est qu'un lien
vers sa version précédente.
Le modèle et le stockage sur disque sont deux choses distinctes. Pour
gagner de la place, Git range régulièrement ses objets dans des fichiers
appelés packfiles, où il compresse les versions proches les unes par
rapport aux autres, avec des deltas. Cette optimisation reste invisible à
l'usage : vous manipulez toujours des snapshots. Vous pouvez retenir
simplement que le détail du stockage ne change rien à ce que vous faites.
Le modèle par snapshots rend la plupart des opérations locales et
directes. Chaque commit désigne une arborescence complète : pour
afficher une version, Git la lit telle quelle, sans rejouer une chaîne de
différences. Le tableau compare les deux familles sur ce que vous ferez au
quotidien.
Ce que vous faites
Deltas centralisés (SVN, CVS)
Snapshots distribués (Git)
Ouvrir une version passée
Requête au serveur, qui reconstruit la version
Lecture locale du snapshot
Consulter l'historique
Requête au serveur
Lecture locale de .git/
Committer sans réseau
Impossible : le commit part au serveur
Possible, le commit est local
Vérifier l'intégrité
Sommes de contrôle par fichier
Chaque objet est nommé par son empreinte
Glissez pour voir
Pour comparer deux versions, git diff calcule bien des différences, mais
seulement à la demande et entre deux snapshots. Il compare les deux
arborescences et saute d'un coup tout sous-dossier dont le contenu est
identique des deux côtés (Git le reconnaît à son empreinte, expliquée juste
après) : seuls les fichiers réellement modifiés sont lus. C'est ce qui garde
git diff rapide sur un dépôt de milliers de commits.
Les identifiants SHA : l'empreinte digitale de chaque version
Chaque objet de Git porte un nom calculé à partir de son contenu : son
SHA. Un commit, un fichier, un dossier : tout objet est identifié par une
empreinte (un hash).
Dans le format par défaut, SHA-1, elle fait 40 caractères
hexadécimaux (des chiffres et les lettres de a à f). Dans le format
SHA-256, présenté plus bas, elle en fait 64. Voici l'empreinte complète d'un
commit, en SHA-1 :
1e28c5e26a9e43fcd96ed0d8827ef57060d045c2
Ce nom n'est pas tiré au hasard : Git le calcule à partir du contenu. La
commande git hash-object le montre sur un simple texte. Ajoutez un seul
caractère, un point, et l'empreinte change entièrement.
Fenêtre de terminal
echo"Bonjour"|githash-object--stdin
echo"Bonjour."|githash-object--stdin
632e4fe73c3da8c9018008dbda117fc6b00e3e83
e03e829c1d374b5d17b6d194e4cee13b49a88788
Ces deux empreintes ne ressemblent en rien l'une à l'autre, alors que les
deux textes ne diffèrent que d'un point. Chez vous, elles sont identiques à
celles-ci (hors d'un dépôt SHA-256) : elles ne dépendent que du texte.
Le SHA n'est pas seulement une étiquette. Il apporte deux garanties qui
expliquent la solidité de Git.
Il révèle la corruption. Si un objet est abîmé (disque défaillant,
transfert réseau interrompu), son contenu ne correspond plus à son
empreinte, et git fsck le signale. Comme chaque commit contient
l'empreinte de son parent, le commit qui le précède, modifier un ancien
commit change l'empreinte de tous ceux qui suivent.
Il distingue les contenus en pratique. Deux contenus différents ne
produisent pas la même empreinte dans un dépôt réel. Depuis l'attaque
SHAttered de 2017, Git utilise une version durcie de SHA-1, qui
détecte les collisions fabriquées.
SHA-1 est le format par défaut, pas une propriété du modèle. Le projet
Git a déjà prévu d'en changer, et tout ce que vous apprenez ici reste vrai
avec un autre algorithme : seule la longueur des empreintes change. Cette
section sert de repère et peut se lire en diagonale la première fois. Dans
un dépôt, la commande suivante indique le format utilisé :
Fenêtre de terminal
gitrev-parse--show-object-format
sha1
SHA-256 existe déjà : git init --object-format=sha256 crée un tel dépôt
depuis Git 2.29. Ses empreintes font 64 caractères au lieu de 40. Les
forges (les plateformes qui hébergent des dépôts) ne savent pas toutes
héberger ce format : réservez-le à l'expérimentation pour l'instant.
Format
Longueur de l'empreinte
Taille de .git/refs/heads/<branche>
SHA-1 (défaut aujourd'hui)
40 caractères
41 octets
SHA-256
64 caractères
65 octets
Glissez pour voir
Une branche, c'est-à-dire une ligne de développement nommée, est un
petit fichier qui contient l'empreinte d'un commit, plus un saut de ligne :
d'où les 41 octets en SHA-1. Ce chiffre est un détail d'implémentation, pas
une propriété des branches. Ce qui ne change pas, c'est qu'une branche est
une référence vers un commit, et c'est pour cela qu'elle ne coûte presque
rien.
En pratique, vous verrez surtout des SHA abrégés, comme dans la sortie
de git log --oneline :
b1d8e9c Ajout de la page d'accueil
1e28c5e Création du fichier README
Chaque ligne est un commit : son empreinte abrégée, puis son message. Le
commit 1e28c5e est celui dont l'empreinte complète figure plus haut. Git
accepte une empreinte abrégée tant qu'elle reste non ambiguë dans le
dépôt. Il affiche 7 caractères par défaut et en ajoute automatiquement quand
le dépôt grossit. Vos identifiants seront différents : chaque dépôt a les
siens.
Avant d'entrer dans l'historique, un changement passe par trois zones :
le répertoire de travail, la zone de staging et le dépôt. C'est le concept
le plus important de cette leçon, parce que chaque commande de base fait
passer un changement d'une zone à l'autre.
Le schéma suit le trajet d'un fichier modifié. Les flèches pleines vont vers
l'historique (git add, puis git commit), les flèches en pointillés
reviennent en arrière (git restore).
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
Le Working Directory est le dossier de votre projet tel que vous le
voyez sur votre disque. Quand vous ouvrez un fichier dans votre éditeur et
que vous le modifiez, vous travaillez dans cette zone : Git voit la
modification, mais ne l'a encore enregistrée nulle part.
La Staging Area,
aussi appelée Index, est la zone où vous préparez votre prochain
commit. git add y copie l'état actuel d'un fichier : le fichier reste
dans votre répertoire de travail, et l'index garde la version que vous avez
ajoutée.
Ce point explique un piège classique. Si vous modifiez de nouveau un fichier
après git add, le prochain commit contiendra la version ajoutée, pas la
dernière. git status --short l'affiche avec deux lettres, MM : la
première décrit l'index, la seconde le répertoire de travail. Ici,
index.html a une modification indexée puis une autre non indexée, et
style.css une seule modification, non indexée (la première colonne est
vide).
MM index.html
M style.css
L'intérêt de cette zone est de choisir ce qui entre dans un commit. Vous
avez modifié dix fichiers, mais trois seulement concernent la même
fonctionnalité : vous n'indexez que ces trois-là, et le commit qui suit ne
portera qu'eux.
Le Repository est la base de données de Git. Il est stocké dans le
dossier .git/, à la racine du projet, et contient tous les commits, les
branches, les tags (des noms posés sur des commits précis, comme un numéro
de version) et la configuration locale du dépôt.
git commit y enregistre un nouveau snapshot, construit à partir de
l'index. Ce commit est identifié par son SHA et ne se modifie plus :
« corriger » un commit en crée en réalité un nouveau, avec une autre
empreinte.
Les trois zones se traversent toujours dans le même ordre, et chaque étape a
sa commande :
Vous modifiez un fichier dans votre éditeur. Il est modifié dans
le Working Directory.
Vous exécutez git add pour copier son état dans la Staging Area.
Il est indexé (staged).
Vous exécutez git commit pour enregistrer le snapshot dans le
Repository. Il est committé.
Pour savoir où en sont vos fichiers, git status décrit chaque zone. Ici,
index.html a été modifié puis ajouté, et style.css modifié sans être
ajouté :
Fenêtre de terminal
gitstatus
On branch main
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
modified: 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
La rubrique Changes to be committed liste la Staging Area : c'est le
contenu du prochain commit. La rubrique Changes not staged for commit
liste ce qui n'existe encore que dans le répertoire de travail. Git y
rappelle même la commande de chaque passage.
Dans cet exemple, index.html n'a pas été modifié après git add, et il
n'apparaît donc que dans la première rubrique. Modifié une seconde fois, il
figurerait dans les deux, ce que traduit le MM de git status --short. Vos fichiers
seront différents de ceux de cet exemple, et les messages s'afficheront en
français si votre système est en français.
Un commit est un petit objet texte que vous pouvez lire. La commande
git cat-file -p affiche son contenu brut : un lien vers son arborescence,
un lien vers son parent, son auteur, son committer et son message. HEAD
désigne le commit sur lequel vous vous trouvez, le dernier de votre branche.
Fenêtre de terminal
gitcat-file-pHEAD
tree 359fa95ef2a6931d2543bf7840a980e7b3ca22f9
parent 1e28c5e26a9e43fcd96ed0d8827ef57060d045c2
author Alice Martin <alice@exemple.fr> 1791966600 +0200
committer Alice Martin <alice@exemple.fr> 1791966600 +0200
Ajout de la page d'accueil
Chaque ligne a un rôle précis. Vos empreintes, votre nom et votre date
seront différents. Le nombre 1791966600 est la date en secondes écoulées
depuis le 1er janvier 1970, et +0200 le décalage horaire. L'empreinte du
commit n'y figure pas : elle est calculée à partir de ce texte, ce qui la
rend impossible à modifier sans changer le commit lui-même.
Champ
Contenu
Dans l'exemple
tree
Empreinte de l'arborescence complète, le snapshot
359fa95…
parent
Empreinte du ou des commits précédents
1e28c5e…
author
Qui a écrit les modifications, et quand
Alice Martin, puis la date en secondes
committer
Qui a créé le commit, et quand
souvent la même personne
message
La description du changement
Ajout de la page d'accueil
Glissez pour voir
Le schéma montre deux commits qui se suivent. Chacun pointe vers son
tree, la liste de ses fichiers, où chaque fichier est un blob, le
contenu d'un fichier. Le commit récent pointe aussi vers son parent. Dans
cet exemple, README.md n'a pas changé : les deux tree désignent le
même objet.
Un commit récent pointe vers son commit précédent par le champ parent, et chaque commit pointe vers un tree. Chaque tree liste des blobs. Le fichier README.md, inchangé, est un seul blob désigné par les deux tree, alors que index.html a un blob par version.parenttreetreeCommit récentauteur, messageCommit précédentauteur, messagetreeliste des fichierstreeliste des fichiersblob index.htmlnouvelle versionblob README.mdmême objetblob index.htmlancienne version
Le champ tree mène au snapshot. git cat-file -p 'HEAD^{tree}' en affiche
le contenu : chaque fichier y est un blob, désigné par son empreinte. Un
fichier inchangé d'un commit à l'autre garde la même empreinte, donc le
même objet.
Chaque ligne donne le mode du fichier (100644 désigne un fichier
ordinaire), le type d'objet, l'empreinte du contenu, puis le nom du
fichier. Vos empreintes seront différentes.
Le champ parent crée la chaîne de l'historique : chaque commit désigne
son prédécesseur, jamais l'inverse. Les flèches ne vont que dans un sens, et
on parle de graphe orienté. Le premier commit du projet n'a pas de parent,
alors qu'un commit de merge, qui réunit deux lignes de travail, en a deux.
Avec Git, presque toutes les opérations se font sur votre machine.
Votre copie contient l'historique complet du projet, là où Subversion
interroge le serveur pour afficher l'historique ou créer une branche. Au
quotidien, cela donne :
Consulter l'historique (git log) lit la copie locale, sans requête
réseau.
Comparer deux versions (git diff) se calcule sur votre disque.
Créer une branche (git branch) écrit une référence vers un commit, rien
de plus.
Committer dans le train sans Wi-Fi ne pose aucun problème : vous
synchroniserez au retour du réseau.
Seules les opérations qui parlent à un serveur distant demandent le
réseau : push, pull, fetch et clone.
Un contenu committé est très difficile à perdre, un contenu jamais
committé ne l'est pas. Git garde la trace des positions successives de
HEAD dans le reflog : même après la suppression d'une branche, ses
commits restent récupérables tant qu'ils y figurent, soit 30 jours par
défaut pour un commit qui n'est plus rattaché à aucune branche.
La leçon pratique pour un débutant : committez souvent. Un commit, même
imparfait, se retrouve et se corrige ; un travail resté dans le répertoire
de travail n'a aucune copie dans Git.
Vérifiez que l'essentiel de cette leçon 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
⏱️--:--
0 / 10
Vérification
(0/0)
--:--
0%
0Correctes
0À revoir
0:00Temps
-Niveau
Score par domaine
Un domaine regroupe plusieurs guides et reçoit plusieurs questions : son score est plus fiable qu'un score par thème, qui porte souvent sur une seule question.
Bilan
Points forts
Aucun sujet réussi à 80 % sur au moins deux questions pour l’instant.