La commande git commit capture un instantané des changements actuellement stagés du projet. Les instantanés commités peuvent être considérés comme des versions « sûres » d'un projet. Git ne les modifiera jamais, sauf si vous le lui demandez explicitement. Avant d'exécuter git commit, la commande git add est utilisée pour promouvoir ou « stager » les changements apportés au projet qui seront stockés dans un commit. Ces deux commandes git commit et git add font partie des plus fréquemment utilisées.

Commit Git et commit SVN

Bien qu'elles portent le même nom, git commit n'a rien à voir avec svn commit. Ce nom partagé peut semer la confusion chez les débutants dans Git qui ont déjà utilisé SVN, et il est important de souligner la différence. Comparer git commit et svn commit revient à comparer un modèle d'application centralisée (SVN) et un modèle d'application distribuée (Git). Dans SVN, un commit fait un push de changements du client SVN local vers un dépôt SVN partagé, centralisé et distant. Dans Git, les dépôts sont distribués, les instantanés sont commités dans le dépôt local, ce qui ne nécessite aucune interaction avec d'autres dépôts Git. Les commits Git peuvent ensuite être pushés vers des dépôts distants de façon arbitraire.

Fonctionnement

À un niveau général, Git peut être considéré comme un utilitaire de gestion de la chronologie. Les commits constituent les piliers d'une chronologie de projet Git. Ils sont créés grâce à la commande git commit pour capturer l'état d'un projet à un point dans le temps. Les instantanés Git sont toujours commités dans le dépôt local. C'est radicalement différent de SVN, où la copie de travail est commitée dans le dépôt centralisé. Git, en revanche, ne vous oblige pas à interagir avec le dépôt centralisé tant que vous n'êtes pas prêt. À l'instar de la zone de staging qui agit comme un tampon entre le dépôt de travail et l'historique de projet, le dépôt local de chaque développeur constitue un tampon entre ses contributions et le dépôt centralisé.

Cela change le modèle de développement de base pour les utilisateurs de Git. Au lieu d'apporter un changement et de le commiter directement dans le dépôt centralisé, les développeurs Git peuvent accumuler les commits dans leur dépôt local. Cela présente de nombreux avantages par rapport à la collaboration de type SVN : il est notamment plus facile de séparer une fonctionnalité en commits atomiques, de regrouper des commits connexes et de nettoyer l'historique local avant de le publier dans le dépôt centralisé. Cela permet également aux développeurs de travailler dans un environnement isolé, repoussant l'intégration jusqu'à ce qu'ils soient prêts. Même si l'isolation et l'intégration reportée sont bénéfiques lorsque vous travaillez seul, il en va de l'intérêt de l'équipe d'intégrer fréquemment et par petites unités. Pour en savoir plus sur les bonnes pratiques de collaboration en équipe Git, découvrez comment les équipes structurent leur workflow Git.

Instantanés, pas de différence

En dehors des différences pratiques entre SVN et Git, leur implémentation sous-jacente suit également des philosophies de conception radicalement distinctes. Tandis que SVN suit les différences d'un fichier, le modèle de contrôle de version de Git repose sur les instantanés. Par exemple, un commit SVN indique les différences par rapport au fichier d'origine ajouté au dépôt. Git, en revanche, enregistre tout le contenu de chaque fichier dans chaque commit.

Tutoriel Git : Instantanés, pas de différence

Les opérations Git sont donc plus rapides que SVN, puisqu'il est inutile d'assembler une version spécifique d'un fichier à partir de ses différences : la révision complète de chaque fichier est immédiatement disponible dans la base de données interne de Git.

Le modèle d'instantané Git a un impact considérable sur la plupart des aspects de son modèle de contrôle de version, des outils de création de branche et de merge à ses workflows de collaboration.

Options communes

git commit

Commitez l'instantané stagé. Cette action lancera un éditeur de texte qui vous demandera un message de commit. Après avoir saisi un message, enregistrez le fichier et fermez l'éditeur pour créer le commit réel.

git commit -a

Commitez un instantané de tous les changements apportés au répertoire de travail. Ceci inclut uniquement les changements dans les fichiers suivis (ceux qui ont été ajoutés grâce à git add à un moment donné dans l'historique).

git commit -m "commit message"

Une commande de raccourci qui crée immédiatement un commit avec un message de commit transmis. Par défaut, git commit ouvre l'éditeur de texte configuré en local et invite à saisir un message de commit. Lorsque vous transmettez l'option -m renonce à l'invite d'éditeur de texte au profit d'un message contextuel.

git commit -am "commit message"

Une commande de raccourci pour les utilisateurs intensifs, qui combine les options -a et -m. Cette combinaison crée immédiatement un commit de tous les changements stagés et insère un message de commit contextuel.

git commit --amend

Cette option ajoute un autre niveau de fonctionnalité à la commande de commit. Lorsque vous transmettez cette option, le dernier commit sera modifié. Au lieu de créer un commit, les changements stagés sont ajoutés au commit précédent. Cette commande ouvre l'éditeur de texte configuré pour le système et invite à modifier le message de commit précédemment indiqué.

Exemples

Enregistrer des changements grâce à un commit

L'exemple suivant part du principe que vous avez édité le contenu d'un fichier nommé hello.py dans la branche actuelle et que vous êtes prêt à le commiter dans l'historique du projet. Vous devez tout d'abord stager le fichier grâce à git add. Ensuite, vous pouvez commiter l'instantané stagé.

git add hello.py

Cette commande ajoute hello.py à la zone de staging Git. Nous pouvons examiner le résultat de cette action en lançant la commande git status.

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

Le nouveau fichier de sortie vert, hello.py, indique que hello.py sera enregistré avec le nouveau commit. Le commit est créé en exécutant la commande suivante :

git commit

Cette action ouvre un éditeur de texte (personnalisable via git config) qui vous demande un message de journal de commit, avec une liste de ce qui a été commité :

# Saisissez le message de commit pour vos changements. Les lignes commençant
# par '#' sont ignorées, et un message vide annule le commit.
# Sur la branche principale
# Changements à commiter :
# (utilisez "git reset HEAD ..." pour annuler le staging)
#
#modifié : hello.py

Git n'exige pas que les messages de commit suivent des contraintes de formatage spécifiques, mais le format canonique consiste à résumer le commit entier sur la première ligne (en moins de 50 caractères), à laisser une ligne vierge, puis à fournir une explication détaillée de ce qui a changé. Par exemple :

Change the message displayed by hello.py
- Update the sayHello() function to output the user's name - Change the sayGoodbye() function to a friendlier message

Il est courant d'utiliser la première ligne du message de commit comme une ligne d'objet, comme vous le feriez dans un e-mail. Le reste du message de journal est considéré comme le corps et permet de communiquer les détails de l'ensemble de changements du commit. Remarque : beaucoup de développeurs aiment aussi utiliser le présent dans leurs messages de commit. Ces derniers sonnent ainsi comme des actions dans le dépôt, ce qui rend les opérations de réécriture de l'historique plus intuitives.
 

Comment mettre à jour ou modifier un commit ?

Poursuivons avec l'exemple hello.py ci-dessus. Apportons de nouvelles mises à jour à hello.py et exécutons la commande suivante :

git add hello.py
git commit --amend

Une fois de plus, cette commande va ouvrir l'éditeur de texte configuré. Cette fois, il sera cependant prérenseigné avec le message de commit précédemment saisi. Cela indique que nous ne créons pas un commit, nous modifions le dernier.

Résumé

La commande git commit est l'une des fonctions principales de Git. Avant d'utiliser la commande git add, il est impératif de sélectionner les changements qui seront stagés pour le prochain commit. Ensuite, git commit est utilisée pour créer un instantané des changements stagés suivant la chronologie d'un historique de projets Git. Pour en savoir plus sur l'utilisation de git addconsultez la page dédiée. La commande git status peut être utilisée pour explorer l'état de la zone de staging et le commit en attente.

Les modèles de commit de SVN et Git sont fondamentalement différents, mais font souvent l'objet de confusions, car ils partagent la même terminologie. Si vous débutez dans Git après avoir déjà utilisé SVN, il est utile de savoir que dans Git, les commits sont faciles et devraient être utilisés fréquemment. Tandis que les commits SVN constituent des opérations coûteuses, qui nécessitent une demande distante, les commits Git sont effectués en local et grâce à un algorithme plus efficace.

Prêt à découvrir Git ?

Essayez ce tutoriel interactif.

Démarrez maintenant