Aide-mémoire

Commandes Git : aide-mémoire avec des exemples pour le quotidien

Mis à jour: · Skillaria.Top

Les principales commandes Git sont git init et git clone pour créer un dépôt, git status, git add et git commit pour enregistrer les modifications, git branch, git switch et git merge pour les branches, git push, git fetch et git pull pour se synchroniser avec le serveur, ainsi que git restore, git reset et git revert pour annuler des changements.

Voici un aide-mémoire Git pour le travail quotidien : les commandes sont regroupées par tâche, chacune avec un exemple et une courte explication. Gardez-le ouvert à côté du terminal : presque tout ce qu'un développeur fait avec Git dans une journée tient dans les 20 à 30 commandes de ces tableaux.

Pour bien comprendre les commandes, gardez en tête trois zones : le répertoire de travail (les fichiers sur le disque), l'index ou staging area (ce qui entrera dans le prochain commit) et le dépôt (l'historique des commits dans le dossier .git). La plupart des commandes Git déplacent des modifications entre ces trois zones ou entre le dépôt local et le dépôt distant.

Configurer Git

Ces commandes s'exécutent une fois après l'installation. L'option --global écrit les réglages dans ~/.gitconfig et s'applique à tous les dépôts de l'utilisateur ; sans elle, uniquement au dépôt courant.

CommandeCe qu'elle fait
git config --global user.name "Marie Dupont"Nom de l'auteur des commits
git config --global user.email "marie@example.com"E-mail de l'auteur des commits
git config --global init.defaultBranch mainNom de la branche par défaut des nouveaux dépôts
git config --global core.editor "code --wait"Éditeur des messages de commit (ici VS Code)
git config --global pull.rebase falseComportement par défaut de git pull : fusion
git config --global core.autocrlf inputConversion de CRLF en LF au commit (macOS/Linux ; sous Windows, généralement true)
git config --list --show-originAfficher tous les réglages et le fichier d'où vient chacun
git config --global alias.st statusAlias : git st au lieu de git status
git --versionVersion de Git installée
git help commitAide complète d'une commande (ou git commit -h pour la version courte)

Créer et cloner un dépôt

CommandeCe qu'elle fait
git initCrée un dépôt vide (dossier .git) dans le répertoire courant
git init my-projectCrée le répertoire my-project et un dépôt à l'intérieur
git clone https://github.com/user/repo.gitCopie un dépôt distant avec tout son historique
git clone git@github.com:user/repo.git appClone en SSH dans le dossier app
git clone --depth 1 URLClone superficiel : uniquement le dernier commit, rapide et léger
git clone -b develop URLClone et se place directement sur la branche develop

Le cycle de base : status, add, commit

C'est le cœur du travail quotidien : voir ce qui a changé, sélectionner ce qu'il faut dans l'index et l'enregistrer par un commit.

CommandeCe qu'elle fait
git statusÉtat : fichiers modifiés, indexés et non suivis
git status -sFormat court : M — modifié, A — ajouté, ?? — non suivi
git add file.txtAjouter un fichier à l'index
git add .Ajouter toutes les modifications du répertoire courant et en dessous, suppressions comprises
git add -AAjouter toutes les modifications de tout le dépôt
git add -pChoisir en interactif des fragments (hunks) de modifications
git commit -m "Ajouter le formulaire de connexion"Créer un commit à partir de l'index avec un message
git commit -am "Corriger une coquille"Indexer tous les fichiers suivis modifiés et commiter ; les nouveaux fichiers n'y entrent pas
git commit --amendRéécrire le dernier commit : ajouter un oubli depuis l'index ou corriger le message
git commit --amend --no-editCompléter le dernier commit sans changer le message
git rm file.txtSupprimer un fichier du disque et de l'index
git rm --cached secret.envNe plus suivre un fichier tout en le gardant sur le disque
git mv old.js new.jsRenommer ou déplacer un fichier

Un scénario typique ressemble à ceci :

git status
git add src/login.js src/login.css
git diff --staged          # vérifier ce qui partira exactement dans le commit
git commit -m "Ajouter le formulaire de connexion"

N'utilisez pas --amend sur des commits déjà poussés sur une branche partagée : il crée un nouveau commit avec un autre hash, et vos collègues devront gérer la divergence d'historique.

Consulter l'historique et les modifications

CommandeCe qu'elle fait
git logHistorique des commits de la branche courante
git log --onelineChaque commit sur une ligne : hash court et titre
git log --oneline --graph --allGraphe de toutes les branches dans le terminal
git log -p file.txtHistorique d'un fichier avec le diff de chaque commit
git log --author="Marie" --since="2 weeks ago"Filtrer par auteur et par date
git log -S "getUser"Commits où la chaîne getUser a été ajoutée ou supprimée
git log main..featureCommits présents dans feature mais absents de main
git diffModifications du répertoire de travail pas encore ajoutées à l'index
git diff --stagedModifications de l'index par rapport au dernier commit (synonyme de --cached)
git diff main featureDifférence entre les extrémités de deux branches
git diff HEAD~3 -- src/Modifications du dossier src sur les trois derniers commits
git show a1b2c3dMétadonnées et diff d'un commit précis
git show HEAD:README.mdContenu d'un fichier dans le dernier commit
git blame app.jsQui a modifié chaque ligne en dernier, et dans quel commit
git shortlog -snNombre de commits par auteur

Les références de commits servent partout : HEAD — le commit courant, HEAD~1 — son parent, HEAD~3 — trois pas en arrière via le premier parent, HEAD^2 — le second parent d'un commit de merge.

Branches : créer, changer, supprimer

Depuis la version 2.23, Git propose git switch pour les branches et git restore pour les fichiers — elles se partagent le travail de git checkout, qui faisait trop de choses. Les anciennes formes fonctionnent toujours.

CommandeCe qu'elle fait
git branchListe des branches locales, la courante est marquée d'un *
git branch -aBranches locales et distantes (remote-tracking)
git branch -vvBranches avec leur dernier commit et leur retard/avance sur l'upstream
git branch feature/loginCréer une branche sans s'y placer
git switch feature/loginPasser sur une branche
git switch -c feature/loginCréer une branche et s'y placer (équivalent de git checkout -b)
git switch -Revenir à la branche précédente
git branch -m new-nameRenommer la branche courante
git branch -d feature/loginSupprimer une branche si elle a déjà été fusionnée
git branch -D feature/loginSupprimer une branche de force, même non fusionnée
git branch --mergedBranches déjà fusionnées dans la branche courante — candidates à la suppression

Fusion et rebase

CommandeCe qu'elle fait
git merge featureFusionner feature dans la branche courante (fast-forward si possible)
git merge --no-ff featureToujours créer un commit de merge
git merge --squash featureRassembler toutes les modifications de la branche dans l'index en un seul lot, puis git commit
git merge --abortAnnuler une fusion en conflit et revenir à l'état initial
git rebase mainRejouer les commits de la branche courante par-dessus main
git rebase -i HEAD~4En interactif : fusionner (squash), renommer, réordonner, supprimer les 4 derniers commits
git rebase --continueContinuer après avoir résolu un conflit
git rebase --abortAnnuler complètement le rebase
git cherry-pick a1b2c3dAppliquer un seul commit sur la branche courante sous forme de nouveau commit

La résolution d'un conflit de fusion se déroule presque toujours de la même façon :

git merge feature
# CONFLICT (content): Merge conflict in app.js
git status                 # fichiers dans la section "both modified"
# on corrige app.js, on retire les marqueurs <<<<<<< ======= >>>>>>>
git add app.js
git commit                 # Git propose un message de commit de merge tout prêt

La règle d'or du rebase : ne rebasez pas des commits qui se trouvent déjà sur une branche partagée et sur lesquels d'autres construisent leur travail.

Travailler avec les dépôts distants

CommandeCe qu'elle fait
git remote -vListe des remotes et de leurs adresses
git remote add origin git@github.com:user/repo.gitAssocier un dépôt distant sous le nom origin
git remote set-url origin NEW_URLChanger l'adresse d'un remote (par exemple HTTPS vers SSH)
git remote remove upstreamRetirer un remote
git fetchTélécharger les nouveaux commits et branches sans toucher à vos fichiers
git fetch --pruneIdem, et supprimer les références aux branches effacées sur le serveur
git pullgit fetch + fusion de la branche upstream dans la branche courante
git pull --rebasegit fetch + rebase de vos commits par-dessus ceux récupérés
git pushEnvoyer les commits de la branche courante vers son upstream
git push -u origin feature/loginPremier envoi d'une branche avec définition de l'upstream
git push --force-with-leaseÉcraser la branche distante seulement si personne n'y a ajouté de nouveaux commits
git push origin --delete feature/loginSupprimer une branche sur le serveur
git push --tagsEnvoyer tous les tags locaux

Au lieu de git push --force, prenez l'habitude de --force-with-lease : si un collègue a poussé entre-temps sur la même branche, la commande refusera d'écraser son travail.

Annuler des modifications

La partie la plus stressante de Git. La question clé avant de choisir une commande : les modifications sont-elles seulement dans les fichiers, déjà dans l'index, dans un commit local ou dans un commit publié ?

SituationCommande
Annuler les modifications d'un fichier (revenir au dernier commit)git restore app.js
Retirer un fichier de l'index en gardant les modificationsgit restore --staged app.js
Restaurer un fichier depuis un commit précisgit restore --source=a1b2c3d app.js
Annuler le dernier commit en gardant les modifications dans l'indexgit reset --soft HEAD~1
Annuler le dernier commit en gardant les modifications dans les fichiersgit reset HEAD~1 (mode --mixed par défaut)
Supprimer le dernier commit et toutes ses modificationsgit reset --hard HEAD~1
Annuler un commit publié par un nouveau commit « inverse »git revert a1b2c3d
Annuler un commit de mergegit revert -m 1 <merge-hash>
Voir quels fichiers non suivis seraient supprimésgit clean -n
Supprimer les fichiers et dossiers non suivisgit clean -fd
Retrouver un commit « perdu » après un reset ou un rebasegit reflog, puis git reset --hard HEAD@{2}

git reset --hard et git clean -f suppriment définitivement les modifications non commitées : le reflog ne conserve que les commits, pas les modifications du répertoire de travail. Avant de les lancer, faites un git stash ou au moins un git status.

Stash : mettre de côté un travail inachevé

CommandeCe qu'elle fait
git stashMettre de côté les modifications des fichiers suivis et nettoyer le répertoire de travail
git stash push -u -m "wip: formulaire"Mettre de côté avec les fichiers non suivis, avec une description
git stash listListe des lots mis de côté : stash@{0}, stash@{1}…
git stash show -p stash@{0}Afficher le diff d'un lot
git stash popRestaurer le dernier lot et le retirer de la liste
git stash apply stash@{1}Restaurer un lot en le gardant dans la liste
git stash drop stash@{1}Supprimer un lot
git stash branch fix-formCréer une branche à partir du commit où le stash a été fait et l'y appliquer

Tags et releases

CommandeCe qu'elle fait
git tagListe des tags
git tag -a v1.2.0 -m "Release 1.2.0"Tag annoté avec auteur, date et message
git tag v1.2.0 a1b2c3dTag léger sur un commit précis
git push origin v1.2.0Envoyer un seul tag
git tag -d v1.2.0Supprimer un tag en local
git push origin --delete v1.2.0Supprimer un tag sur le serveur
git describe --tagsTag le plus proche et nombre de commits depuis, par exemple v1.2.0-3-ga1b2c3d

Commandes Git avancées

CommandeCe qu'elle fait
git bisect start, git bisect bad, git bisect good v1.1.0Recherche dichotomique du commit qui a introduit un bug ; à la fin, git bisect reset
git worktree add ../hotfix mainUn second dossier de travail sur une autre branche du même dépôt
git submodule update --init --recursiveTélécharger les sous-modules après un clone
git grep "TODO"Recherche rapide dans les fichiers suivis
git format-patch -1 HEAD / git apply fix.patchEnregistrer un commit sous forme de patch et appliquer un patch au répertoire de travail
git gcCompacter les objets et nettoyer le dépôt (Git le fait généralement tout seul)

Erreurs fréquentes et comment les corriger

Commit fait sur main au lieu d'une nouvelle branche

Si le commit n'a pas encore été poussé, créez une branche sur le commit courant et ramenez main en arrière :

git branch feature/login      # la branche pointe sur votre commit
git reset --hard HEAD~1       # main recule d'un cran
git switch feature/login

Fichier oublié dans le dernier commit

git add forgotten.js
git commit --amend --no-edit

Push refusé : rejected, non-fast-forward

Le serveur contient des commits que vous n'avez pas. Récupérez-les d'abord, puis poussez :

git pull --rebase
git push

Un fichier de mots de passe commité par erreur

Retirez-le du suivi et ajoutez-le au .gitignore : git rm --cached .env, puis un commit. Si le commit est déjà publié, considérez le secret comme compromis et renouvelez-le — il est toujours présent dans l'historique.

En résumé

Pour le travail quotidien, un petit ensemble suffit : status, add, commit, switch, merge, pull, push et log --oneline. Choisissez les commandes d'annulation — restore, reset, revert — selon que le commit est publié ou non, et gardez reflog en tête comme filet de sécurité de dernier recours. Toutes les commandes Git de cet aide-mémoire sont mises en pratique dans le cours Git, où vous les essayez chacune dans votre propre dépôt.

Questions fréquentes

Combien de commandes Git un débutant doit-il connaître ?

Pour commencer, 10 à 12 suffisent : init, clone, status, add, commit, log, diff, branch, switch, merge, pull et push. Les autres s'apprennent au fil des besoins.

Quelle différence entre git switch et git checkout ?

git switch sait seulement changer de branche et en créer, alors que git checkout restaure aussi des fichiers. La séparation entre switch et restore évite d'écraser des modifications par erreur en confondant une branche et un fichier.

Comment afficher l'aide de n'importe quelle commande Git ?

Lancez git help nom-de-la-commande pour le manuel complet ou git nom-de-la-commande -h pour la liste résumée des options. La même documentation est disponible sur git-scm.com.

Peut-on raccourcir les commandes Git trop longues ?

Oui, avec des alias : git config --global alias.lg "log --oneline --graph --all" vous permet ensuite de taper git lg.

Ces commandes fonctionnent-elles sous Windows ?

Oui, les commandes sont identiques sur tous les systèmes. Sous Windows, on les exécute facilement dans Git Bash, PowerShell ou le terminal de l'éditeur de code.

Apprenez ce sujet en vidéo

Ce sujet est traité en détail avec de la pratique dans le cours « Git de zéro à développeur confirmé ».

Voir le cours