Git est un système de versionnement : cela signifie qu’il enregistre l’évolution des fichiers au fil du temps, permettant de retrouver n’importe quelle version précédente, de collaborer efficacement, et de gérer différentes versions d’un projet en parallèle. Il permet de travailler à plusieurs, de tester sans peur, et surtout de revenir en arrière si besoin.

Bonnes pratiques Git

  • Un commit = une intention
  • Messages clairs : fix(login): handle null token
  • Branches nommées : feature/, bugfix/, hotfix/
  • Pas de travail direct sur main
    Il faut créer une branche, faire le développement, et faire pull request qui sera fusionnée (merge) dans la branche main.
  • Pull régulier
  • Rebase avant merge si possible

Commandes de base et fréquentes

git init
git clone <url>
git status
git add .
git commit -m "message"
git push
git pull
git branch
git checkout -b feature/login
git switch main
git stash
git log --oneline

Git stash

Quand vous travaillez sur plusieurs projets, vous pouvez être amener à mettre en pause votre travail pour corriger un bug ou autre. Donc git stash va permettre de sauvegarder le travail en cours.

Sauvegarder le travail en cours

git stash

Voir la liste des sauvegardes

git stash list

Ceci affichera quelquechose comme

stash@{0}: WIP on main: <hash> comment A
stash@{1}: WIP on main: <hash> comment B
...
stash@{n}: WIP on main: <hash> comment N

Voir le contenu d’une sauvagarde

git stash show -p stash@{0}

Applique une sauvegarde mais la conserve dans la pile

git stash apply stash@{0}

Applique la dernière sauvegarde « stash@0 » et la supprime de la pile

git stash pop

Git log

Cette commande permet de lire l’historique.

Historique complet

git log

Historique condensé

git log --oneline

Graphe de l’historique

git log --graph --all --decorate --oneline

git rebase main vs git merge main —no-commit

Ces deux commandes permettent d’intégrer les changements de la branche main dans une branche de travail (par exemple feature) mais de façons différentes, avec des impacts distincts sur l’historique du projet.

git rebase main

gitGraph commit id: "A" commit id: "B" branch feature checkout feature commit id: "C" commit id: "D" checkout main commit id: "E" checkout feature merge main id: "Rebase" commit id: "C'" commit id: "D'" checkout main merge feature id: "Fast-forward"

git rebase main permet de rejouer les commits de ta branche actuelle (ex: feature) au-dessus des derniers commits de main. Cela crée un historique linéaire, comme vous partiez de main dès le départ.

C’est idéal pour éviter les commits de merge inutiles et rendre l’historique plus clair.

git checkout feature
git rebase main
  • Rejoue les commits de feature sur main
  • Historique linéaire, sans commit de merge

git merge main —no-commit

git merge main --no-commit est utile lorsque que vous voulez fusionner les changements de main dans ta branche sans valider immédiatement le commit de merge. Cela vous permet de :

  • Voir les modifications introduites par la fusion
  • Résoudre des conflits ou ajuster du code avant de valider

C’est donc une fusion contrôlée, utile notamment avant une revue de code ou pour des cas sensibles.

git checkout feature
git merge main --no-commit
  • Fusionne les changements sans valider automatiquement
  • Vous pouvez inspecter/modifier avant de faire le commit final

Merge classique VS squash

Merge classique

gitGraph commit id: "A" commit id: "B" branch feature checkout feature commit id: "C" commit id: "D" checkout main commit id: "E" merge feature id: "Merge" commit id: "F" 
git merge feature
  • Conserve tous les commits

Merge squash

gitGraph commit id: "A" commit id: "B" branch feature checkout feature commit id: "C" commit id: "D" commit id: "E" checkout main merge feature id: "Squash" type: HIGHLIGHT commit id: "F" 
git merge --squash feature
git commit -m "feat: ajout fonctionnalité"
  • Regroupe tous les commits en un seul

Cherry-pick : sélectif et précis

La commande git cherry-pick permet de prendre un ou plusieurs commits spécifiques d’une branche et de les appliquer sur une autre branche comme s’ils avaient été écrits là. C’est très utile quand vous voulez récupérer un correctif ou une fonctionnalité sans fusionner toute une branche.

gitGraph commit id: "A" branch feature checkout feature commit id: "B" commit id: "C" type: HIGHLIGHT commit id: "D" checkout main commit id: "E" commit id: "Cherry-pick C" type: HIGHLIGHT 
git cherry-pick <commit_sha>

Par exemple :

git checkout main
git cherry-pick abc1234

Cela va rejouer le commit abc1234 depuis une autre branche (par exemple feature/xyz) dans main.

Vous pouvez aussi cherry-pick une série de commits :

git cherry-pick abc1234..def5678

⚠️ Attention : si le commit a déjà été fusionné par une autre voie, des doublons ou conflits sont possibles.

Git diff

git diff                       # Fichiers modifiés non staged
git diff --staged             # Staged mais pas commit
git diff main..feature        # Entre branches
git diff <commit1> <commit2> # Entre commits
git diff v1.0.0 HEAD          # Avec tag
git checkout HEAD^     # Commit précédent
git checkout HEAD~2    # Deux commits avant
git show HEAD~3        # Voir commit

Récupérer un commit perdu

git reflog

Montre tous les changements récents, même les commits « supprimés ».

git checkout <sha>        # Revenir sur un commit

Git bisect : trouver l’origine d’un bug

git bisect est une commande puissante pour localiser rapidement le commit qui a introduit un bug. Elle utilise une recherche binaire dans l’historique.

Principe

Il faut indiquer à Git un commit « bon » et un commit « mauvais », celui où le bug a été constaté. Ensuite, Git teste les commits intermédiaires jusqu’à isoler celui qui pose problème.

Exemple :

git bisect start
git bisect bad            # Le commit actuel contient le bug
git bisect good abc1234   # Ce commit fonctionnait

Git va maintenant se placer sur un commit intermédiaire. Il faut tester le code, puis il faut lui indiquer :

git bisect good           # ou
git bisect bad

Git continue jusqu’à trouver le commit coupable. Pour terminer la session :

git bisect reset

C’est idéal pour les projets où le bug est apparu progressivement et l’historique est long.

Résolution des conflits Git

Les conflits surviennent lorsque Git ne peut pas fusionner automatiquement des modifications car elles affectent les mêmes portions de code. Voici comment les gérer efficacement :

Quand apparaissent les conflits?

Les conflits se produisent généralement lors d’opérations comme :

  • git merge
  • git rebase
  • git cherry-pick
  • git pull (qui inclut un merge)
  • git stash apply/pop

Comprendre les marqueurs de conflit

Quand un conflit se produit, Git modifie les fichiers concernés en ajoutant des marqueurs spéciaux :

<<<<<<< HEAD
Code de votre branche actuelle
=======
Code de la branche que vous essayez d'intégrer
>>>>>>> feature/nom-branche

Processus de résolution

  1. Identifier les fichiers en conflit :

    git status

    Les fichiers marqués “both modified” contiennent des conflits.

  2. Ouvrir et éditer chaque fichier en conflit :

    • Supprimer les marqueurs (<<<<<<<, =======, >>>>>>>)
    • Choisir quelle version conserver, ou créer une fusion manuelle des deux versions

  3. Marquer comme résolu :

    git add <fichier-résolu>

  4. Finaliser l’opération en cours :

    • Pour un merge : git commit
    • Pour un rebase : git rebase --continue
    • Pour un cherry-pick : git cherry-pick --continue

Outils de résolution

git mergetool

Lance un outil visuel de résolution configuré dans Git (comme vimdiff, meld, kdiff3, etc.)

Prévention des conflits

  • Pull régulièrement pour rester synchronisé
  • Diviser le travail en petites unités logiques
  • Communiquer avec l’équipe sur les zones de code modifiées
  • Utiliser git rebase avant de pousser une branche destinée à être fusionnée

Abandonner en cas de difficulté

Si la résolution devient trop complexe :

git merge --abort      # Annuler un merge
git rebase --abort     # Annuler un rebase
git cherry-pick --abort # Annuler un cherry-pick

Conclusion

Git, c’est bien plus que commit/push. Maîtriser des commandes comme rebase, stash, log, reflog vous permettra de garder un historique propre, de corriger sans stress et de travailler efficacement, même à plusieurs. Adoptez cet outil pas à pas et vous gagnerez en productivité et en confiance.