> Le mémo des commandes Git essentielles : clone, add, commit, branch, merge, rebase, stash, reset et log, commentés avec des exemples concrets.

*Source : https://coder-studio.com/outils/commandes-git-essentielles/*

---

[// Outils du dev](https://coder-studio.com/outils/)

# Git : les commandes essentielles (mémo)

Par **Kévin Papot** · publié le 15 décembre 2025

Git est l’outil que tout développeur finit par utiliser tous les jours — et dont on oublie régulièrement la moitié des commandes. Ce mémo rassemble les commandes essentielles, classées par tâche et commentées. Gardez-le sous la main : l’objectif n’est pas de tout retenir, mais de retrouver la bonne commande au bon moment.

## Démarrer un dépôt

Deux points de départ possibles : créer un dépôt local, ou récupérer un dépôt existant.

```
# Initialiser un nouveau dépôt dans le dossier courant
git init

# Cloner un dépôt distant en local
git clone https://github.com/utilisateur/projet.git

# Cloner dans un dossier au nom précis
git clone https://github.com/utilisateur/projet.git mon-dossier
```

Pensez aussi à configurer votre identité une fois pour toutes, sinon vos commits n’auront pas d’auteur cohérent :

```
git config --global user.name "Votre Nom"
git config --global user.email "vous@exemple.com"
```

## Enregistrer ses modifications : add et commit

Git travaille en deux temps : on **indexe** les changements (_staging_), puis on les **valide** dans un commit.

```
# Voir l'état des fichiers (modifiés, indexés, non suivis)
git status

# Indexer un fichier précis
git add fichier.js

# Indexer tout ce qui a changé
git add .

# Valider les changements indexés avec un message
git commit -m "Ajoute la validation du formulaire"

# Indexer et valider les fichiers suivis en une commande
git commit -am "Corrige un bug d'affichage"
```

Un bon message de commit décrit **ce que fait** le changement, pas comment. Court, à l’impératif, il vous remerciera dans six mois.

## Voir l’historique : log et diff

```
# Historique complet des commits
git log

# Historique condensé, une ligne par commit
git log --oneline

# Historique graphique des branches
git log --oneline --graph --all

# Voir les modifications non encore indexées
git diff

# Voir ce qui est indexé, prêt à être validé
git diff --staged
```

## Les branches : branch, checkout, switch

Les branches permettent de développer une fonctionnalité isolément sans toucher au code principal.

```
# Lister les branches locales
git branch

# Créer une branche
git branch nouvelle-fonctionnalite

# Basculer sur une branche
git switch nouvelle-fonctionnalite

# Créer une branche et y basculer d'un coup
git switch -c nouvelle-fonctionnalite

# (syntaxe classique équivalente)
git checkout -b nouvelle-fonctionnalite

# Supprimer une branche fusionnée
git branch -d ancienne-branche
```

## Fusionner le travail : merge et rebase

Deux façons d’intégrer une branche dans une autre. **Merge** conserve l’historique tel quel en créant un commit de fusion ; **rebase** rejoue vos commits par-dessus la branche cible pour un historique linéaire.

```
# Se placer sur la branche de destination
git switch main

# Fusionner une branche dedans
git merge nouvelle-fonctionnalite

# Rebaser la branche courante sur main
git switch nouvelle-fonctionnalite
git rebase main
```

Règle de prudence : **ne rebasez jamais une branche déjà partagée** avec d’autres, car vous réécririez un historique sur lequel ils travaillent. Le rebase est idéal pour nettoyer votre travail local avant de le pousser.

## Mettre de côté : stash

Vous devez changer de branche mais votre travail n’est pas prêt à être validé ? Le _stash_ range vos modifications temporairement.

```
# Mettre de côté les modifications en cours
git stash

# Lister les remises de côté
git stash list

# Récupérer la dernière remise et la retirer de la pile
git stash pop

# Récupérer sans retirer de la pile
git stash apply
```

## Annuler : reset, revert et restore

Faire marche arrière proprement, c’est tout un art. Distinguez bien ces commandes :

```
# Désindexer un fichier (garde les modifications)
git restore --staged fichier.js

# Annuler les modifications d'un fichier non indexé (destructif)
git restore fichier.js

# Revenir avant le dernier commit, en gardant les changements indexés
git reset --soft HEAD~1

# Revenir avant le dernier commit, en gardant les changements non indexés
git reset --mixed HEAD~1

# Revenir avant le dernier commit et TOUT supprimer (destructif)
git reset --hard HEAD~1

# Créer un nouveau commit qui annule un commit précédent (sûr, partageable)
git revert <hash-du-commit>
```

`reset --hard` détruit du travail : utilisez-le en connaissance de cause. Sur une branche partagée, préférez `revert`, qui annule proprement sans réécrire l’historique.

## Travailler avec le dépôt distant

```
# Récupérer les changements distants sans les fusionner
git fetch

# Récupérer et fusionner les changements distants
git pull

# Envoyer vos commits vers le dépôt distant
git push

# Pousser une nouvelle branche et la lier au distant
git push -u origin nouvelle-fonctionnalite
```

## Le réflexe à garder

La plupart des situations tiennent en une boucle simple : `status` pour voir où vous en êtes, `add` puis `commit` pour enregistrer, `push` pour partager. Le reste — branches, rebase, stash — vient enrichir ce socle quand le projet grandit. Gardez ce mémo ouvert le temps que les commandes deviennent des automatismes.

## À lire ensuite

-   [VS Code : les extensions indispensables](https://coder-studio.com/outils/extensions-vscode-indispensables/)
-   [Les meilleurs IDE pour développeurs en 2026](https://coder-studio.com/outils/meilleurs-ide-2026/)
-   [Débuter sous Linux quand on est développeur](https://coder-studio.com/tutoriels/debuter-linux-developpeur/)