// Copier-coller

Des commandes Git prêtes à copier

Chaque snippet est accompagné d'une explication simple et de son niveau de risque. Copie avec modération.

Risque

122 commandes

Démarrer

10 commandes

Installer Git, créer un dépôt, faire le premier commit et le mettre sur GitHub.

Git est-il installé ?

Affiche la version. « command not found » ? Voir la leçon « Installer Git » de l'Academy.

Sans risque
$ git --version

Installer Git sur Windows

Avec winget, inclus dans Windows 10 et 11. Ouvre un nouveau terminal ensuite.

Sans risque
$ winget install --id Git.Git -e --source winget

Installer Git sur macOS

Installe les outils en ligne de commande d'Apple, Git compris. Ou : brew install git.

Sans risque
$ xcode-select --install

Installer Git sur Debian / Ubuntu

Fedora : sudo dnf install git. Arch : sudo pacman -S git.

Sans risque
$ sudo apt install git

Créer un dépôt

Transforme le dossier courant en dépôt Git. Une fois par projet, à sa racine.

Sans risque
$ git init

Faire le premier commit

Ajoute d'abord un .gitignore, pour que node_modules et .env n'y finissent pas.

Sans risque
$ git add .
$ git commit -m "chore: initial commit"

Mettre un projet local sur GitHub

Crée d'abord un dépôt vide sur GitHub. -u relie main à origin pour les prochains push.

Sans risque
$ git remote add origin git@github.com:OWNER/REPO.git
$ git push -u origin main

Récupérer un projet

Copie tout le dépôt et son historique dans un nouveau dossier.

Sans risque
$ git clone git@github.com:OWNER/REPO.git

Cloner seulement la dernière version

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.

Sans risque
$ git clone --depth 1 https://github.com/owner/repo.git

Cloner une seule branche

Télécharge une seule branche et se place dessus, en ignorant les autres.

Sans risque
$ git clone -b dev --single-branch https://github.com/owner/repo.git

Configuration

7 commandes

Configurer Git une fois, gagner du temps pour toujours.

Dire à Git qui tu es

Inscrit dans chaque commit. Sans --global, ne s'applique qu'à un seul dépôt.

Sans risque
$ git config --global user.name "Your Name"
$ git config --global user.email "you@example.com"

Nommer les nouvelles branches main

Utilisé par git init pour chaque nouveau dépôt.

Sans risque
$ git config --global init.defaultBranch main

Pull avec rebase par défaut

Fini les commits « Merge branch 'main' of … » qui encombrent l'historique.

Sans risque
$ git config --global pull.rebase true

Créer un alias de log lisible

Ensuite, tape simplement git lg.

Sans risque
$ git config --global alias.lg "log --oneline --graph --decorate --all"

Voir toute ta configuration

Chaque réglage et le fichier d'où il vient. Parfait pour comprendre un comportement bizarre.

Sans risque
$ git config --list --show-origin

Utiliser VS Code comme éditeur de Git

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.

Sans risque
$ git config --global core.editor "code --wait"

Fins de ligne sous Windows

Convertit en CRLF à l'extraction, en LF au commit. Sous macOS/Linux, utilise input.

Sans risque
$ git config --global core.autocrlf true

Bases

8 commandes

Les commandes du quotidien pour savoir où tu en es et préparer un commit.

Où est-ce que j'en suis ?

Statut court avec la branche actuelle et ton avance/retard sur le remote.

Sans risque
$ git status -sb

Indexer seulement une partie d'un fichier

Passe en revue chaque modification et choisis ce qui va dans le commit.

Sans risque
$ git add -p

Voir ce que tu vas commit

Affiche les modifications indexées. Lance-la avant chaque commit, tes reviewers t'aimeront.

Sans risque
$ git diff --staged

Renommer ou déplacer un fichier

Git enregistre directement le renommage. Ajoute -f pour ne changer que les majuscules / minuscules.

Sans risque
$ git mv old-name.ts new-name.ts

Supprimer un fichier et l'enregistrer

Le supprime du disque et indexe la suppression. --cached pour le garder sur le disque.

Prudence
$ git rm path/to/file

Résumé de ce qui a changé

Fichiers modifiés et nombre de lignes ajoutées / supprimées, sans le détail.

Sans risque
$ git diff --stat

Indexer et commiter tous les fichiers modifiés

-a indexe chaque fichier suivi qui a changé. Les nouveaux fichiers (non suivis) ne sont PAS inclus.

Sans risque
$ git commit -am "fix: message"

Voir les changements mot par mot

Au lieu de lignes entières, montre exactement quels mots ont changé. Idéal pour du texte et de la doc.

Sans risque
$ git diff --word-diff

Annuler

9 commandes

Revenir sur une modification, un commit ou un push — du plus doux au plus brutal.

Corriger le dernier commit

Change le message ou ajoute des fichiers oubliés. Réécrit le commit : à éviter s'il est déjà poussé.

Prudence
$ git commit --amend

Annuler le dernier commit, garder les modifs

Le commit disparaît, ses modifications restent indexées. Parfait pour refaire un commit.

Prudence
$ git reset --soft HEAD~1

Annuler les modifications d'un fichier

Remet le fichier dans son dernier état commité. Les modifications non commitées sont perdues pour de bon.

Destructrice
$ git restore path/to/file

Retirer un fichier de l'index

Retire le fichier du prochain commit, garde tes modifications.

Sans risque
$ git restore --staged path/to/file

Annuler un commit déjà poussé

Crée un nouveau commit qui fait l'inverse. L'historique reste intact : l'annulation respectueuse de l'équipe.

Sans risque
$ git revert <commit>

Rendre ma branche identique au remote

Jette les commits locaux ET les modifications non commitées. Crée d'abord une branche de secours.

Destructrice
$ git reset --hard origin/main

Ramener une ancienne version d'un fichier

Remplace le fichier de ta copie de travail par sa version de ce commit. Commite-le pour le garder.

Prudence
$ git restore --source=<commit> -- path/to/file

Annuler un merge déjà poussé

Crée un commit qui annule le merge. -m 1 garde la ligne principale (la branche dans laquelle tu as mergé).

Prudence
$ git revert -m 1 <merge-hash>

Tout désindexer

Retire tous les fichiers de l'index. Tes modifications restent sur le disque.

Sans risque
$ git restore --staged .

Branches

9 commandes

Créer, changer, nettoyer et déplacer du travail entre branches.

Créer une branche et s'y placer

L'équivalent moderne de git checkout -b.

Sans risque
$ git switch -c feature/my-feature

Lister les branches déjà mergées

Trouve les branches que tu peux supprimer sans risque.

Sans risque
$ git branch --merged main

Supprimer une branche mergée

-d refuse si la branche n'est pas mergée. -D force (et tu finiras sur notre page Urgences).

Prudence
$ git branch -d feature/old

Renommer la branche actuelle

Renommage local uniquement. Pousse le nouveau nom et supprime l'ancien sur le remote si besoin.

Sans risque
$ git branch -m new-name

Mettre ma branche à jour par-dessus main

Rejoue tes commits sur le dernier main. Réécrit ta branche : seulement sur des branches qui t'appartiennent.

Prudence
$ git fetch origin
$ git rebase origin/main

Copier un commit sur la branche actuelle

Applique ici les modifications d'un commit précis.

Sans risque
$ git cherry-pick <commit>

Revenir à la branche précédente

Comme cd - dans un terminal : revient sur la branche où tu étais avant.

Sans risque
$ git switch -

Lister les branches locales et distantes

Les distantes apparaissent en remotes/origin/… Fais un git fetch avant pour être à jour.

Sans risque
$ git branch -a

Les branches, les plus récentes d'abord

Retrouve la branche sur laquelle tu bossais hier parmi cinquante.

Sans risque
$ git branch --sort=-committerdate

Historique

17 commandes

Comprendre ce qui s'est passé, quand, et qui l'a fait.

Voir tout l'historique en graphe

Le meilleur moyen de comprendre la situation avant de réparer quoi que ce soit.

Sans risque
$ git log --oneline --graph --decorate --all

Ton dernier espoir

Toutes les positions par lesquelles HEAD est passé, même après des resets et des branches supprimées.

Sans risque
$ git reflog

Qui a écrit cette ligne ?

Spoiler : c'était sûrement toi. -w ignore les espaces, -C suit le code déplacé.

Sans risque
$ git blame -w -C path/to/file

Trouver quand du code est apparu

Liste les commits qui ont ajouté ou supprimé cette chaîne.

Sans risque
$ git log -S "functionName" --oneline

Trouver le commit qui a tout cassé

Recherche dichotomique dans l'historique. Termine avec git bisect reset.

Sans risque
$ git bisect start
$ git bisect bad
$ git bisect good <commit>

Voir ce qu'un commit a changé

Message, auteur et diff complet d'un commit.

Sans risque
$ git show <commit>

Comparer une branche avec main

Trois points : seulement ce que la branche a ajouté depuis qu'elle a quitté main. Exactement ce qu'affiche une PR.

Sans risque
$ git diff main...feature/my-feature

Historique d'un seul fichier

--follow continue à travers les renommages.

Sans risque
$ git log --follow --oneline -- path/to/file

Voir un fichier tel qu'il était dans un ancien commit

L'affiche sans toucher à ta copie de travail. Redirige avec > pour l'enregistrer.

Sans risque
$ git show <commit>:path/to/file

Les commits de quelqu'un, sur une période

Marche aussi avec --until, et --grep="fix" pour chercher dans les messages.

Sans risque
$ git log --author="Alice" --since="2 weeks ago" --oneline

Qui a le plus commité

Nombre de commits par auteur. Ajoute --no-merges pour ignorer les commits de merge.

Sans risque
$ git shortlog -sn

Chercher du texte dans les fichiers suivis

Rapide, ignore node_modules et les autres fichiers ignorés. Ajoute un commit pour chercher dans une ancienne version.

Sans risque
$ git grep -n "TODO"

Les commits pas encore poussés

Ce que tu as et que le serveur n'a pas (après un git fetch).

Sans risque
$ git log origin/main..HEAD --oneline

Ce qui est nouveau sur le serveur

Les commits que tu récupéreras au prochain pull, sans encore les tirer.

Sans risque
$ git fetch && git log HEAD..origin/main --oneline

Chercher dans les messages de commit

Chaque commit dont le message contient le mot. Ajoute -i pour ignorer la casse.

Sans risque
$ git log --oneline --grep="login"

Ce qui s'est passé récemment

Les commits des deux dernières semaines. Marche aussi avec « yesterday », « 2026-11-01 »…

Sans risque
$ git log --since="2 weeks ago" --oneline --no-merges

Qui a écrit ces lignes

Le blame seulement des lignes 10 à 30, avec le commit et l'auteur de chacune.

Sans risque
$ git blame -L 10,30 path/to/file

Remote

12 commandes

Parler à GitHub / GitLab : fetch, push, remotes et tags.

Où est-ce que je pousse ?

Liste les remotes et leurs URL.

Sans risque
$ git remote -v

Changer l'URL du remote

Après avoir renommé un dépôt ou être passé de HTTPS à SSH.

Prudence
$ git remote set-url origin git@github.com:OWNER/REPO.git

Taguer une version

Les tags ne sont pas poussés par défaut : pousse-les explicitement.

Sans risque
$ git tag -a v1.2.0 -m "v1.2.0"
$ git push origin v1.2.0

Pull sans commit de merge

Garde un historique linéaire en rejouant tes commits locaux par-dessus.

Prudence
$ git pull --rebase

Pousser une nouvelle branche

Publie la branche actuelle et la lie au remote.

Sans risque
$ git push -u origin HEAD

Force push, mais poliment

Écrase le remote seulement si personne n'a poussé depuis ton dernier fetch. N'utilise jamais --force tout court.

Destructrice
$ git push --force-with-lease

Oublier les branches distantes supprimées

Nettoie les références origin/* qui n'existent plus sur le serveur.

Sans risque
$ git fetch --prune

Supprimer une branche sur le remote

La branche disparaît pour tout le monde. Ses commits restent s'ils sont mergés ailleurs.

Destructrice
$ git push origin --delete feature/old

Garder un fork à jour

upstream = le projet d'origine, origin = ton fork.

Prudence
$ git remote add upstream git@github.com:ORIGINAL/REPO.git
$ git fetch upstream
$ git rebase upstream/main

Tester une pull request GitHub en local

Remplace 123 par le numéro de la PR.

Sans risque
$ git fetch origin pull/123/head:pr-123
$ git switch pr-123

Pull seulement si rien n'a divergé

Refuse de créer un commit de merge : soit il avance simplement ta branche, soit il s'arrête et te laisse décider.

Sans risque
$ git pull --ff-only

Renommer un remote

Pratique après un fork : l'original devient upstream, ton fork devient origin.

Sans risque
$ git remote rename origin upstream

Pull requests

14 commandes

Ouvrir, mettre à jour, relire et nettoyer une pull request (ou une merge request GitLab).

Commencer une branche de pull request

Toujours depuis un main à jour, pour que la PR ne contienne que ton travail.

Sans risque
$ git switch main
$ git pull
$ git switch -c feat/my-change

Pousser la branche pour ouvrir la PR

Git affiche un lien pour créer la pull request. Ensuite un simple git push la met à jour.

Sans risque
$ git push -u origin HEAD

Ouvrir une PR depuis le terminal (CLI GitHub)

--fill reprend le titre et la description de tes commits. Ajoute --draft pour une PR brouillon.

Sans risque
$ gh pr create --fill

Récupérer une PR pour la relire (CLI GitHub)

Marche aussi pour les PR venant de forks.

Sans risque
$ gh pr checkout 123

Statut et checks de mes PR

Tes PR ouvertes, les reviews qui t'attendent, et les résultats de la CI.

Sans risque
$ gh pr status
$ gh pr checks

Tester une merge request GitLab en local

Remplace 42 par le numéro de la merge request.

Sans risque
$ git fetch origin merge-requests/42/head:mr-42
$ git switch mr-42

Ce que change ma PR

Les trois points comparent avec le point de départ de ta branche : exactement le diff de la PR.

Sans risque
$ git diff --stat origin/main...HEAD

Les commits de ma PR

Doit lister seulement ton travail. Autre chose ? Ta branche est partie du mauvais endroit.

Sans risque
$ git log --oneline origin/main..HEAD

Mettre à jour ma PR avec main (merge)

Intègre le dernier main dans ta branche. Pas de push forcé.

Sans risque
$ git fetch origin
$ git merge origin/main
$ git push

Mettre à jour ma PR avec main (rebase)

Rejoue tes commits sur le dernier main : historique linéaire, demande un push forcé.

Prudence
$ git fetch origin
$ git rebase origin/main
$ git push --force-with-lease

Ranger les commits de la PR avant le merge

Replie tes commits fixup! dans ceux qu'ils corrigent.

Prudence
$ git rebase -i --autosquash origin/main
$ git push --force-with-lease

Synchroniser mon fork avec l'original

Demande d'avoir ajouté l'original en upstream (git remote add upstream …).

Sans risque
$ git fetch upstream
$ git switch main
$ git merge --ff-only upstream/main
$ git push origin main

Nettoyer après le merge de la PR

Après un squash merge, -d refuse : utilise -D une fois la PR vérifiée comme mergée.

Sans risque
$ git switch main
$ git pull
$ git branch -d feat/my-change

Ce qui a changé après un push forcé

Compare deux versions d'une branche de PR commit par commit : parfait pour les reviewers.

Sans risque
$ git range-diff origin/main old-head new-head

Stash

6 commandes

Mettre de côté du travail inachevé sans le commiter.

Cacher ton bazar pour plus tard

Sauvegarde les modifications, fichiers non suivis inclus (-u), avec un message dont tu te remercieras.

Sans risque
$ git stash push -u -m "wip: something"

Ressortir le bazar

Applique le dernier stash et le supprime. En cas de conflit, le stash est conservé.

Prudence
$ git stash pop

Lister tes stashs

stash@{0} est le plus récent.

Sans risque
$ git stash list

Voir ce qu'il y a dans un stash

Le diff complet du stash, sans l'appliquer.

Sans risque
$ git stash show -p stash@{0}

Transformer un stash en branche

Crée une branche là où le stash a été fait et l'y applique : aucun conflit avec ce qui a changé depuis.

Sans risque
$ git stash branch fix/from-stash stash@{0}

Supprimer un stash

Disparaît de la liste. Récupérable un temps avec git fsck si c'était une erreur.

Prudence
$ git stash drop stash@{0}

Nettoyage

6 commandes

Supprimer ce que Git ne devrait pas suivre ni garder.

Prévisualiser les fichiers non suivis à supprimer

Simulation : montre ce que git clean supprimerait, ne supprime rien.

Sans risque
$ git clean -nd

Supprimer tous les fichiers non suivis

Irréversible : Git n'a jamais connu ces fichiers, il ne peut pas les ramener. Lance d'abord la simulation.

Destructrice
$ git clean -fd

Arrêter de suivre un dossier commité

Le retire de Git, le garde sur le disque. Ajoute-le au .gitignore juste après.

Sans risque
$ git rm -r --cached node_modules

Pourquoi ce fichier est-il ignoré ?

Affiche le fichier .gitignore et la ligne qui s'appliquent. Aucune sortie : le fichier n'est pas ignoré.

Sans risque
$ git check-ignore -v path/to/file

Prévisualiser les fichiers ignorés à supprimer (builds, caches)

X majuscule : seulement les fichiers listés dans le .gitignore. Remplace -n par -f pour supprimer vraiment.

Sans risque
$ git clean -ndX

Nettoyer les fichiers non suivis un par un

Un menu interactif : tu choisis quoi supprimer. Plus sûr que clean -fd.

Prudence
$ git clean -i

Tags et versions

6 commandes

Marquer des versions, les publier, savoir sur quelle version tu es.

Lister les tags, du plus récent au plus ancien

Filtre avec un motif : git tag --list "v2.*".

Sans risque
$ git tag --list --sort=-creatordate

Créer un tag annoté

Les tags annotés stockent auteur, date et message : à utiliser pour les versions.

Sans risque
$ git tag -a v1.3.0 -m "Release 1.3.0"

Pousser les commits et leurs tags

Pousse les tags annotés qui pointent vers les commits poussés.

Sans risque
$ git push --follow-tags

Supprimer un tag (local et distant)

À éviter pour une version publiée : des gens peuvent en dépendre.

Destructrice
$ git tag -d v1.3.0
$ git push origin --delete v1.3.0

Regarder le code d'une version

HEAD détachée : exploration en lecture seule. Crée une branche si tu veux corriger quelque chose.

Sans risque
$ git switch --detach v1.2.0

Sur quelle version suis-je ?

Ex. : v1.2.0-4-g3f9a2c1 = 4 commits après v1.2.0.

Sans risque
$ git describe --tags

Réécrire l'historique

6 commandes

Nettoyer des commits avant de les partager : squash, reword, réordonner. Seulement sur des commits que personne n'a récupérés.

Réécrire les 5 derniers commits

pick, reword, squash, fixup, drop, ou réordonne les lignes. Seulement sur des commits pas encore partagés.

Prudence
$ git rebase -i HEAD~5

Corriger proprement un commit plus ancien

La correction est fusionnée automatiquement dans le commit visé pendant le rebase.

Prudence
$ git commit --fixup <commit>
$ git rebase -i --autosquash main

Ajouter un fichier oublié au dernier commit

Garde le message. Uniquement si ce n'est pas encore poussé.

Prudence
$ git add forgotten-file.ts
$ git commit --amend --no-edit

Réunir toute une branche en un seul commit

Toutes les modifications depuis que la branche a quitté main, en un seul commit.

Prudence
$ git reset --soft $(git merge-base HEAD main)
$ git commit -m "feat: my feature"

Déplacer des commits sur une autre base

Prend les commits de my-branch après old-base et les rejoue sur main.

Prudence
$ git rebase --onto main old-base my-branch

Ne résoudre le même conflit qu'une fois

Git retient comment tu as résolu un conflit et le refait la fois suivante.

Sans risque
$ git config --global rerere.enabled true

Avancé

12 commandes

Worktrees, sous-modules, Git LFS, hooks, signature et maintenance.

Travailler sur deux branches en même temps

Un second dossier sur une autre branche, partageant le même dépôt. Plus besoin de stash.

Sans risque
$ git worktree add ../hotfix main
$ git worktree list

Supprimer un worktree supplémentaire

Refuse s'il contient des modifications non commitées (sauf avec --force).

Prudence
$ git worktree remove ../hotfix

Ajouter un dépôt dans le tien

Fixe un commit précis de l'autre dépôt. Commite aussi .gitmodules.

Sans risque
$ git submodule add https://github.com/OWNER/lib.git vendor/lib

Télécharger les sous-modules après un clone

Ou clone directement avec --recurse-submodules.

Sans risque
$ git submodule update --init --recursive

Versionner de gros fichiers avec Git LFS

Le dépôt stocke un pointeur ; le fichier vit sur le serveur LFS.

Sans risque
$ git lfs install
$ git lfs track "*.psd"
$ git add .gitattributes

Partager des hooks Git avec l'équipe

Les hooks dans .githooks/ (versionné) au lieu de .git/hooks/ (non versionné).

Sans risque
$ git config core.hooksPath .githooks

Exporter le projet en zip

Uniquement les fichiers suivis, sans .git.

Sans risque
$ git archive --format=zip -o release.zip HEAD

Taille du dépôt et nettoyage

gc compresse la base. N'utilise jamais --prune=now pendant que tu récupères des commits perdus.

Sans risque
$ git count-objects -vH
$ git gc

Signer les commits avec ta clé SSH

Ajoute la clé comme « Signing key » sur GitHub pour obtenir le badge Verified.

Sans risque
$ git config --global gpg.format ssh
$ git config --global user.signingkey ~/.ssh/id_ed25519.pub
$ git config --global commit.gpgsign true

Vérifier l'intégrité du dépôt

Trouve les objets corrompus ou manquants, et les commits perdus (dangling).

Sans risque
$ git fsck --full

Trouver le commit coupable automatiquement

Git teste les commits par dichotomie avec ta commande, puis désigne le premier mauvais. Termine avec git bisect reset.

Sans risque
$ git bisect start HEAD v1.0.0
$ git bisect run npm test

N'extraire que certains dossiers (monorepo)

Les autres dossiers disparaissent de ton disque (pas du dépôt). git sparse-checkout disable remet tout.

Sans risque
$ git sparse-checkout set apps/web packages/ui