Git est-il installé ?
Affiche la version. « command not found » ? Voir la leçon « Installer Git » de l'Academy.
$ git --version
// Copier-coller
Chaque snippet est accompagné d'une explication simple et de son niveau de risque. Copie avec modération.
122 commandes
Installer Git, créer un dépôt, faire le premier commit et le mettre sur GitHub.
Affiche la version. « command not found » ? Voir la leçon « Installer Git » de l'Academy.
$ git --version
Avec winget, inclus dans Windows 10 et 11. Ouvre un nouveau terminal ensuite.
$ winget install --id Git.Git -e --source winget
Installe les outils en ligne de commande d'Apple, Git compris. Ou : brew install git.
$ xcode-select --install
Fedora : sudo dnf install git. Arch : sudo pacman -S git.
$ sudo apt install git
Transforme le dossier courant en dépôt Git. Une fois par projet, à sa racine.
$ git init
Ajoute d'abord un .gitignore, pour que node_modules et .env n'y finissent pas.
$ git add .$ git commit -m "chore: initial commit"
Crée d'abord un dépôt vide sur GitHub. -u relie main à origin pour les prochains push.
$ git remote add origin git@github.com:OWNER/REPO.git$ git push -u origin main
Copie tout le dépôt et son historique dans un nouveau dossier.
$ git clone git@github.com:OWNER/REPO.git
Ne télécharge que le dernier commit : bien plus rapide pour les gros dépôts. Récupère le reste plus tard avec git fetch --unshallow.
$ git clone --depth 1 https://github.com/owner/repo.git
Télécharge une seule branche et se place dessus, en ignorant les autres.
$ git clone -b dev --single-branch https://github.com/owner/repo.git
Configurer Git une fois, gagner du temps pour toujours.
Inscrit dans chaque commit. Sans --global, ne s'applique qu'à un seul dépôt.
$ git config --global user.name "Your Name"$ git config --global user.email "you@example.com"
Utilisé par git init pour chaque nouveau dépôt.
$ git config --global init.defaultBranch main
Fini les commits « Merge branch 'main' of … » qui encombrent l'historique.
$ git config --global pull.rebase true
Ensuite, tape simplement git lg.
$ git config --global alias.lg "log --oneline --graph --decorate --all"
Chaque réglage et le fichier d'où il vient. Parfait pour comprendre un comportement bizarre.
$ git config --list --show-origin
Les messages de commit et les rebases interactifs s'ouvrent dans VS Code au lieu de Vim. --wait fait attendre Git jusqu'à la fermeture de l'onglet.
$ git config --global core.editor "code --wait"
Convertit en CRLF à l'extraction, en LF au commit. Sous macOS/Linux, utilise input.
$ git config --global core.autocrlf true
Les commandes du quotidien pour savoir où tu en es et préparer un commit.
Statut court avec la branche actuelle et ton avance/retard sur le remote.
$ git status -sb
Passe en revue chaque modification et choisis ce qui va dans le commit.
$ git add -p
Affiche les modifications indexées. Lance-la avant chaque commit, tes reviewers t'aimeront.
$ git diff --staged
Git enregistre directement le renommage. Ajoute -f pour ne changer que les majuscules / minuscules.
$ git mv old-name.ts new-name.ts
Le supprime du disque et indexe la suppression. --cached pour le garder sur le disque.
$ git rm path/to/file
Fichiers modifiés et nombre de lignes ajoutées / supprimées, sans le détail.
$ git diff --stat
-a indexe chaque fichier suivi qui a changé. Les nouveaux fichiers (non suivis) ne sont PAS inclus.
$ git commit -am "fix: message"
Au lieu de lignes entières, montre exactement quels mots ont changé. Idéal pour du texte et de la doc.
$ git diff --word-diff
Revenir sur une modification, un commit ou un push — du plus doux au plus brutal.
Change le message ou ajoute des fichiers oubliés. Réécrit le commit : à éviter s'il est déjà poussé.
$ git commit --amend
Le commit disparaît, ses modifications restent indexées. Parfait pour refaire un commit.
$ git reset --soft HEAD~1
Remet le fichier dans son dernier état commité. Les modifications non commitées sont perdues pour de bon.
$ git restore path/to/file
Retire le fichier du prochain commit, garde tes modifications.
$ git restore --staged path/to/file
Crée un nouveau commit qui fait l'inverse. L'historique reste intact : l'annulation respectueuse de l'équipe.
$ git revert <commit>
Jette les commits locaux ET les modifications non commitées. Crée d'abord une branche de secours.
$ git reset --hard origin/main
Remplace le fichier de ta copie de travail par sa version de ce commit. Commite-le pour le garder.
$ git restore --source=<commit> -- path/to/file
Crée un commit qui annule le merge. -m 1 garde la ligne principale (la branche dans laquelle tu as mergé).
$ git revert -m 1 <merge-hash>
Retire tous les fichiers de l'index. Tes modifications restent sur le disque.
$ git restore --staged .
Créer, changer, nettoyer et déplacer du travail entre branches.
L'équivalent moderne de git checkout -b.
$ git switch -c feature/my-feature
Trouve les branches que tu peux supprimer sans risque.
$ git branch --merged main
-d refuse si la branche n'est pas mergée. -D force (et tu finiras sur notre page Urgences).
$ git branch -d feature/old
Renommage local uniquement. Pousse le nouveau nom et supprime l'ancien sur le remote si besoin.
$ git branch -m new-name
Rejoue tes commits sur le dernier main. Réécrit ta branche : seulement sur des branches qui t'appartiennent.
$ git fetch origin$ git rebase origin/main
Applique ici les modifications d'un commit précis.
$ git cherry-pick <commit>
Comme cd - dans un terminal : revient sur la branche où tu étais avant.
$ git switch -
Les distantes apparaissent en remotes/origin/… Fais un git fetch avant pour être à jour.
$ git branch -a
Retrouve la branche sur laquelle tu bossais hier parmi cinquante.
$ git branch --sort=-committerdate
Comprendre ce qui s'est passé, quand, et qui l'a fait.
Le meilleur moyen de comprendre la situation avant de réparer quoi que ce soit.
$ git log --oneline --graph --decorate --all
Toutes les positions par lesquelles HEAD est passé, même après des resets et des branches supprimées.
$ git reflog
Spoiler : c'était sûrement toi. -w ignore les espaces, -C suit le code déplacé.
$ git blame -w -C path/to/file
Liste les commits qui ont ajouté ou supprimé cette chaîne.
$ git log -S "functionName" --oneline
Recherche dichotomique dans l'historique. Termine avec git bisect reset.
$ git bisect start$ git bisect bad$ git bisect good <commit>
Message, auteur et diff complet d'un commit.
$ git show <commit>
Trois points : seulement ce que la branche a ajouté depuis qu'elle a quitté main. Exactement ce qu'affiche une PR.
$ git diff main...feature/my-feature
--follow continue à travers les renommages.
$ git log --follow --oneline -- path/to/file
L'affiche sans toucher à ta copie de travail. Redirige avec > pour l'enregistrer.
$ git show <commit>:path/to/file
Marche aussi avec --until, et --grep="fix" pour chercher dans les messages.
$ git log --author="Alice" --since="2 weeks ago" --oneline
Nombre de commits par auteur. Ajoute --no-merges pour ignorer les commits de merge.
$ git shortlog -sn
Rapide, ignore node_modules et les autres fichiers ignorés. Ajoute un commit pour chercher dans une ancienne version.
$ git grep -n "TODO"
Ce que tu as et que le serveur n'a pas (après un git fetch).
$ git log origin/main..HEAD --oneline
Les commits que tu récupéreras au prochain pull, sans encore les tirer.
$ git fetch && git log HEAD..origin/main --oneline
Chaque commit dont le message contient le mot. Ajoute -i pour ignorer la casse.
$ git log --oneline --grep="login"
Les commits des deux dernières semaines. Marche aussi avec « yesterday », « 2026-11-01 »…
$ git log --since="2 weeks ago" --oneline --no-merges
Le blame seulement des lignes 10 à 30, avec le commit et l'auteur de chacune.
$ git blame -L 10,30 path/to/file
Parler à GitHub / GitLab : fetch, push, remotes et tags.
Liste les remotes et leurs URL.
$ git remote -v
Après avoir renommé un dépôt ou être passé de HTTPS à SSH.
$ git remote set-url origin git@github.com:OWNER/REPO.git
Les tags ne sont pas poussés par défaut : pousse-les explicitement.
$ git tag -a v1.2.0 -m "v1.2.0"$ git push origin v1.2.0
Garde un historique linéaire en rejouant tes commits locaux par-dessus.
$ git pull --rebase
Publie la branche actuelle et la lie au remote.
$ git push -u origin HEAD
Écrase le remote seulement si personne n'a poussé depuis ton dernier fetch. N'utilise jamais --force tout court.
$ git push --force-with-lease
Nettoie les références origin/* qui n'existent plus sur le serveur.
$ git fetch --prune
La branche disparaît pour tout le monde. Ses commits restent s'ils sont mergés ailleurs.
$ git push origin --delete feature/old
upstream = le projet d'origine, origin = ton fork.
$ git remote add upstream git@github.com:ORIGINAL/REPO.git$ git fetch upstream$ git rebase upstream/main
Remplace 123 par le numéro de la PR.
$ git fetch origin pull/123/head:pr-123$ git switch pr-123
Refuse de créer un commit de merge : soit il avance simplement ta branche, soit il s'arrête et te laisse décider.
$ git pull --ff-only
Pratique après un fork : l'original devient upstream, ton fork devient origin.
$ git remote rename origin upstream
Ouvrir, mettre à jour, relire et nettoyer une pull request (ou une merge request GitLab).
Toujours depuis un main à jour, pour que la PR ne contienne que ton travail.
$ git switch main$ git pull$ git switch -c feat/my-change
Git affiche un lien pour créer la pull request. Ensuite un simple git push la met à jour.
$ git push -u origin HEAD
--fill reprend le titre et la description de tes commits. Ajoute --draft pour une PR brouillon.
$ gh pr create --fill
Marche aussi pour les PR venant de forks.
$ gh pr checkout 123
Tes PR ouvertes, les reviews qui t'attendent, et les résultats de la CI.
$ gh pr status$ gh pr checks
Remplace 42 par le numéro de la merge request.
$ git fetch origin merge-requests/42/head:mr-42$ git switch mr-42
Les trois points comparent avec le point de départ de ta branche : exactement le diff de la PR.
$ git diff --stat origin/main...HEAD
Doit lister seulement ton travail. Autre chose ? Ta branche est partie du mauvais endroit.
$ git log --oneline origin/main..HEAD
Intègre le dernier main dans ta branche. Pas de push forcé.
$ git fetch origin$ git merge origin/main$ git push
Rejoue tes commits sur le dernier main : historique linéaire, demande un push forcé.
$ git fetch origin$ git rebase origin/main$ git push --force-with-lease
Replie tes commits fixup! dans ceux qu'ils corrigent.
$ git rebase -i --autosquash origin/main$ git push --force-with-lease
Demande d'avoir ajouté l'original en upstream (git remote add upstream …).
$ git fetch upstream$ git switch main$ git merge --ff-only upstream/main$ git push origin main
Après un squash merge, -d refuse : utilise -D une fois la PR vérifiée comme mergée.
$ git switch main$ git pull$ git branch -d feat/my-change
Compare deux versions d'une branche de PR commit par commit : parfait pour les reviewers.
$ git range-diff origin/main old-head new-head
Mettre de côté du travail inachevé sans le commiter.
Sauvegarde les modifications, fichiers non suivis inclus (-u), avec un message dont tu te remercieras.
$ git stash push -u -m "wip: something"
Applique le dernier stash et le supprime. En cas de conflit, le stash est conservé.
$ git stash pop
stash@{0} est le plus récent.
$ git stash list
Le diff complet du stash, sans l'appliquer.
$ git stash show -p stash@{0}
Crée une branche là où le stash a été fait et l'y applique : aucun conflit avec ce qui a changé depuis.
$ git stash branch fix/from-stash stash@{0}
Disparaît de la liste. Récupérable un temps avec git fsck si c'était une erreur.
$ git stash drop stash@{0}
Supprimer ce que Git ne devrait pas suivre ni garder.
Simulation : montre ce que git clean supprimerait, ne supprime rien.
$ git clean -nd
Irréversible : Git n'a jamais connu ces fichiers, il ne peut pas les ramener. Lance d'abord la simulation.
$ git clean -fd
Le retire de Git, le garde sur le disque. Ajoute-le au .gitignore juste après.
$ git rm -r --cached node_modules
Affiche le fichier .gitignore et la ligne qui s'appliquent. Aucune sortie : le fichier n'est pas ignoré.
$ git check-ignore -v path/to/file
X majuscule : seulement les fichiers listés dans le .gitignore. Remplace -n par -f pour supprimer vraiment.
$ git clean -ndX
Un menu interactif : tu choisis quoi supprimer. Plus sûr que clean -fd.
$ git clean -i
Nettoyer des commits avant de les partager : squash, reword, réordonner. Seulement sur des commits que personne n'a récupérés.
pick, reword, squash, fixup, drop, ou réordonne les lignes. Seulement sur des commits pas encore partagés.
$ git rebase -i HEAD~5
La correction est fusionnée automatiquement dans le commit visé pendant le rebase.
$ git commit --fixup <commit>$ git rebase -i --autosquash main
Garde le message. Uniquement si ce n'est pas encore poussé.
$ git add forgotten-file.ts$ git commit --amend --no-edit
Toutes les modifications depuis que la branche a quitté main, en un seul commit.
$ git reset --soft $(git merge-base HEAD main)$ git commit -m "feat: my feature"
Prend les commits de my-branch après old-base et les rejoue sur main.
$ git rebase --onto main old-base my-branch
Git retient comment tu as résolu un conflit et le refait la fois suivante.
$ git config --global rerere.enabled true
Worktrees, sous-modules, Git LFS, hooks, signature et maintenance.
Un second dossier sur une autre branche, partageant le même dépôt. Plus besoin de stash.
$ git worktree add ../hotfix main$ git worktree list
Refuse s'il contient des modifications non commitées (sauf avec --force).
$ git worktree remove ../hotfix
Fixe un commit précis de l'autre dépôt. Commite aussi .gitmodules.
$ git submodule add https://github.com/OWNER/lib.git vendor/lib
Ou clone directement avec --recurse-submodules.
$ git submodule update --init --recursive
Le dépôt stocke un pointeur ; le fichier vit sur le serveur LFS.
$ git lfs install$ git lfs track "*.psd"$ git add .gitattributes
Les hooks dans .githooks/ (versionné) au lieu de .git/hooks/ (non versionné).
$ git config core.hooksPath .githooks
Uniquement les fichiers suivis, sans .git.
$ git archive --format=zip -o release.zip HEAD
gc compresse la base. N'utilise jamais --prune=now pendant que tu récupères des commits perdus.
$ git count-objects -vH$ git gc
Ajoute la clé comme « Signing key » sur GitHub pour obtenir le badge Verified.
$ git config --global gpg.format ssh$ git config --global user.signingkey ~/.ssh/id_ed25519.pub$ git config --global commit.gpgsign true
Trouve les objets corrompus ou manquants, et les commits perdus (dangling).
$ git fsck --full
Git teste les commits par dichotomie avec ta commande, puis désigne le premier mauvais. Termine avec git bisect reset.
$ git bisect start HEAD v1.0.0$ git bisect run npm test
Les autres dossiers disparaissent de ton disque (pas du dépôt). git sparse-checkout disable remet tout.
$ git sparse-checkout set apps/web packages/ui