Introduction

Dans le langage courant, on « sauvegarde » un document, mais dans Git l'action équivalente s'appelle committer. Un commit enregistre un instantané permanent de vos fichiers préparés et de leurs modifications dans l'historique du dépôt. Contrairement à Enregistrer dans un éditeur, un commit ne remplace pas la version précédente — il ajoute une nouvelle entrée dans une chronologie que vous pouvez consulter, comparer ou restaurer à tout moment.

Cette page est une carte des commandes que vous utilisez pour enregistrer les modifications localement et les préparer au partage. Chaque section renvoie à un chapitre dédié avec toutes les options et des exemples.

Les trois zones par lesquelles transitent les modifications

Pour comprendre l'enregistrement dans Git, il est utile de savoir qu'un fichier peut se trouver dans trois endroits à la fois :

• Répertoire de travail — les fichiers que vous modifiez sur le disque.
• Zone de préparation (aussi appelée l'index) — une zone tampon où vous assemblez exactement ce que contiendra le prochain commit.
• Dépôt — l'historique des commits, stocké dans le dossier caché .git.

Enregistrer des modifications signifie les faire passer du répertoire de travail, à travers la zone de préparation, et dans le dépôt :

edit files        # changes live in the working directory
git add <file>    # move them into the staging area
git commit        # record them permanently in the repository

Le flux en deux étapes add puis commit est intentionnel : il vous permet de committer uniquement une partie de votre travail et de laisser le reste pour plus tard, produisant des commits ciblés et significatifs.

git add

La commande git add déplace les modifications du répertoire de travail vers la zone de préparation. Elle indique à Git quelles mises à jour inclure dans le prochain commit. En elle-même, git add n'enregistre rien de permanent — vous devez la faire suivre de git commit.

git add index.html      # stage a single file
git add src/            # stage everything under a directory
git add .               # stage all changes in the current directory tree

Exécutez git status à tout moment pour voir quels fichiers sont préparés, modifiés ou non suivis.

git commit

La commande git commit enregistre toutes les modifications actuellement préparées sous la forme d'un nouvel instantané dans le dépôt. Chaque commit est un point permanent dans l'historique auquel vous pouvez revenir. Comme seules les modifications préparées sont capturées, git add doit être exécuté en premier.

git commit -m "Add contact form validation"

Utilisez un message court et descriptif à l'impératif (« Add », « Fix », « Update »). Si vous omettez -m, Git ouvre votre éditeur configuré pour vous permettre d'écrire un message plus long.

git diff

La commande git diff compare différents états de votre projet afin que vous puissiez examiner exactement ce que vous êtes sur le point d'enregistrer. Par défaut, git diff affiche les modifications non préparées — la différence entre votre répertoire de travail et la zone de préparation. Ajoutez --staged pour voir ce qui est déjà préparé et prêt à être commité.

git diff             # working directory vs. staging area (not yet staged)
git diff --staged    # staging area vs. last commit (about to be committed)

Examiner un diff avant de committer est le meilleur moyen d'éviter d'enregistrer du code de débogage ou des modifications accidentelles.

git stash

La commande git stash met temporairement de côté les modifications non commitées afin que votre répertoire de travail devienne propre — utile lorsque vous devez changer de tâche ou récupérer des mises à jour sans committer un travail inachevé. Les modifications sont sauvegardées dans une pile que vous pouvez réappliquer plus tard.

git stash        # set aside current changes and revert to a clean tree
git stash pop    # re-apply the most recent stash and remove it from the stack

.gitignore

Certains fichiers ne devraient jamais être commités — les sorties de compilation, les dépendances, les secrets ou les métadonnées du système d'exploitation. Git lit un fichier nommé .gitignore pour décider quels chemins ignorer. Il n'existe pas de commande git ignore ; vous créez et commitez ce fichier vous-même, en listant les motifs que Git doit exclure du suivi :

# Dependencies
node_modules/
# OS files
.DS_Store
Thumbs.db
# Secrets
.env

Notez que .gitignore n'affecte que les fichiers que Git ne suit pas encore. Pour arrêter le suivi d'un fichier qui a été commité avant d'être ignoré, utilisez git rm --cached.

Flux de travail typique

Une séquence standard pour enregistrer et partager des modifications ressemble à ceci :

git status                          # see what changed
git add .                           # stage the changes
git diff --staged                   # review what is about to be committed
git commit -m "Implement feature"   # save a permanent snapshot
git push origin main                # upload commits to the remote

Les quatre premières étapes sauvegardent votre travail localement ; git push est ce qui le partage avec un serveur distant tel que GitHub.

Annuler avant d'enregistrer

Si vous préparez quelque chose par erreur, vous pouvez le retirer de la zone de préparation sans perdre vos modifications :

git restore --staged <file>    # unstage, keep the changes in the working directory
git restore <file>             # discard working-directory changes (cannot be undone)

Pour d'autres façons d'annuler des modifications après un commit, consultez git reset.

Pratique