Git

Git est un logiciel de gestion de versions décentralisé créé par Linus Torvalds en 2005, initialement pour les besoins du développement du noyau Linux. Cette page rassemble les commandes que j'utilise (ou que je consulte régulièrement) au quotidien, classées par grandes familles comme le fait la documentation officielle. Ce n'est pas une traduction exhaustive du man, juste un pense-bête pratique avec des exemples concrets.

Configuration

La configuration Git existe sur trois niveaux, du plus large au plus spécifique : --system (toute la machine), --global (l'utilisateur courant) et --local (le dépôt en cours, valeur par défaut). En cas de conflit, c'est le niveau le plus précis qui l'emporte.

bash

# Identité (obligatoire avant le premier commit)
git config --global user.name "Noé Georget"
git config --global user.email "moi@exemple.fr"

# Éditeur par défaut pour les messages de commit
git config --global core.editor "vim"

# Nom de la branche par défaut lors d'un git init
git config --global init.defaultBranch main

# Voir toute la configuration active
git config --list

# Voir uniquement d'où vient une valeur
git config --show-origin user.email

Le fichier --global se trouve dans ~/.gitconfig, le --local dans .git/config à la racine du dépôt.

Créer ou récupérer un dépôt

bash

# Initialiser un nouveau dépôt dans le dossier courant
git init

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

# Cloner dans un dossier précis
git clone https://github.com/user/repo.git mon-dossier

# Cloner uniquement une branche, sans tout l'historique
git clone --branch main --single-branch --depth 1 https://github.com/user/repo.git

Le cycle de base : status, add, commit

C'est le trio qu'on tape le plus souvent. Git distingue trois zones : le répertoire de travail (working directory, mes fichiers tels quels), l'index (staging area, ce qui est prêt à être commité) et l'historique (les commits déjà enregistrés).

bash

# État actuel du dépôt : fichiers modifiés, non suivis, en attente
git status

# Version courte, plus lisible au quotidien
git status -s

# Ajouter un fichier précis à l'index
git add fichier.txt

# Ajouter tout le dossier courant
git add .

# Ajouter uniquement les fichiers déjà suivis qui ont été modifiés
git add -u

# Ajout interactif, morceau par morceau (très utile pour ne commiter qu'une partie d'un fichier)
git add -p

# Créer un commit avec les fichiers indexés
git commit -m "Message du commit"

# Ajouter ET commiter en une commande (uniquement les fichiers déjà suivis)
git commit -am "Message du commit"

# Modifier le dernier commit (message et/ou contenu) sans en créer un nouveau
git commit --amend

commit --amend réécrit l'historique : à éviter sur un commit déjà poussé et partagé, sauf à savoir exactement ce qu'on fait (voir la partie Réécrire l'historique).

Voir les différences

bash

# Différences non indexées (working directory vs index)
git diff

# Différences indexées, prêtes à être commitées (index vs dernier commit)
git diff --staged
# ou de façon équivalente
git diff --cached

# Différences entre deux commits
git diff abc1234 def5678

# Différences entre deux branches
git diff main..feature/login

# Uniquement les noms de fichiers modifiés
git diff --stat

Consulter l'historique

bash

# Historique complet
git log

# Version condensée, une ligne par commit
git log --oneline

# Avec le graphe des branches et fusions
git log --oneline --graph --all --decorate

# Historique d'un fichier précis
git log -- chemin/vers/fichier.txt

# Qui a modifié quelle ligne d'un fichier, et dans quel commit
git blame fichier.txt

# Détails d'un commit précis
git show abc1234

# Chercher un commit dont le message contient un mot
git log --grep="fix bug"

# Chercher un commit qui a introduit ou supprimé une chaîne précise dans le code
git log -S "nomDeFonction"

Branches

bash

# Lister les branches locales
git branch

# Lister aussi les branches distantes
git branch -a

# Créer une branche sans basculer dessus
git branch feature/login

# Créer une branche ET basculer dessus
git checkout -b feature/login
# équivalent moderne, plus explicite
git switch -c feature/login

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

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

# Supprimer une branche locale déjà fusionnée
git branch -d feature/login

# Forcer la suppression (même non fusionnée) — attention, perte de commits possible
git branch -D feature/login

# Supprimer une branche sur le dépôt distant
git push origin --delete feature/login

checkout reste très répandu par habitude et dans les vieux tutoriels, mais depuis Git 2.23, switch (changer de branche) et restore (annuler des modifications de fichiers) existent pour séparer clairement ces deux usages que checkout mélangeait auparavant.

Fusionner : merge et rebase

Deux façons d'intégrer les commits d'une branche dans une autre, avec des conséquences très différentes sur l'historique.

bash

# Se placer sur la branche qui va recevoir les modifications
git switch main

# Fusionner feature/login dans main : crée un commit de fusion (sauf fast-forward possible)
git merge feature/login

# Forcer la création d'un commit de fusion même en cas de fast-forward possible
git merge --no-ff feature/login

# Rebaser la branche courante sur main : rejoue les commits de la branche courante
# par-dessus main, ce qui donne un historique linéaire, sans commit de fusion
git switch feature/login
git rebase main

# Rebase interactif : réordonner, fusionner (squash) ou éditer des commits avant de les pousser
git rebase -i HEAD~5

En cas de conflit, Git s'arrête et laisse les marqueurs <<<<<<<, =======, >>>>>>> dans les fichiers concernés :

bash

# Après résolution manuelle des conflits dans les fichiers
git add fichier-en-conflit.txt
git rebase --continue
# ou pour un merge :
git merge --continue

# Abandonner l'opération en cours et revenir à l'état d'avant
git rebase --abort
git merge --abort

Règle que je m'impose : ne jamais rebaser une branche déjà poussée et partagée avec d'autres personnes. Le rebase réécrit les hash des commits, ce qui casse l'historique de quiconque a déjà basé du travail dessus.

Dépôts distants (remote)

bash

# Lister les remotes configurés
git remote -v

# Ajouter un remote
git remote add origin https://github.com/user/repo.git

# Changer l'URL d'un remote existant
git remote set-url origin git@github.com:user/repo.git

# Récupérer les commits distants sans les fusionner
git fetch origin

# Récupérer ET fusionner (fetch + merge)
git pull origin main

# Récupérer ET rebaser au lieu de fusionner (historique plus propre)
git pull --rebase origin main

# Envoyer les commits locaux
git push origin main

# Pousser une nouvelle branche et la lier au remote (pour les prochains push/pull simplifiés)
git push -u origin feature/login

# Forcer un push après réécriture de l'historique (amend, rebase...)
# --force-with-lease est plus sûr : il échoue si quelqu'un d'autre a poussé entre-temps
git push --force-with-lease

Réécrire l'histoire : reset, revert, rebase

Trois commandes qui « annulent » des choses, mais pas de la même manière — c'est le genre de nuance qui coûte cher si on se trompe.

bash

# reset --soft : déplace HEAD, garde les modifications indexées
git reset --soft HEAD~1

# reset --mixed (par défaut) : déplace HEAD, désindexe les modifications, garde les fichiers modifiés
git reset HEAD~1

# reset --hard : déplace HEAD et écrase TOUT, y compris le répertoire de travail
# ⚠️ perte définitive des modifications non commitées
git reset --hard HEAD~1

# revert : crée un NOUVEAU commit qui annule les changements d'un commit précédent,
# sans toucher à l'historique existant — la méthode sûre sur une branche déjà partagée
git revert abc1234

En résumé : reset déplace le curseur dans l'historique (donc le réécrit), revert ajoute un commit compensatoire par-dessus sans rien effacer. Sur une branche partagée en équipe, revert est presque toujours le bon choix.

Annuler des modifications non commitées (restore)

bash

# Annuler les modifications d'un fichier dans le working directory (revenir à la version indexée/commitée)
git restore fichier.txt

# Désindexer un fichier (le retirer de l'index sans toucher à son contenu)
git restore --staged fichier.txt

# Ancienne syntaxe équivalente à ces deux commandes (avant Git 2.23)
git checkout -- fichier.txt

Remiser des modifications (stash)

Pratique quand on doit changer de branche rapidement sans commiter un travail en cours.

bash

# Mettre de côté les modifications en cours
git stash

# Avec un message pour s'y retrouver
git stash push -m "wip: formulaire de login"

# Inclure aussi les fichiers non suivis
git stash -u

# Lister les stash en attente
git stash list

# Réappliquer le dernier stash et le retirer de la liste
git stash pop

# Réappliquer sans le retirer de la liste
git stash apply

# Voir le contenu d'un stash précis
git stash show -p stash@{0}

# Supprimer un stash précis
git stash drop stash@{0}

# Tout vider
git stash clear

Patching : cherry-pick, rebase, revert

bash

# Appliquer un commit précis d'une autre branche sur la branche courante
git cherry-pick abc1234

# Appliquer plusieurs commits à la suite
git cherry-pick abc1234 def5678

# En cas de conflit pendant un cherry-pick
git cherry-pick --continue
git cherry-pick --abort

Débogage : bisect, blame, grep

bisect fait une recherche dichotomique dans l'historique pour trouver le commit qui a introduit un bug — très efficace sur un historique long.

bash

# Démarrer une session de bisect
git bisect start

# Marquer le commit actuel comme buggé
git bisect bad

# Marquer un commit antérieur connu comme sain
git bisect good v1.0.0

# Git checkoute alors un commit intermédiaire à tester ;
# répéter good/bad jusqu'à isoler le commit fautif
git bisect good   # ou git bisect bad, selon le résultat du test

# Terminer la session et revenir à l'état initial
git bisect reset

# Rechercher du texte dans les fichiers suivis par Git
git grep "TODO"

# Avec les numéros de ligne
git grep -n "TODO"

Sous-modules

Utile pour inclure un dépôt Git dans un autre (une lib partagée, par exemple), tout en gardant les deux historiques séparés.

bash

# Ajouter un sous-module
git submodule add https://github.com/user/lib.git chemin/lib

# Cloner un dépôt en récupérant aussi ses sous-modules
git clone --recurse-submodules https://github.com/user/repo.git

# Initialiser les sous-modules d'un dépôt déjà cloné sans --recurse-submodules
git submodule update --init --recursive

# Mettre à jour tous les sous-modules vers le commit référencé
git submodule update --remote

Worktrees

Permet d'avoir plusieurs branches du même dépôt checkoutées simultanément, chacune dans son propre dossier, sans avoir à cloner plusieurs fois ni à faire des stash à répétition.

bash

# Créer un nouveau worktree pour une branche existante
git worktree add ../repo-hotfix hotfix/urgent

# Créer un worktree ET une nouvelle branche en même temps
git worktree add -b feature/x ../repo-feature-x

# Lister les worktrees actifs
git worktree list

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

Maintenance et administration

bash

# Supprimer les fichiers non suivis (dry-run d'abord pour vérifier !)
git clean -n
git clean -f

# Inclure aussi les dossiers non suivis
git clean -fd

# Nettoyer et optimiser le dépôt (compresser les objets, purger les inutiles)
git gc

# Vérifier l'intégrité de la base d'objets du dépôt
git fsck

# Créer une archive du dépôt (zip, tar...) sans l'historique .git
git archive --format=zip HEAD -o archive.zip

Reflog : le filet de sécurité

Le reflog garde une trace de tous les déplacements de HEAD, même après un reset --hard ou une branche supprimée par erreur. Tant que le garbage collector n'est pas passé, c'est presque toujours récupérable.

bash

# Voir l'historique des déplacements de HEAD
git reflog

# Revenir à un état antérieur retrouvé dans le reflog
git reset --hard HEAD@{2}

`.gitignore`

Fichier listant les chemins que Git doit ignorer (dépendances, artefacts de build, secrets locaux...).

txt

# Dossiers
node_modules/
dist/
.venv/

# Fichiers par extension
*.log
*.env

# Exception : ne pas ignorer un fichier précis dans un dossier par ailleurs ignoré
!dist/keep-this.txt

bash

# Vérifier pourquoi un fichier est ignoré (quelle règle, dans quel fichier)
git check-ignore -v fichier.txt

# Arrêter de suivre un fichier déjà commité, sans le supprimer du disque
git rm --cached fichier.txt

Alias utiles

Pour gagner du temps sur les commandes tapées le plus souvent :

bash

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.lg "log --oneline --graph --all --decorate"

Aide-mémoire rapide

Situation	Commande
Annuler des modifs non indexées sur un fichier	`git restore fichier.txt`
Retirer un fichier de l'index sans perdre les modifs	`git restore --staged fichier.txt`
Annuler le dernier commit, garder les modifs	`git reset --soft HEAD~1`
Annuler un commit déjà poussé, proprement	`git revert abc1234`
Récupérer un commit "perdu"	`git reflog` puis `git reset --hard <hash>`
Mettre de côté un travail en cours	`git stash`
Trouver le commit qui a cassé quelque chose	`git bisect start`
Récupérer un commit précis d'une autre branche	`git cherry-pick <hash>`

Source : documentation officielle Git

Général

Stockage

VPN

Firewall

Reverse proxy

DNS

Monitoring

Paramètres

Formats

Moteurs

Modèles

Git

Configuration

Créer ou récupérer un dépôt

Le cycle de base : status, add, commit

Voir les différences

Consulter l'historique

Branches

Fusionner : merge et rebase

Dépôts distants (remote)

Réécrire l'histoire : reset, revert, rebase

Annuler des modifications non commitées (restore)

Remiser des modifications (stash)

Tags

Patching : cherry-pick, rebase, revert

Débogage : bisect, blame, grep

Sous-modules

Worktrees

Maintenance et administration

Reflog : le filet de sécurité

`.gitignore`

Alias utiles

Aide-mémoire rapide

Git ​

Configuration ​

Créer ou récupérer un dépôt ​

Le cycle de base : status, add, commit ​

Voir les différences ​

Consulter l'historique ​

Branches ​

Fusionner : merge et rebase ​

Dépôts distants (remote) ​

Réécrire l'histoire : reset, revert, rebase ​

Annuler des modifications non commitées (restore) ​

Remiser des modifications (stash) ​

Tags ​

Patching : cherry-pick, rebase, revert ​

Débogage : bisect, blame, grep ​

Sous-modules ​

Worktrees ​

Maintenance et administration ​

Reflog : le filet de sécurité ​

.gitignore ​

Alias utiles ​

Aide-mémoire rapide ​

Git

Configuration

Créer ou récupérer un dépôt

Le cycle de base : status, add, commit

Voir les différences

Consulter l'historique

Branches

Fusionner : merge et rebase

Dépôts distants (remote)

Réécrire l'histoire : reset, revert, rebase

Annuler des modifications non commitées (restore)

Remiser des modifications (stash)

Tags

Patching : cherry-pick, rebase, revert

Débogage : bisect, blame, grep

Sous-modules

Worktrees

Maintenance et administration

Reflog : le filet de sécurité

`.gitignore`

Alias utiles

Aide-mémoire rapide