Aide-Mémoire des Commandes Git 2026

Introduction : Pourquoi maîtriser Git en 2026

Git est le système de contrôle de version le plus utilisé au monde, et sa maîtrise est indispensable pour tout développeur professionnel en 2026. Que vous travailliez seul sur un projet personnel ou en équipe sur une application d'entreprise, Git vous permet de suivre chaque modification de votre code, de collaborer efficacement et de revenir en arrière en cas de problème.

Cet aide-mémoire complet regroupe toutes les commandes Git essentielles, organisées par catégorie et accompagnées d'exemples pratiques. Gardez cette page en favoris : elle deviendra votre référence quotidienne.

Configuration initiale

Avant de commencer à utiliser Git, vous devez configurer votre identité et vos préférences. Ces paramètres sont enregistrés globalement sur votre machine.

# Configurer votre nom d'utilisateur
git config --global user.name "Votre Nom"

# Configurer votre email
git config --global user.email "votre.email@exemple.com"

# Définir l'éditeur par défaut (VS Code)
git config --global core.editor "code --wait"

# Activer la coloration syntaxique dans le terminal
git config --global color.ui auto

# Définir la branche par défaut à 'main'
git config --global init.defaultBranch main

# Vérifier votre configuration
git config --list

Commandes de base

Initialiser et cloner un dépôt

# Créer un nouveau dépôt Git dans le répertoire courant
git init

# Créer un nouveau dépôt dans un répertoire spécifique
git init mon-projet

# Cloner un dépôt distant
git clone https://github.com/utilisateur/depot.git

# Cloner dans un répertoire spécifique
git clone https://github.com/utilisateur/depot.git mon-dossier

# Cloner une branche spécifique
git clone -b develop https://github.com/utilisateur/depot.git

# Clone superficiel (uniquement le dernier commit)
git clone --depth 1 https://github.com/utilisateur/depot.git

Suivi des fichiers et staging

# Vérifier l'état du dépôt
git status

# Version concise du statut
git status -s

# Ajouter un fichier au staging
git add fichier.txt

# Ajouter tous les fichiers modifiés
git add .

# Ajouter tous les fichiers d'un type spécifique
git add "*.js"

# Ajouter interactivement des parties de fichiers
git add -p

# Retirer un fichier du staging (sans perdre les modifications)
git restore --staged fichier.txt

# Annuler les modifications d'un fichier (ATTENTION: irréversible)
git restore fichier.txt

Commits

# Créer un commit avec un message
git commit -m "feat: ajouter la fonctionnalité de connexion"

# Ajouter et commiter en une seule commande (fichiers déjà suivis)
git commit -am "fix: corriger le bug d'affichage"

# Modifier le dernier commit (message ou contenu)
git commit --amend -m "Nouveau message de commit"

# Créer un commit vide (utile pour déclencher des CI/CD)
git commit --allow-empty -m "chore: déclencher le pipeline"

Conventions de messages de commit

Adoptez la convention Conventional Commits pour des messages clairs et cohérents :

Préfixe	Usage
`feat:`	Nouvelle fonctionnalité
`fix:`	Correction de bug
`docs:`	Documentation uniquement
`style:`	Formatage (pas de changement de code)
`refactor:`	Refactorisation du code
`test:`	Ajout ou modification de tests
`chore:`	Tâches de maintenance
`perf:`	Amélioration des performances

Historique et inspection

# Afficher l'historique des commits
git log

# Historique condensé sur une ligne
git log --oneline

# Historique avec graphe des branches
git log --oneline --graph --all

# Historique d'un fichier spécifique
git log -- fichier.txt

# Historique avec le diff de chaque commit
git log -p

# Afficher les N derniers commits
git log -5

# Rechercher dans les messages de commit
git log --grep="bug"

# Afficher les détails d'un commit spécifique
git show abc1234

# Afficher les différences entre le répertoire de travail et le staging
git diff

# Différences entre le staging et le dernier commit
git diff --staged

# Différences entre deux branches
git diff main..develop

# Qui a modifié chaque ligne d'un fichier
git blame fichier.txt

Branches

Les branches sont l'un des concepts les plus puissants de Git. Elles permettent de travailler sur plusieurs fonctionnalités en parallèle sans interférer les unes avec les autres.

# Lister les branches locales
git branch

# Lister toutes les branches (locales et distantes)
git branch -a

# Créer une nouvelle branche
git branch nouvelle-branche

# Créer et basculer sur une nouvelle branche
git checkout -b nouvelle-branche
# Ou avec la syntaxe moderne :
git switch -c nouvelle-branche

# Basculer sur une branche existante
git checkout main
# Ou :
git switch main

# Renommer la branche courante
git branch -m nouveau-nom

# Supprimer une branche (déjà fusionnée)
git branch -d branche-a-supprimer

# Forcer la suppression d'une branche
git branch -D branche-a-supprimer

Fusion (Merge) et Rebase

Merge

# Fusionner une branche dans la branche courante
git merge feature-branch

# Fusionner sans fast-forward (préserve l'historique de la branche)
git merge --no-ff feature-branch

# Annuler une fusion en cours (en cas de conflit)
git merge --abort

Rebase

# Rebaser la branche courante sur main
git rebase main

# Rebase interactif des 3 derniers commits
git rebase -i HEAD~3

# Annuler un rebase en cours
git rebase --abort

# Continuer un rebase après résolution de conflits
git rebase --continue

Résolution de conflits

Lorsqu'un conflit survient, Git marque les fichiers concernés. Voici la procédure :

# 1. Identifier les fichiers en conflit
git status

# 2. Ouvrir les fichiers et résoudre les conflits manuellement
# Les marqueurs de conflit ressemblent à :
# <<<<<<< HEAD
# Votre code
# =======
# Le code de l'autre branche
# >>>>>>> feature-branch

# 3. Marquer les conflits comme résolus
git add fichier-resolu.txt

# 4. Terminer la fusion
git commit

Travail avec les dépôts distants

# Afficher les dépôts distants configurés
git remote -v

# Ajouter un dépôt distant
git remote add origin https://github.com/utilisateur/depot.git

# Modifier l'URL d'un dépôt distant
git remote set-url origin https://nouvelle-url.git

# Récupérer les modifications distantes (sans fusionner)
git fetch origin

# Récupérer et fusionner en une commande
git pull origin main

# Pousser les modifications vers le dépôt distant
git push origin main

# Pousser une nouvelle branche et configurer le suivi
git push -u origin nouvelle-branche

# Supprimer une branche distante
git push origin --delete branche-distante

# Synchroniser la liste des branches distantes supprimées
git fetch --prune

Stash : Mettre de côté temporairement

Le stash est extrêmement utile pour sauvegarder temporairement des modifications non commitées :

# Mettre les modifications de côté
git stash

# Mettre de côté avec un message descriptif
git stash push -m "WIP: formulaire de contact"

# Inclure les fichiers non suivis
git stash -u

# Lister les stash enregistrés
git stash list

# Réappliquer le dernier stash (et le conserver)
git stash apply

# Réappliquer et supprimer le stash
git stash pop

# Appliquer un stash spécifique
git stash apply stash@{2}

# Supprimer un stash spécifique
git stash drop stash@{0}

# Supprimer tous les stash
git stash clear

Tags et versionnement

# Créer un tag léger
git tag v1.0.0

# Créer un tag annoté (recommandé)
git tag -a v1.0.0 -m "Version 1.0.0 - Lancement initial"

# Lister tous les tags
git tag -l

# Lister les tags correspondant à un pattern
git tag -l "v1.*"

# Pousser un tag vers le distant
git push origin v1.0.0

# Pousser tous les tags
git push origin --tags

# Supprimer un tag local
git tag -d v1.0.0

# Supprimer un tag distant
git push origin --delete v1.0.0

Commandes avancées

Cherry-pick

# Appliquer un commit spécifique sur la branche courante
git cherry-pick abc1234

# Cherry-pick sans commiter automatiquement
git cherry-pick --no-commit abc1234

# Cherry-pick d'une plage de commits
git cherry-pick abc1234..def5678

Reset et Revert

# Annuler le dernier commit (conserver les modifications)
git reset --soft HEAD~1

# Annuler le dernier commit et le staging
git reset --mixed HEAD~1

# Annuler le dernier commit complètement (ATTENTION: perte de données)
git reset --hard HEAD~1

# Créer un commit qui annule un commit précédent (sûr pour l'historique partagé)
git revert abc1234

Bisect : Trouver un bug par dichotomie

# Démarrer la recherche
git bisect start

# Marquer le commit courant comme mauvais
git bisect bad

# Marquer un commit connu comme bon
git bisect good abc1234

# Git vous proposera des commits à tester
# Après chaque test, marquez comme bon ou mauvais
git bisect good
# ou
git bisect bad

# Terminer la session bisect
git bisect reset

Worktrees

# Créer un worktree pour travailler sur une autre branche
git worktree add ../projet-hotfix hotfix-branch

# Lister les worktrees
git worktree list

# Supprimer un worktree
git worktree remove ../projet-hotfix

Alias Git utiles

Gagnez du temps avec des alias personnalisés :

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --all --decorate"
git config --global alias.last "log -1 HEAD"
git config --global alias.unstage "restore --staged"

Bonnes pratiques Git en 2026

Commitez souvent, poussez régulièrement : des commits petits et fréquents facilitent la revue de code et la résolution de conflits.
Utilisez des branches pour chaque fonctionnalité : ne travaillez jamais directement sur main.
Rédigez des messages de commit clairs : suivez la convention Conventional Commits.
Utilisez .gitignore : excluez les fichiers générés, les dépendances et les fichiers de configuration locaux.
Faites des revues de code : utilisez les Pull Requests pour la revue par les pairs.
Protégez la branche main : configurez des règles de protection de branche.

Pour formater et valider vos fichiers de configuration Git, vous pouvez utiliser le formateur JSON de ToolBox Hub, notamment pour les fichiers package.json de vos projets.

Conclusion

Git est un outil puissant dont la maîtrise demande de la pratique. Cet aide-mémoire couvre les commandes les plus utilisées, mais Git offre bien plus de fonctionnalités. Gardez cette page à portée de main et n'hésitez pas à expérimenter dans des dépôts de test. La meilleure façon d'apprendre Git, c'est de l'utiliser quotidiennement.