Git Avancé — Commandes, .gitignore & Bonnes Pratiques

Maîtriser les commandes avancées de Git vous permet de corriger des erreurs, explorer l'historique et maintenir un workflow propre en équipe.

Annuler des changements

git revert — Annuler un commit de façon sûre

git revert crée un nouveau commit qui annule les changements d'un commit précédent. C'est la méthode sûre pour annuler en équipe (l'historique est préservé).

# Annuler le dernier commit
git revert HEAD

# Annuler un commit spécifique (par son hash)
git revert a3f2c1d

# Sans ouvrir l'éditeur
git revert HEAD --no-edit

Avant :   A ─── B ─── C  (C est le commit à annuler)
Après :   A ─── B ─── C ─── C'  (C' annule C)

git reset — Remonter dans l'historique

git reset déplace le pointeur HEAD en arrière. Attention : peut modifier l'historique.

# Soft : annule le commit, garde les fichiers en staging
git reset --soft HEAD~1

# Mixed (défaut) : annule le commit, garde les fichiers dans working dir
git reset HEAD~1
git reset HEAD nom-fichier.js   # Désindexer un fichier (unstage)

# Hard : annule le commit ET supprime les modifications (IRRÉVERSIBLE)
git reset --hard HEAD~1

# Revenir à un commit spécifique
git reset --hard a3f2c1d

--hard est dangereux. Ne jamais l'utiliser sur main ou sur des commits déjà poussés.

git clean — Supprimer les fichiers non trackés

# Voir ce qui serait supprimé (simulation)
git clean -n

# Supprimer les fichiers non trackés
git clean -f

# Supprimer fichiers ET dossiers non trackés
git clean -fd

Git Stash — Mettre de côté des modifications

Utile quand vous devez changer de branche mais n'êtes pas prêt à commiter.

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

# Lister les stashes
git stash list

# Réappliquer le dernier stash
git stash pop

# Réappliquer sans supprimer du stash
git stash apply

# Supprimer un stash
git stash drop

Git Rebase — Rejouer des commits

git rebase rejoue les commits d'une branche sur une autre base. Résultat : un historique linéaire sans commit de merge.

# Rebaser la branche feature sur main
git checkout feature/login
git rebase main

# Rebase interactif (réorganiser, fusionner, renommer des commits)
git rebase -i HEAD~3       # Modifier les 3 derniers commits
git rebase -i main         # Modifier tous les commits depuis main

Avant rebase :             Après rebase :
main:    A ─── B           main:    A ─── B
                 \                          \
feature:  C ─── D          feature:  C' ─── D'  (rejoués sur B)

Commandes dans le rebase interactif :

Règle : Ne jamais rebaser des commits déjà poussés sur le remote (shared history).

Git Log avancé

# Un commit par ligne avec hash court
git log --oneline

# Graphe ASCII des branches
git log --oneline --graph --all --decorate

# Afficher les fichiers modifiés par commit
git log --stat

# Afficher les diffs complets de chaque commit
git log -p

# Filtrer par auteur
git log --author="Alice"

# Filtrer par message
git log --grep="fix"

# Commits dans une plage de dates
git log --since="2024-01-01" --until="2024-12-31"

# Commits qui ont touché un fichier
git log -- app.js

# Limiter à N commits
git log -5

Exemple de sortie :

* a3f2c1d (HEAD -> main, origin/main) feat: add payment module
* b12e8f0 fix: correct cart total
| * c891a2e (feature/search) feat: implement search
|/
* d45b7c3 feat: user authentication
* e78f901 initial commit

.gitignore — Exclure des fichiers

Le fichier .gitignore liste les fichiers et dossiers que Git doit ignorer.

# Créer ou éditer .gitignore à la racine du projet
vim .gitignore

Exemples de règles .gitignore

# Dépendances
node_modules/
vendor/
.venv/

# Fichiers de build
dist/
build/
*.class
*.jar

# Fichiers d'environnement (JAMAIS commiter !)
.env
.env.local
.env.production
*.pem
*.key

# Logs
*.log
logs/

# OS et éditeurs
.DS_Store
.idea/
.vscode/
*.swp
Thumbs.db

# Terraform
.terraform/
*.tfstate
*.tfstate.backup

Règle absolue : ne jamais commiter de fichiers .env ou de credentials dans Git. Si un secret est accidentellement commité, changer immédiatement les credentials.

Ignorer un fichier déjà tracké

# 1. Ajouter au .gitignore
echo ".env" >> .gitignore

# 2. Retirer du tracking (sans supprimer le fichier)
git rm --cached .env

# 3. Commiter
git commit -m "chore: remove .env from tracking"

Gestion des remotes

# Voir les remotes configurés
git remote -v

# Ajouter un remote
git remote add origin git@gitlab.com:user/projet.git

# Changer l'URL d'un remote
git remote set-url origin git@github.com:user/projet.git

# Supprimer un remote
git remote remove origin

# Récupérer les infos du remote sans merger
git fetch origin

Bonnes pratiques Git

Messages de commit

✓ feat: add user authentication with JWT
✓ fix: correct calculation of cart total
✓ docs: update README with setup instructions

✗ fix bug
✗ update
✗ WIP
✗ asdfgh

Règles :

• Message concis et descriptif (max 72 caractères)
• Commencer par un verbe à l'infinitif (add, fix, update, remove...)
• Expliquer le pourquoi si nécessaire (corps du message)
• Utiliser les préfixes conventionnels (feat:, fix:, docs:, etc.)

Fréquence des commits

✓ Commits petits et focalisés (1 chose par commit)
✓ Commiter souvent (ne pas accumuler trop de changements)
✓ Commiter seulement du travail cohérent (ne pas mélanger les sujets)
✗ Éviter les gros commits fourre-tout

Workflow en équipe

✓ Pull souvent depuis main pour rester synchronisé
✓ 1 branche par feature ou bugfix
✓ Nommer les branches : feature/xx, bugfix/xx, hotfix/xx
✓ Code review via Merge Request avant de merger dans main
✓ Ne pas push directement sur main
✓ Utiliser .gitignore (ne jamais commiter .env ou secrets)
✗ Ne jamais force-push sur main ou develop
✗ Ne jamais rebaser des commits partagés

Cheatsheet — Référence rapide

Commandes essentielles

Branches

Annuler

Remote

À retenir

• git revert = annuler proprement (crée un nouveau commit) — méthode sûre en équipe
• git reset --hard = dangereux, supprime définitivement les changements
• git stash = mettre de côté temporairement des modifications
• git rebase -i = réécrire l'historique de façon interactive
• .gitignore = liste des fichiers exclus du tracking (.env, node_modules/, dist/)
• Jamais commiter de secrets dans Git (clés API, mots de passe, certificats)
• Messages de commit clairs : préfixe + description concise
• Ne jamais force-push sur main ou sur des branches partagées