Git Commit | Tutoriel Git en ligne W3Docs

La commande git commit enregistre les modifications que vous avez indexées dans l'historique du dépôt sous la forme d'un nouvel instantané. Chaque commit est un point permanent et nommé vers lequel vous pouvez revenir, le comparer ou le partager avec d'autres. Cette page explique ce qu'est un commit, comment le flux de travail indexer-puis-valider s'articule, les options les plus utiles, comment rédiger de bons messages de commit et en quoi le modèle d'instantanés de Git diffère des systèmes plus anciens comme SVN.

Définition

La commande git commit enregistre toutes les modifications actuellement indexées du projet. Les commits sont créés pour capturer l'état actuel d'un projet. Les instantanés validés sont considérés comme des versions sûres d'un projet, car ils vivent dans votre historique local et Git ne les modifiera pas silencieusement. Avant d'exécuter git commit, vous utilisez la commande git add pour indexer les modifications que le commit va stocker.

Un commit est composé de trois éléments :

Un instantané de chaque fichier suivi au moment du commit (pas un diff — voir Instantanés, pas des différences ci-dessous).
Des métadonnées : l'auteur, un horodatage et le message que vous rédigez.
Un pointeur parent vers le commit précédent, qui permet à Git de construire un historique consultable avec git log.

Chaque commit est identifié par un hash SHA-1 unique de 40 caractères (par exemple 9fceb02...), que vous pouvez abréger aux sept premiers caractères pour y faire référence.

Fonctionnement

Les instantanés Git sont validés dans votre dépôt local. Git vous permet d'accumuler des commits localement plutôt que de pousser immédiatement les modifications vers un serveur central. Vous les publiez ensuite avec git push. Cette séparation offre plusieurs avantages :

Découper une fonctionnalité en commits afin que chaque étape soit petite et révisable.
Regrouper les modifications associées dans un seul commit autonome.
Nettoyer l'historique local (fusionner, reformuler, réordonner) avant de le partager.
Travailler hors ligne — vous pouvez committer dans un avion et pousser lorsque vous vous reconnectez.

Le cycle de vie typique d'une modification est le suivant : répertoire de travail → zone d'index → commit : vous modifiez des fichiers, exécutez git add pour indexer les parties souhaitées, puis git commit pour les enregistrer. Tout ce que vous n'indexez pas reste dans votre répertoire de travail et est exclu du commit.

Options courantes

git commit -a	Valide un instantané de toutes les modifications dans le répertoire de travail. Seules les modifications des fichiers déjà suivis sont incluses.
git commit -m "message de commit"	Crée un commit avec le message de commit fourni. Par défaut, git commit ouvre l'éditeur de texte configuré localement pour saisir un message de commit.
git commit -am "message de commit"	Combine les options `-a` et `-m` pour indexer tous les fichiers suivis modifiés et créer un commit avec un message en ligne.
git commit --amend	Modifie le dernier commit. Les modifications indexées sont ajoutées au commit précédent et l'éditeur s'ouvre pour permettre de modifier le message.

Avertissement

git commit -a (et -am) n'indexe que les fichiers que Git suit déjà. Les nouveaux fichiers ne sont jamais pris en compte automatiquement — vous devez d'abord exécuter git add. Utilisez git status en cas de doute.

Enregistrer des modifications avec un commit

Dans l'exemple suivant, nous avons le fichier w3docs.txt dont le contenu a été modifié sur la branche courante. Pour valider l'instantané indexé du fichier, vous devez d'abord l'indexer avec la commande git add.

Commande git add

git add w3docs.txt

L'exécution de git add déplace le fichier w3docs.txt dans la zone d'index de Git. Utilisez la commande git status pour afficher le résultat.

git status

git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: w3docs.txt

Le résultat indique que w3docs.txt sera enregistré lors du prochain commit. Le commit est créé en exécutant :

Git commit

git commit

L'exécution de git commit ouvre un éditeur de texte (configurable via git config) demandant un message de journal de commit et la liste de ce qui est validé :

git commit dans l'éditeur

# Enter the commit message of your changes. Lines that start
# with '#' will be ignored, an empty message breaks off the commit.
# On branch master
# Changes needed to be committed:
# (use "git reset HEAD ..." to unstage)
#
#modified: w3docs.txt

Le format de commit conventionnel de Git résume la modification sur la première ligne en moins de 50 caractères, suivi d'une ligne vide et d'une explication détaillée. Par exemple :

Message de commit

Change the message displayed by w3docs.txt

- Update the sayHello() function to get the username
- Change the sayGoodbye() function to a more welcoming message

La première ligne est le sujet ; le reste constitue le corps. Enregistrez et fermez l'éditeur pour finaliser le commit.

Rédiger un bon message de commit

Un message clair rend l'historique consultable et facilite la revue de code. La convention largement adoptée est la suivante :

Gardez la ligne de sujet sous 50 caractères et rédigez-la à l'impératif (« Add login form », pas « Added » ni « Adds »).
Ne terminez pas le sujet par un point.
Laissez une ligne vide entre le sujet et le corps — de nombreux outils en dépendent.
Limitez le corps à environ 72 caractères par ligne et expliquez pourquoi la modification a été effectuée, pas seulement ce qui a changé.

Valider avec un message en ligne

Pour les petites modifications à usage unique, vous pouvez généralement ignorer l'éditeur et passer le message directement :

git commit -m "Update greeting in w3docs.txt"

Utilisez git commit -am "..." pour indexer chaque fichier suivi modifié et effectuer le commit en une seule étape.

Comment mettre à jour (amender) un commit

git commit --amend remplace le commit le plus récent au lieu d'en ajouter un nouveau. C'est utile lorsque vous avez oublié d'indexer un fichier ou souhaitez corriger une faute de frappe dans le dernier message. L'éditeur s'ouvre prérempli avec le message précédent :

git add et git commit

git add w3docs.txt
git commit --amend

Pour modifier uniquement le message sans ouvrir l'éditeur :

git commit --amend -m "Corrected commit message"

Avertissement

L'amendement réécrit le dernier commit et lui attribue un nouveau hash. N'amendez que les commits que vous n'avez pas encore poussés et partagés — réécrire l'historique public oblige tous les autres à réconcilier leurs copies. Pour annuler un commit que vous n'avez pas encore partagé, utilisez git reset.

Git commit vs svn commit

SVN est un modèle d'application centralisé, tandis que Git est un modèle d'application distribué. Un commit SVN pousse les modifications du client local vers un dépôt centralisé. Dans Git, les instantanés sont validés dans le dépôt local. Les commits Git peuvent être poussés vers des dépôts distants arbitraires.

Instantanés, pas des différences

Git est basé sur des instantanés, tandis que SVN suit les différences entre les fichiers. Un svn commit enregistre un diff appliqué au fichier d'origine dans le dépôt. Git enregistre l'état complet du projet à chaque commit. Lors de l'enregistrement de l'état du projet, Git prend un instantané des fichiers actuels et stocke une référence à cet instantané. Si un fichier n'a pas changé, Git ne le stocke pas à nouveau, ce qui optimise le stockage.

Commandes associées

git add — indexer les modifications avant de les valider.
git status — voir ce qui est indexé et ce qui ne l'est pas.
git log — parcourir l'historique des commits effectués.
git reset — désindexer des fichiers ou annuler un commit.
git push — publier vos commits locaux vers un dépôt distant.

Pratique

Quelles sont les caractéristiques et les options de la commande 'git commit' ?

'git commit' enregistre toutes les modifications actuellement indexées du projet.La commande 'git commit' est utilisée pour ajouter des modifications à la zone d'index.'git commit -a' valide un instantané de toutes les modifications dans le répertoire de travail.'git commit -m' permet de créer un commit avec un message de commit spécifié.L'utilisation de 'git commit --amend' modifie le dernier commit.Les commits Git sont poussés directement vers le dépôt central.Git prend un instantané de l'état actuel des fichiers et stocke une référence à cet instantané dans chaque commit.