Comment utiliser Git comme un pro : 25 commandes, workflows et bonnes pratiques

Les bases Git que tout pro a automatisées

Avant les workflows, configurez votre identité et quelques réglages sensés. À faire une fois :

git config --global user.name "Votre Nom"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
git config --global pull.rebase true
git config --global rerere.enabled true

pull.rebase true signifie que git pull ne crée jamais de commits de fusion inutiles. rerere.enabled permet à Git de mémoriser vos résolutions de conflits et de les rejouer automatiquement. Les pros règlent cela une fois et n'y pensent plus.

Le workflow pro : petites branches, petits commits

Le workflow professionnel est simple à expliquer et difficile à sauter : ne commitez jamais directement sur la branche main.

git checkout -b feature/login-form     # créer une branche et y basculer
git add src/components/LoginForm.vue   # indexer un changement logique
git commit -m "feat: add login form validation"
git push -u origin feature/login-form  # pousser et mémoriser la branche

Trois règles rendent ce workflow puissant :

Un commit = une idée. Si le message du commit a besoin du mot « et », découpez-le.
Comitez souvent, poussez petit. Un commit de 5 lignes est facile à relire et facile à annuler. Un commit de 500 lignes est un mystère pour tout le monde.
Protégez main. Ne poussez jamais directement dessus. Fusionnez uniquement via une pull request, avec une revue.

Écrivez des messages de commit qui veulent dire quelque chose

Les bons messages suivent le format conventionnel : un type, un résumé court, et éventuellement un corps.

git commit -m "fix: handle empty email in contact form"

# avec un corps :
git commit -m "fix: handle empty email in contact form" -m "Le formulaire plantait quand le champ email était vide. Ajout d'une clause de garde avant la validation."

Types courants : feat, fix, refactor, docs, test, chore. Six mois plus tard, un historique propre est une documentation gratuite.

Annuler ses erreurs comme un pro (les commandes qui sauvent)

Tout le monde se trompe. Les pros ne paniquent pas, parce que Git est une machine à remonter le temps. Voici la commande exacte pour chaque situation.

Je n'ai pas encore committé — supprimer le changement

git restore src/App.vue            # annuler les modifications non indexées
git restore --staged src/App.vue   # désindexer un fichier, garder les modifs

J'ai committé mais c'est local — corriger

git commit --amend -m "fix: correct typo in title"   # réécrire le dernier commit

Je veux réécrire plusieurs commits locaux

git rebase -i HEAD~3   # squasher, réordonner ou éditer les 3 derniers commits

Dans l'éditeur, changez pick en squash pour fusionner plusieurs commits en un seul historique propre.

J'ai déjà poussé — annuler sans mentir

Ne réécrivez jamais un historique que vous avez poussé. Créez plutôt un nouveau commit qui annule le mauvais :

git revert <hash-du-commit>   # sûr : ajoute un commit qui annule l'ancien

git revert garde un historique honnête et reste sûr sur les branches partagées. C'est la version pro de « supprimer ».

Je veux mettre de côté mon travail

git stash               # sauvegarder le travail non committé et nettoyer
git stash pop           # le récupérer
git stash list          # lister les sauvegardes
git stash save "wip"    # la nommer

git stash est l'outil parfait quand vous êtes en plein milieu d'une tâche et devez changer de branche.

Les commandes que les pros lancent chaque jour

Ces cinq commandes distinguent silencieusement les professionnels des débutants.

Voir exactement ce qui a changé

git diff                  # changements non indexés
git diff --staged         # changements indexés, prêts à committer

Faites toujours git diff avant de committer. C'est la dernière chance de rattraper une erreur.

Indexer des parties d'un fichier, pas tout le fichier

git add -p src/components/ContactForm.vue   # indexer ligne par ligne

Le mode -p (patch) vous demande hunk par hunk : y pour oui, n pour non. Il garde les modifications sans rapport hors de vos commits.

Suivre l'historique

git log --oneline --graph --decorate   # historique visuel
git blame src/App.vue                  # qui a changé chaque ligne, et quand

git blame ne sert pas à accuser. Il répond à « quand et pourquoi cette ligne a-t-elle été ajoutée ? » et vous fera gagner des heures.

Corriger un bug en le traquant automatiquement

git bisect start
git bisect bad     # marquer le commit actuel comme cassé
git bisect good <commit-ancien>   # marquer un ancien bon commit

Git extrait le commit du milieu. Vous testez, dites good ou bad, et Git divise la recherche en deux jusqu'à trouver le commit exact qui a cassé les choses. Magique, et gratuit.

Amener un commit dans votre branche

git cherry-pick <hash-du-commit>   # copier un commit précis dans votre branche

Parfait pour prendre un correctif de main dans une branche de fonctionnalité sans faire une fusion complète.

La règle d'or : pull avec rebase, push avec force-with-lease

Quand votre branche est en retard sur le dépôt distant, ne créez jamais de commits de fusion en local :

git pull --rebase          # rejouer vos commits par-dessus les changements distants
git push -u origin ma-branche

Et si vous devez vraiment réécrire des commits poussés (ça arrive), n'utilisez jamais un simple git push -f :

git push --force-with-lease

--force-with-lease refuse d'écraser un travail que vous n'avez pas vu. Un simple -f peut détruire les commits d'un collègue. Cet unique drapeau fait la différence entre un pro et un danger.

Votre antisèche Git de pro

Situation	Commande
Voir votre statut	`git status`
Tout indexer	`git add .`
Committer	`git commit -m "..."`
Annuler un fichier non commité	`git restore <fichier>`
Annuler le dernier commit local	`git commit --amend`
Annuler un commit poussé	`git revert <hash>`
Sauvegarder le travail temporairement	`git stash`
Voir l'historique	`git log --oneline --graph`
Qui a changé cette ligne ?	`git blame <fichier>`
Fusionner les 3 derniers commits	`git rebase -i HEAD~3`
Trouver le commit du bug	`git bisect start`
Copier un commit	`git cherry-pick <hash>`
Mettre à jour sa branche en sécurité	`git pull --rebase`
Écraser avec prudence	`git push --force-with-lease`

Astuces Git pour le travail en équipe (là où les pros gagnent vraiment)

Tirez avant de pousser, à chaque fois. git pull --rebase d'abord, puis poussez. Pas de surprises pour l'équipe.
Gardez les pull requests petites. Une PR de 200 lignes est relue. Une PR de 2 000 lignes est ignorée. Petites PR = moins de bugs.
Ne committez jamais de secrets. Ajoutez .env, les clés et les dossiers de build à .gitignore dès le premier jour.

# .gitignore
node_modules/
dist/
.env
.env.*
*.log

Utilisez un .gitignore pour chaque langage. Les modèles de gitignore.io sont un excellent point de départ.
Écrivez un README avec le workflow. « Branch sur main, PR vers main, jamais de push direct » épargne une heure à chaque nouveau venu.

L'état d'esprit pro

Voici le basculement qui fait un pro : Git est un filet de sécurité, pas une menace. Les débutants craignent Git parce qu'ils pensent pouvoir casser quelque chose. Les pros savent que Git peut presque toujours tout annuler, à condition de committer tôt et souvent.

La règle qui évite 90 % des catastrophes Git : commitez petit, commitez souvent, et ne réécrivez jamais un historique que quelqu'un d'autre a déjà récupéré. Suivez ces trois règles avec les commandes ci-dessus, et vous travaillez déjà comme un pro.

Que voir ensuite

Maîtrisez d'abord les bases ici. Puis explorez :

Les alias Git — raccourcissez git checkout en git co, git status en git st, et plus :

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.lg "log --oneline --graph --decorate"

Les hooks — exécutez des vérifications automatiques avant chaque commit.
Les workflows de rebase — gardez un historique parfaitement linéaire pour les petites équipes.

Git fait peur vu de l'extérieur. De l'intérieur, ce sont juste des commandes qui protègent votre travail et celui de votre équipe. Apprenez-les une fois, utilisez-les chaque jour, et laissez la machine à remonter le temps faire le reste.