Git est le système de gestion de versions de référence. Ce guide va à l'essentiel : les commandes du quotidien, la gestion des branches, et surtout les commandes de récupération utiles lorsqu'une mauvaise manipulation survient. Avec des exercices pour bien les assimiler.

Règle d'or à retenir : avec Git, on perd très rarement du travail commité. Presque tout peut être récupéré, à condition de connaître les bonnes commandes.

1. Les commandes de base

git init                      # créer un dépôt dans le dossier courant
git clone <url>               # cloner un dépôt distant

git status                    # voir l'état (fichiers modifiés, indexés…)
git add <fichier>             # indexer un fichier (le préparer au commit)
git add .                     # indexer tout
git commit -m "message"       # enregistrer un instantané
git commit -am "message"      # add + commit des fichiers déjà suivis

git log --oneline --graph     # historique condensé et visuel
git diff                      # changements non indexés
git diff --staged             # changements indexés (prêts à commiter)

Échanger avec le distant :

git pull                      # récupérer + fusionner les changements distants
git push                      # envoyer ses commits
git push -u origin main       # 1re fois : lie la branche locale au distant
git remote -v                 # voir les dépôts distants configurés

2. Les branches

Une branche est une ligne de développement parallèle. On y travaille sans toucher au code stable (main), puis on fusionne.

git branch                    # lister les branches
git branch ma-feature         # créer une branche
git switch ma-feature         # basculer dessus (git moderne)
git switch -c ma-feature      # créer ET basculer en une fois
# (équivalents anciens : git checkout ma-feature / git checkout -b ma-feature)

git merge ma-feature          # fusionner ma-feature dans la branche courante
git branch -d ma-feature      # supprimer une branche fusionnée
git branch -D ma-feature      # forcer la suppression (non fusionnée)

Merge vs rebase :

git merge ma-feature          # crée un commit de fusion (historique fidèle)
git rebase main               # rejoue ses commits par-dessus main (historique linéaire)

💡 Conseil : merge pour conserver l'historique réel, rebase pour un historique propre. Ne jamais rebaser une branche déjà partagée/poussée.

3. Les commandes de récupération (les vraies)

C'est ici que Git montre toute sa valeur : annuler, restaurer, retrouver.

Annuler des changements

git restore <fichier>         # annuler les modifs non indexées d'un fichier
git restore --staged <fichier> # désindexer (sans perdre les modifs)
git restore .                 # tout annuler (modifs non commitées) — prudence

Revenir en arrière

git reset --soft HEAD~1       # annule le dernier commit, GARDE les modifs indexées
git reset HEAD~1              # annule le dernier commit, garde les modifs (non indexées)
git reset --hard HEAD~1       # ⚠️ annule le commit ET les modifs (destructeur)

git revert <hash>             # crée un commit qui ANNULE un commit (sûr, partageable)

reset réécrit l'historique (local), revert ajoute un commit d'annulation (sans réécrire). Sur une branche partagée, toujours préférer revert.

Le filet de sécurité : reflog

git reflog                    # journal de TOUS les déplacements de HEAD
git reset --hard <hash>       # revenir à un état retrouvé dans le reflog

🛟 La commande de récupération décisive. Même après un reset --hard malheureux, le commit perdu reste presque toujours retrouvable via git reflog (Git garde les commits orphelins ~30 jours).

Mettre de côté : stash

git stash                     # ranger ses modifs en cours (revenir à un état propre)
git stash list                # lister les remises
git stash pop                 # récupérer la dernière remise (et la retirer)
git stash apply               # récupérer sans retirer de la liste

Récupérer un commit précis : cherry-pick

git cherry-pick <hash>        # appliquer UN commit précis sur la branche courante

4. Exercices pratiques

Entraînez-vous dans un dépôt jetable (git init dans un dossier de test) :

  1. Premier commit — crée un fichier, add, commit, puis git log --oneline.
  2. Annuler proprement — modifie le fichier, puis annule avec git restore. Vérifie avec git status.
  3. Défaire un commit — fais un commit, puis git reset --soft HEAD~1. Le fichier est-il toujours indexé ?
  4. Branche + merge — git switch -c test, fais un commit, reviens sur main, git merge test.
  5. Le sauvetage — fais git reset --hard HEAD~1 (tu « perds » un commit), puis retrouve-le avec git reflog + git reset --hard <hash>. 🎉
  6. Stash — modifie un fichier sans commiter, git stash, change de branche, reviens, git stash pop.

5. Astuces utiles

git commit --amend            # corriger le dernier commit (message ou contenu)
git log --oneline -5          # les 5 derniers commits
git diff HEAD~1 HEAD          # ce qui a changé au dernier commit
git clean -n                  # PRÉVISUALISER les fichiers non suivis à supprimer
git clean -fd                 # supprimer les fichiers/dossiers non suivis (prudence)
git config --global alias.lg "log --oneline --graph --all"   # un alias pratique
  • Commits petits et fréquents > un gros commit fourre-tout.
  • Messages clairs à l'impératif : « Ajoute la page blog », « Corrige le calcul de TVA ».
  • .gitignore dès le début (jamais de secrets, de node_modules, de dossiers build/).

Le véritable atout de Git ne se limite pas au versionnement : il permet surtout de revenir en arrière avec méthode. Une fois reflog, restore, revert et stash bien maîtrisés, vous pouvez expérimenter plus librement, avec un cadre de récupération fiable.