Tu connais git add, git commit et git push, mais tu bloques dès qu’il faut annuler une modification, gérer une branche ou récupérer un commit perdu ? Cette antisèche réunit les 30 commandes Git indispensables, classées par situation, avec pour chacune un exemple concret, les options utiles et les pièges à éviter. À garder ouverte dans un onglet !
Git compte plus de 150 commandes, mais au quotidien, une trentaine suffit pour faire face à 99 % des situations. Encore faut-il savoir laquelle utiliser au bon moment, surtout quand quelque chose s’est mal passé.
Cette antisèche des commandes Git est organisée par besoin : configurer, créer, enregistrer, consulter l’historique, travailler avec les branches, synchroniser avec GitHub, annuler et déboguer. Si tu débutes complètement, commence par notre guide Git et GitHub pour débutant, qui configure ton poste pas à pas.
- Les commandes sont classées par situation, dans l’ordre où tu les rencontres.
- Chaque commande est accompagnée d’un exemple prêt à copier.
- Les commandes destructrices (qui peuvent faire perdre du travail) sont signalées par ⚠️.
- Un tableau récapitulatif t’attend à la fin.
Les zones de Git en 30 secondes
Pour comprendre les commandes Git, il faut connaître les quatre endroits où vit ton code :
| Zone | Description | On y entre avec |
|---|---|---|
| Répertoire de travail | Tes fichiers, tels que tu les modifies | Ton éditeur |
| Zone de préparation (index, staging) | Les modifications choisies pour le prochain commit | git add |
| Dépôt local | L’historique des commits, sur ton ordinateur | git commit |
| Dépôt distant | La copie partagée (GitHub, GitLab…) | git push |
La plupart des commandes déplacent des modifications d’une zone à l’autre, dans un sens ou dans l’autre.
Configuration : 3 commandes Git à lancer une seule fois
1. git config : définir ton identité et tes préférences
git config --global user.name "Prénom Nom"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
git config --global --list # afficher toute ta configuration--global s’applique à tous tes projets. Sans cette option, le réglage ne concerne que le dépôt courant (pratique pour utiliser une adresse professionnelle sur un projet précis).
2. git config alias : créer des raccourcis
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --decorate --all"Tu peux maintenant taper git st et git lg. Ce dernier affiche un historique graphique de toutes les branches, très pratique.
3. git help : l’aide intégrée
git help commit # documentation complète de la commande
git commit -h # résumé rapide des optionsCréer ou récupérer un dépôt
4. git init : créer un dépôt
cd mon-projet
git initCrée un dossier caché .git qui contiendra tout l’historique. À ne faire qu’une fois par projet.
5. git clone : copier un dépôt existant
git clone [email protected]:utilisateur/projet.git
git clone [email protected]:utilisateur/projet.git mon-dossier # dans un dossier au nom choisi
git clone --depth 1 https://github.com/utilisateur/gros-projet.git # sans l'historique complet--depth 1 ne télécharge que le dernier état du projet : beaucoup plus rapide pour un gros dépôt dont tu n’as pas besoin de l’historique.
Enregistrer ton travail
6. git status : où en suis-je ?
git status
git status -s # version courteLa commande Git la plus utilisée. Elle indique la branche courante, les fichiers modifiés, préparés ou non suivis. Lance-la sans modération, avant chaque autre commande.
7. git add : préparer les modifications
git add index.html # un fichier
git add src/ # un dossier
git add . # tout le dossier courant
git add -p # choisir morceau par morceaugit add -p (patch) te montre chaque modification et te demande si tu veux l’inclure. Idéal pour découper un gros travail en plusieurs commits cohérents.
8. git commit : enregistrer un cliché
git commit -m "Ajoute la validation du formulaire de contact"
git commit -am "Corrige une faute de frappe" # add + commit des fichiers déjà suivisÉcris à l’impératif, en décrivant ce que fait le commit : « Corrige le calcul de la TVA » plutôt que « fix » ou « modifs ». Un commit = une modification logique. Beaucoup d’équipes utilisent la convention Conventional Commits : feat: ajoute l’export PDF, fix: corrige le tri par date.
9. git diff : voir les modifications
git diff # modifications NON préparées
git diff --staged # modifications préparées (ce qui partira au prochain commit)
git diff main..ma-branche # différences entre deux branchesPrends l’habitude de lancer git diff --staged juste avant chaque commit : tu repères les oublis (un console.log de test, un mot de passe…) avant qu’ils n’entrent dans l’historique.
10. git rm et git mv : supprimer et renommer
git rm ancien-fichier.js # supprime le fichier et prépare la suppression
git rm --cached secrets.env # arrête de suivre le fichier sans le supprimer du disque
git mv vieux-nom.js nouveau-nom.js # renomme en conservant le suivigit rm --cached est la solution quand tu as commité par erreur un fichier qui aurait dû être dans le .gitignore : il reste sur ton disque, mais Git ne le suit plus.
Consulter l’historique
11. git log : l’historique des commits
git log
git log --oneline # une ligne par commit
git log --oneline --graph --all # graphique de toutes les branches
git log -p fichier.php # l'historique détaillé d'un fichier
git log --author="Léa" --since="2 weeks ago"
git log -S "calculerTva" # les commits qui ont ajouté ou supprimé ce textegit log -S est redoutable pour retrouver quand une fonction a été ajoutée ou supprimée.
12. git show : le détail d’un commit
git show a1b2c3d # le contenu complet d'un commit
git show HEAD~2:src/config.php # un fichier tel qu'il était il y a 2 commitsHEAD désigne le commit actuel, HEAD~1 le précédent, HEAD~2 celui d’avant.
13. git blame : qui a écrit cette ligne ?
git blame src/panier.js
git blame -L 40,60 src/panier.js # seulement les lignes 40 à 60Malgré son nom (blâmer), git blame ne sert pas à accuser : il te permet de retrouver le commit, et donc le contexte, qui explique une ligne de code étrange.
Travailler avec les branches
Une branche est une ligne de développement indépendante. Tu crées une branche pour chaque fonctionnalité ou correction, tu y travailles tranquillement, puis tu la fusionnes dans main quand elle est prête.
14. git branch : lister, créer, supprimer
git branch # liste les branches locales
git branch -a # inclut les branches distantes
git branch fonctionnalite-paiement # crée une branche (sans y aller)
git branch -d fonctionnalite-paiement # supprime une branche fusionnée
git branch -m nouveau-nom # renomme la branche courante15. git switch : changer de branche
git switch main
git switch -c fonctionnalite-paiement # crée la branche ET y va
git switch - # revient à la branche précédentegit switch (depuis Git 2.23) remplace l’ancien usage de git checkout pour les branches, avec une syntaxe plus claire. git checkout fonctionne toujours, mais il fait trop de choses différentes, ce qui le rend source d’erreurs.
16. git merge : fusionner une branche
git switch main
git merge fonctionnalite-paiementSi les deux branches ont modifié les mêmes lignes, Git signale un conflit. Ouvre les fichiers concernés, choisis la bonne version entre les marqueurs <<<<<<<, ======= et >>>>>>>, puis :
git add fichier-resolu.js
git commit # termine la fusion
git merge --abort # ou : abandonne la fusion et revient à l'état d'avantVS Code affiche chaque conflit avec des boutons « Accepter la modification actuelle », « Accepter la modification entrante » ou « Accepter les deux ». Bien plus confortable que d’éditer les marqueurs à la main.
17. git rebase : rejouer tes commits sur une autre base
git switch fonctionnalite-paiement
git rebase main # rejoue tes commits par-dessus la dernière version de main
git rebase -i HEAD~3 # réorganiser, fusionner ou renommer les 3 derniers commitsLe rebase produit un historique linéaire et propre. Le mode interactif (-i) permet de « nettoyer » tes commits avant de les partager.
Ne fais jamais de rebase sur des commits déjà poussés et partagés avec d’autres. Le rebase réécrit l’historique : tes collègues se retrouveraient avec des commits qui n’existent plus. Rebase uniquement ton travail local.
Synchroniser avec GitHub
18. git remote : gérer les dépôts distants
git remote -v # liste les dépôts distants
git remote add origin [email protected]:moi/projet.git # ajoute un dépôt distant
git remote set-url origin [email protected]:moi/nouveau-nom.git19. git fetch : récupérer sans fusionner
git fetch origin
git log --oneline main..origin/main # voir les nouveaux commits avant de les intégrerfetch télécharge les nouveautés du dépôt distant sans toucher à ton travail. Tu peux les examiner tranquillement avant de les fusionner.
20. git pull : récupérer et fusionner
git pull # fetch + merge
git pull --rebase # fetch + rebase (historique plus linéaire)Lance git pull avant de commencer à travailler et avant chaque push, pour partir de la version la plus récente.
21. git push : envoyer tes commits
git push
git push -u origin fonctionnalite-paiement # première fois pour une nouvelle branche
git push --force-with-lease # après un rebase de TA branchegit push --force écrase le dépôt distant, y compris les commits que tes collègues auraient poussés entre-temps. --force-with-lease refuse d’écraser si quelqu’un a poussé depuis ta dernière récupération. Et dans tous les cas : jamais de force sur main.
Annuler sans paniquer
C’est la section la plus précieuse de cette antisèche. Choisis la commande selon où se trouve la modification à annuler :
| Situation | Commande |
|---|---|
| Annuler les modifications d’un fichier non préparé | git restore fichier |
| Retirer un fichier de la zone de préparation | git restore --staged fichier |
| Corriger le dernier commit (pas encore poussé) | git commit --amend |
| Défaire des commits locaux (pas encore poussés) | git reset |
| Annuler un commit déjà poussé | git revert |
| Retrouver un commit « perdu » | git reflog |
22. git restore : annuler des modifications de fichiers
git restore index.html # ⚠️ annule tes modifications non préparées (définitif)
git restore --staged index.html # retire de la zone de préparation (garde les modifications)
git restore --source=HEAD~3 config.php # remet le fichier tel qu'il était il y a 3 commits23. git commit –amend : corriger le dernier commit
git add fichier-oublie.js
git commit --amend --no-edit # ajoute le fichier au dernier commit
git commit --amend -m "Nouveau message" # change le message du dernier commitComme le rebase, --amend réécrit l’historique : à n’utiliser que sur un commit pas encore poussé.
24. git reset : revenir en arrière dans l’historique local
git reset --soft HEAD~1 # défait le dernier commit, garde les modifications PRÉPARÉES
git reset HEAD~1 # défait le dernier commit, garde les modifications (non préparées)
git reset --hard HEAD~1 # ⚠️ défait le dernier commit ET supprime les modifications| Option | Commits | Zone de préparation | Tes fichiers |
|---|---|---|---|
--soft | Défaits | Conservée | Conservés |
--mixed (par défaut) | Défaits | Vidée | Conservés |
--hard ⚠️ | Défaits | Vidée | Remis à l’état du commit |
25. git revert : annuler un commit déjà partagé
git revert a1b2c3dgit revert ne supprime rien : il crée un nouveau commit qui fait exactement l’inverse du commit visé. L’historique reste intact, c’est donc la seule façon sûre d’annuler un commit déjà poussé sur une branche partagée.
26. git reflog : le filet de sécurité
git reflog
# a1b2c3d HEAD@{0}: reset: moving to HEAD~1
# 9f8e7d6 HEAD@{1}: commit: Ajoute le paiement par carte ← le commit « perdu »
git reset --hard 9f8e7d6 # le récupérerLe reflog enregistre tous les déplacements de HEAD sur ton poste, même après un reset --hard, un rebase raté ou une branche supprimée. Tant qu’un commit a existé localement (et pendant environ 90 jours par défaut), tu peux le retrouver. Retiens cette commande : elle t’évitera un jour une crise de panique.
Mettre de côté et organiser
27. git stash : mettre son travail de côté
git stash push -m "formulaire en cours" # met de côté les modifications en cours
git stash list # liste ce qui est mis de côté
git stash pop # récupère la dernière mise de côté
git stash push -u # inclut les fichiers non suivisLe cas typique : tu es en plein travail, et on te demande de corriger un bug urgent sur main. git stash, tu changes de branche, tu corriges, tu reviens, git stash pop.
28. git tag : marquer une version
git tag -a v1.2.0 -m "Version 1.2.0 : export PDF"
git push origin v1.2.0 # les tags ne sont pas poussés automatiquement
git tag # liste les tagsLes tags marquent les versions publiées de ton projet. GitHub s’en sert pour créer les Releases.
29. git cherry-pick : récupérer un commit précis
git switch main
git cherry-pick 4d5e6f7 # applique ce commit (venu d'une autre branche) sur mainPratique pour reporter une correction urgente d’une branche à une autre, sans fusionner toute la branche.
Déboguer
30. git bisect : trouver le commit qui a introduit un bug
git bisect start
git bisect bad # la version actuelle contient le bug
git bisect good v1.1.0 # cette ancienne version fonctionnait
# Git se place au milieu : teste, puis indique le résultat
git bisect good # ou : git bisect bad
# … Git répète la recherche dichotomique jusqu'au commit fautif
git bisect reset # revient à l'état initialSur 1 000 commits, git bisect trouve le coupable en une dizaine d’étapes seulement. Bonus : git bisect run npm test automatise la recherche avec tes tests.
git clean -n liste les fichiers non suivis (fichiers générés, tests temporaires) et git clean -fd les supprime. ⚠️ Lance toujours -n d’abord : la suppression est définitive.
Le tableau récapitulatif des 30 commandes Git
| Besoin | Commandes Git |
|---|---|
| Configurer | git config, alias, git help |
| Créer | git init, git clone |
| Enregistrer | git status, git add, git commit, git diff, git rm / git mv |
| Historique | git log, git show, git blame |
| Branches | git branch, git switch, git merge, git rebase |
| Synchroniser | git remote, git fetch, git pull, git push |
| Annuler | git restore, git commit --amend, git reset, git revert, git reflog |
| Organiser | git stash, git tag, git cherry-pick |
| Déboguer | git bisect |
FAQ
Quelle différence entre git fetch et git pull ?
git fetch télécharge les nouveautés du dépôt distant sans modifier ton travail. git pull fait un fetch puis fusionne automatiquement dans ta branche. fetch est plus prudent : tu peux examiner les changements avant de les intégrer.
Quelle différence entre git reset et git revert ?
git reset déplace ta branche en arrière et réécrit l’historique : réservé aux commits locaux non partagés. git revert crée un nouveau commit qui annule les effets d’un ancien : c’est la méthode sûre pour un commit déjà poussé.
git checkout est-il obsolète ?
Non, il fonctionne toujours. Mais depuis Git 2.23, ses deux usages principaux ont été séparés en deux commandes plus claires : git switch pour changer de branche et git restore pour restaurer des fichiers. Elles sont recommandées pour éviter les erreurs.
J’ai fait un git reset –hard par erreur, mon travail est-il perdu ?
Les commits ne sont pas perdus : retrouve-les avec git reflog, puis git reset --hard <identifiant>. En revanche, les modifications qui n’avaient jamais été commitées ni mises de côté (stash) sont malheureusement perdues. D’où l’intérêt de commiter souvent.
Conclusion
Avec ces 30 commandes Git, tu as tout ce qu’il faut pour travailler sereinement : enregistrer proprement ton travail, explorer l’historique, gérer des branches, collaborer via GitHub et, surtout, annuler n’importe quelle erreur sans paniquer grâce à restore, reset, revert et reflog.
Garde cette antisèche dans tes favoris et n’hésite pas à tester les commandes sur un dépôt d’essai : c’est le meilleur moyen de les retenir. Pour approfondir, le livre Pro Git, gratuit et traduit en français, est la référence absolue.
