Aide-mémoire Git : Commandes essentielles pour chaque développeur

31 mars 2026 · 12 min de lecture

Git est le système de contrôle de version le plus utilisé au monde, alimentant des millions de projets allant des projets personnels aux applications d'entreprise. Que vous soyez un développeur solo ou membre d'une grande équipe, connaître les commandes Git essentielles fait gagner du temps et évite les erreurs.

Cet aide-mémoire complet couvre toutes les commandes dont vous aurez besoin pour le travail de développement quotidien, des opérations de base aux flux de travail avancés. Nous l'avons organisé par type de tâche afin que vous puissiez rapidement trouver ce dont vous avez besoin quand vous en avez besoin.

Mettez cette page en signet comme référence rapide. Pour formater votre documentation Git et vos fichiers README, essayez notre Éditeur Markdown.

Installation et configuration

Avant votre premier commit, vous devez configurer votre identité. Ces paramètres sont stockés globalement et attachés à chaque commit que vous effectuez, afin que les autres développeurs sachent qui a fait quelles modifications.

Configuration initiale

git config --global user.name "Votre nom"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"

Le drapeau --global applique ces paramètres à tous les dépôts sur votre machine. Si vous avez besoin de paramètres différents pour un projet spécifique, exécutez les mêmes commandes sans --global à l'intérieur de ce dépôt.

Options de configuration utiles

git config --global color.ui auto              # Activer la sortie colorée
git config --global core.autocrlf true         # Gérer les fins de ligne (Windows)
git config --global core.autocrlf input        # Gérer les fins de ligne (Mac/Linux)
git config --global pull.rebase false          # Utiliser la stratégie de fusion pour les pulls
git config --global alias.st status            # Créer un raccourci : git st
git config --global alias.co checkout          # Créer un raccourci : git co
git config --global alias.br branch            # Créer un raccourci : git br
git config --global alias.ci commit            # Créer un raccourci : git ci

Affichage et modification de la configuration

git config --list                              # Afficher tous les paramètres
git config --list --show-origin                # Afficher où chaque paramètre est défini
git config user.name                           # Afficher un paramètre spécifique
git config --global --edit                     # Modifier la config globale dans l'éditeur

Création de dépôts

Il existe deux façons de commencer à travailler avec Git : initialiser un nouveau dépôt ou cloner un dépôt existant depuis un serveur distant.

Initialiser un nouveau dépôt

git init                                       # Initialiser le dépôt dans le répertoire actuel
git init mon-projet                            # Créer un nouveau répertoire avec dépôt
git init --bare depot-partage.git              # Créer un dépôt nu (pour les serveurs)

Lorsque vous exécutez git init, Git crée un répertoire caché .git qui stocke toutes les informations de contrôle de version. Ce répertoire contient tout l'historique de votre projet, la configuration et les métadonnées.

Cloner un dépôt existant

git clone https://github.com/utilisateur/depot.git     # Cloner via HTTPS
git clone [email protected]:utilisateur/depot.git         # Cloner via SSH
git clone <url> mon-dossier                      # Cloner dans un répertoire spécifique
git clone --depth 1 <url>                      # Clone superficiel (dernier commit uniquement)
git clone --branch develop <url>               # Cloner une branche spécifique

Les clones superficiels sont utiles pour les pipelines CI/CD ou lorsque vous n'avez besoin que du code le plus récent sans l'historique complet. Ils sont nettement plus rapides et utilisent moins d'espace disque.

Commandes de flux de travail de base

Le flux de travail Git de base tourne autour de trois zones : le répertoire de travail (vos fichiers), la zone de staging (modifications prêtes à être commitées) et le dépôt (historique commité). Comprendre ce flux est crucial pour utiliser Git efficacement.

Vérification du statut

git status                                     # Vérifier l'état de l'arbre de travail
git status -s                                  # Sortie au format court
git status -sb                                 # Format court avec info de branche

Exécutez git status fréquemment. Il montre quels fichiers sont modifiés, stagés ou non suivis, et vous aide à comprendre l'état actuel de votre dépôt.

Mise en staging des modifications

git add fichier.txt                            # Stager un fichier spécifique
git add *.js                                   # Stager tous les fichiers JavaScript
git add .                                      # Stager toutes les modifications
git add -A                                     # Stager toutes les modifications (y compris suppressions)
git add -p                                     # Stager les modifications de manière interactive (mode patch)
git add -u                                     # Stager uniquement les fichiers modifiés et supprimés

La zone de staging (également appelée index) vous permet de créer des commits précis. Vous pouvez stager uniquement les modifications que vous souhaitez inclure, même si vous avez modifié plusieurs fichiers.

Commit des modifications

git commit -m "Ajouter l'authentification utilisateur"       # Commit avec message
git commit -am "Corriger le bug de connexion"                 # Stager les fichiers suivis + commit
git commit --amend                             # Modifier le dernier commit
git commit --amend --no-edit                   # Modifier sans changer le message
git commit -v                                  # Afficher le diff dans l'éditeur de message de commit

Rédigez des messages de commit clairs et descriptifs. Un bon format est : un résumé court (50 caractères ou moins), suivi d'une ligne vide, puis une explication détaillée si nécessaire.

Affichage des modifications

git diff                                       # Afficher les modifications non stagées
git diff --staged                              # Afficher les modifications stagées
git diff HEAD                                  # Afficher toutes les modifications depuis le dernier commit
git diff branche1..branche2                    # Comparer deux branches
git diff --stat                                # Afficher les statistiques de modifications
git diff --word-diff                           # Afficher les différences au niveau des mots

Branches et fusion

Les branches sont l'une des fonctionnalités les plus puissantes de Git. Elles vous permettent de travailler sur des fonctionnalités, des corrections ou des expériences de manière isolée sans affecter la base de code principale.

Gestion des branches

git branch                                     # Lister les branches locales
git branch -a                                  # Lister toutes les branches (locales + distantes)
git branch fonctionnalite-connexion            # Créer une nouvelle branche
git branch -d fonctionnalite-connexion         # Supprimer la branche (sécurisé)
git branch -D fonctionnalite-connexion         # Forcer la suppression de la branche
git branch -m ancien-nom nouveau-nom           # Renommer la branche
git branch -vv                                 # Afficher les branches avec info de suivi

Changement de branches

git checkout fonctionnalite-connexion          # Basculer vers la branche
git checkout -b fonctionnalite-inscription     # Créer et basculer vers une nouvelle branche
git checkout -                                 # Basculer vers la branche précédente
git switch fonctionnalite-connexion            # Façon moderne de changer de branche
git switch -c fonctionnalite-inscription       # Créer et basculer (syntaxe moderne)

La commande git switch a été introduite dans Git 2.23 comme alternative plus claire à git checkout, qui a plusieurs objectifs. Les deux fonctionnent de manière identique pour changer de branche.

Fusion de branches

git merge fonctionnalite-connexion             # Fusionner la branche dans la branche actuelle
git merge --no-ff fonctionnalite-connexion     # Forcer le commit de fusion (pas de fast-forward)
git merge --squash fonctionnalite-connexion    # Écraser les commits en un seul
git merge --abort                              # Annuler la fusion en cours

Lorsque vous fusionnez, Git combine les modifications de deux branches. Si les deux branches ont modifié les mêmes lignes, vous obtiendrez un conflit de fusion qui nécessite une résolution manuelle.

Résolution des conflits de fusion

Lorsque des conflits se produisent, Git marque les sections en conflit dans vos fichiers :

<<<<<<< HEAD
Vos modifications actuelles
=======
Modifications entrantes de la branche en cours de fusion
>>>>>>> branche-fonctionnalite

Pour résoudre les conflits :

1. Ouvrez les fichiers en conflit et modifiez-les pour résoudre les conflits
2. Supprimez les marqueurs de conflit (<<<<<<<, =======, >>>>>>>)
3. Stagez les fichiers résolus avec git add
4. Complétez la fusion avec git commit

git status                                     # Voir quels fichiers ont des conflits
git add fichier-resolu.js                      # Marquer le conflit comme résolu
git merge --continue                           # Continuer la fusion après résolution
git merge --abort                              # Abandonner et recommencer

Rebasage

git rebase main                                # Rebaser la branche actuelle sur main
git rebase -i HEAD~3                           # Rebasage interactif des 3 derniers commits
git rebase --continue                          # Continuer après résolution des conflits
git rebase --abort                             # Annuler le rebasage en cours
git rebase --skip                              # Ignorer le commit actuel pendant le rebasage

Le rebasage réécrit l'historique en déplaçant vos commits vers une nouvelle base. Il crée un historique plus propre et linéaire mais ne doit jamais être effectué sur des branches publiques que d'autres utilisent.

Opérations distantes

Les dépôts distants sont des versions de votre projet hébergées sur Internet ou un réseau. Ils permettent la collaboration et la sauvegarde.

Gestion des dépôts distants

git remote                                     # Lister les connexions distantes
git remote -v                                  # Lister les dépôts distants avec URLs
git remote add origin <url>                    # Ajouter un nouveau dépôt distant
git remote remove origin                       # Supprimer le dépôt distant
git remote rename origin upstream              # Renommer le dépôt distant
git remote set-url origin <nouvelle-url>       # Changer l'URL du dépôt distant
git remote show origin                         # Afficher les infos détaillées du dépôt distant

Récupération et tirage

git fetch                                      # Télécharger les modifications distantes
git fetch origin                               # Récupérer depuis un dépôt distant spécifique
git fetch --all                                # Récupérer depuis tous les dépôts distants
git fetch --prune                              # Supprimer les branches distantes supprimées
git pull                                       # Récupérer et fusionner les modifications distantes
git pull --rebase                              # Récupérer et rebaser au lieu de fusionner
git pull origin main                           # Tirer une branche spécifique

La différence entre fetch et pull : fetch télécharge les modifications mais ne modifie pas votre répertoire de travail, tandis que pull récupère et fusionne immédiatement les modifications.

Envoi des modifications

git push                                       # Pousser vers le dépôt distant/branche par défaut
git push origin main                           # Pousser vers un dépôt distant/branche spécifique
git push -u origin fonctionnalite-connexion    # Pousser et définir le suivi en amont
git push --all                                 # Pousser toutes les branches
git push --tags                                # Pousser tous les tags
git push --force                               # Forcer le push (dangereux !)
git push --force-with-lease                    # Push forcé plus sûr