---
title: Git : les commandes essentielles, branches et récupération
source: https://synapx.fr/blog/git-commandes-essentielles/
date: 2026-06-26
category: Développement
site: SynapxLab
---

# Git : les commandes essentielles, branches et récupération

**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

```bash
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 :**

```bash
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.

```bash
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 :**

```bash
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

```bash
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

```bash
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`

```bash
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`

```bash
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`

```bash
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

```bash
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.