Git, c'est un outil ultra puissant, mais mal utilisé, ça peut vite devenir le chaos. Après des années d'expérience et pas mal de galères, voici les bonnes pratiques que j'applique pour garder un workflow propre et efficace. 🚀

✍️ 1️⃣ Écrire des Messages de Commit Clairs et Structurés

✅ Format que j'utilise : Conventional Commits

Un commit bien écrit, c'est un commit compréhensible par tout le monde (y compris moi dans 6 mois 😅). Je structure toujours mes messages comme ça :

<type>(<scope>): <message>

Exemples :

feat(auth): ajout de l'authentification JWT
fix(ui): correction de l'alignement des boutons sur mobile
docs(readme): mise à jour du guide d'installation

✅ Liste des Types que j'utilise le plus

Type À quoi ça sert
feat Ajout d'une nouvelle fonctionnalité
fix Correction d'un bug
docs Modification de la documentation
style Changement de mise en forme (pas de code modifié)
refactor Amélioration du code sans ajout de fonctionnalité
test Ajout ou mise à jour des tests
chore Tâches annexes (build, CI/CD, etc.)

Un bon commit, c'est comme une bonne ligne de code : clair et concis. Pas besoin d'un pavé, mais assez d'infos pour comprendre l'intention.

🌿 2️⃣ Une Convention de Nommage pour les Branches

J'aime bien garder une structure simple et efficace pour nommer mes branches :

<type>/<feature-name>

Exemples :

git checkout -b feat/profil-utilisateur
git checkout -b fix/bug-navbar

Les types de branches que j'utilise :

  • main (ou master) : la version stable.
  • develop : la branche d'intégration des nouvelles features.
  • feat/... : branches pour chaque nouvelle fonctionnalité.
  • fix/... : branches pour les corrections de bugs.
  • hotfix/... : correctifs urgents en production.

📜 3️⃣ Squash et Rebase pour un Historique Propre

Je préfère éviter les commits inutiles du genre :

feat(login): ajout de la page de connexion
fix(login): correction d'un bug sur le bouton
style(login): amélioration du design du bouton

Avant de pousser, je fais un squash pour ne garder qu'un commit propre :

git rebase -i HEAD~3  # Combine les 3 derniers commits

👉 Résultat : un historique plus lisible et plus propre.

🔄 4️⃣ Toujours Pull avec Rebase

Par défaut, git pull crée un commit de merge inutile. Plutôt que d'avoir un historique pollué, j'utilise :

git pull --rebase

Et pour que ça soit automatique :

git config --global pull.rebase true

✅ Résultat : Un historique linéaire et clair, sans "merge commits" parasites.

🔍 5️⃣ Vérifier ses Modifications Avant un Commit

Toujours jeter un œil aux fichiers modifiés avant de commit :

git status
git diff

Et quand il y a beaucoup de fichiers, je fais du staging sélectif :

git add -p

Ça permet de commit juste ce qu'il faut, sans envoyer des fichiers en vrac.

📂 6️⃣ Un .gitignore Bien Configuré

Rien de pire qu'un dépôt pollué par des fichiers inutiles. Je configure toujours un bon .gitignore dès le début.

Exemple pour un projet Node.js :

node_modules/
.env
dist/

Ou pour un projet Flutter :

build/
.dart_tool/
.flutter-plugins

🔐 7️⃣ Ne Jamais Stocker de Secrets dans Git

Erreur classique : commit une clé API ou un token. ❌

Toujours stocker les variables sensibles dans un fichier .env et l'ajouter au .gitignore.

Si une clé sensible est commitée par erreur, on peut la supprimer de l'historique avec :

git filter-branch --force --index-filter "git rm --cached --ignore-unmatch .env" --prune-empty --tag-name-filter cat -- --all

Et surtout : changer immédiatement la clé en production.

🛑 8️⃣ Ne Jamais Pousser Directement sur main

Règle d'or : Toujours passer par une Pull Request (PR).

git push origin feat/nouvelle-feature

Puis merger la PR après validation.

Ça évite d'envoyer du code bancal en prod et ça permet une relecture par l'équipe.

⚙️ 9️⃣ Automatiser avec des Outils

Quelques outils qui me facilitent la vie :

  • commitlint → Vérifie que les commits respectent la convention.
  • prettier / eslint → Vérifie la qualité du code avant commit.
  • Git hooks (via Husky) → Automatiser lint/tests avant commit.

🚀 Résumé des Best Practices Git

✅ Écrire des commits clairs (feat, fix, etc.).
✅ Nommer ses branches proprement (feat/login-page).
✅ Utiliser rebase au lieu de merge pour un historique clean.
✅ Vérifier ses fichiers avant de commit (git status, git diff).
✅ Ne jamais stocker de secrets dans Git !
✅ Ne jamais pousser directement sur main, utiliser des PRs.

Avec ces bonnes pratiques, Git devient un allié plutôt qu'un casse-tête ! 🔥🚀