Parcourir les aide-mémoire · Git
Branches et fusions
Créez, mettez à jour, comparez, fusionnez et nettoyez vos branches Git en toute sécurité, en préservant l’historique partagé et en évitant toute divergence accidentelle ou résolution de conflits destructrice.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Démarrer une branche de fonctionnalité à partir d’un main à jour
- 2. Créer une branche à partir d’une base distante précise
- 3. Afficher la branche courante
- 4. Lister les branches
- 5. Changer de branche en toute sécurité
- 6. Renommer la branche courante
- 7. Comparer les commits de la branche de fonctionnalité avec main
- 8. Voir les commits de main que votre branche n’a pas
- 9. Comparer les modifications de code avec main
- 10. Afficher uniquement les fichiers modifiés
- 11. Lancer git fetch avant de choisir comment mettre à jour
- 12. Fusionner le dernier main dans la branche de fonctionnalité
- 13. Faire un rebase de la branche de fonctionnalité sur le dernier main
- 14. Comprendre merge ou rebase
- 15. Fusionner une autre branche dans la branche courante
- 16. Fusionner en fast-forward lorsque c’est possible
- 17. Forcer volontairement un commit de merge
- 18. Évaluer à l’avance si un merge s’annonce simple
- 19. Annuler un merge en cours
- 20. Détecter un merge actif
- 21. Résoudre les conflits de fusion de manière délibérée
- 22. Lister les fichiers en conflit
- 23. Inspecter les blocs en conflit
- 24. Comprendre ours et theirs pendant un merge
- 25. Indexer les fichiers résolus
- 26. Poursuivre le merge après les conflits
- 27. Fusionner une branche après sa revue
- 28. Regrouper le travail de la fonctionnalité en un seul commit local
- 29. Comprendre le compromis du squash merge
- 30. Faire un push d’une nouvelle branche de fonctionnalité
- 31. Faire un push après avoir fusionné main dans une branche de fonctionnalité
- 32. Faire un push après un rebase d’une branche de fonctionnalité distante
- 33. Éviter le rebase des branches d’intégration partagées
- 34. Supprimer en toute sécurité une branche locale fusionnée
- 35. Vérifier les commits non fusionnés avant la suppression
- 36. Forcer la suppression d’une branche locale uniquement si nécessaire
- 37. Supprimer une branche distante
- 38. Élaguer les branches de suivi distant obsolètes
- 39. Trouver les branches locales déjà fusionnées dans main
- 40. Trouver les branches locales non fusionnées dans main
- 41. Comprendre les branches de suivi distant
- 42. Définir l’upstream d’une branche
- 43. Inspecter l’état d’avance/de retard
- 44. Trouver la base de fusion
- 45. Afficher le graphe des branches
- 46. Comparer directement les extrémités de deux branches
- 47. Ne pas fusionner accidentellement un main obsolète
- 48. Créer une branche de sauvegarde avant des modifications d’historique complexes
- 49. Utiliser le reflog si un déplacement de branche tourne mal
- 50. Garder des branches de fonctionnalité ciblées
- Interpréter le résultat
- Points à vérifier
- La branche de fonctionnalité contient des commits inattendus
- Le merge crée de nombreux conflits
- Le merge indique « Already up to date »
- La branche distante a changé après votre rebase
- La suppression de la branche est refusée
- Le même conflit réapparaît sans cesse
- Notes de production
- La politique de branches doit correspondre à la collaboration de l’équipe
- Les branches partagées doivent éviter la réécriture de l’historique
- Des branches de courte durée réduisent le coût des conflits
- La résolution des conflits de fusion est une revue de code
- Le CI/CD s’exécute généralement sur l’état de la branche, pas sur l’intention
- Les branches de suivi distant sont des instantanés
- Erreurs fréquentes
- 1. Créer une branche de fonctionnalité à partir d’un main obsolète
- 2. Fusionner en étant sur la mauvaise branche
- 3. Faire un rebase d’une branche que vos coéquipiers utilisent déjà
- 4. Faire un force push après un merge normal
- 5. Choisir --ours ou --theirs à l’aveugle
- 6. Supprimer une branche avec -D sans vérifier ses commits propres
- 7. Considérer le squash merge comme identique à un merge normal
- 8. Comparer les extrémités des branches alors que vous voulez seulement les modifications de la fonctionnalité
- 9. Supposer que origin/main est à jour sans lancer git fetch
- 10. Garder des branches de fonctionnalité ouvertes trop longtemps
- Étape suivante
- Pour aller plus loin
Problème
Vous devez travailler sur des modifications en parallèle sans casser la branche partagée.
Les workflows d’ingénierie typiques consistent à :
- créer une branche de fonctionnalité à partir de la bonne base
- maintenir la branche de fonctionnalité à jour
- comparer la branche avec
main - fusionner les modifications en toute sécurité
- résoudre les conflits de manière délibérée
- éviter les commits de merge accidentels
- nettoyer les branches locales et distantes
- comprendre quand un merge est plus sûr qu’un rebase
L’objectif est de garder un historique de branches compréhensible et un travail partagé en sécurité.
Réponse rapide
Pour une branche de fonctionnalité classique :
git switch main
git pull --ff-only
git switch -c feature/report-engine
Travaillez et faites un commit :
git add -p
git commit -m "Add report engine endpoint"
Avant de fusionner :
git fetch origin
git diff origin/main...HEAD
git log --oneline origin/main..HEAD
Mettez à jour la branche de fonctionnalité selon la politique privilégiée par votre équipe :
git merge origin/main
ou :
git rebase origin/main
Puis faites un push :
git push -u origin feature/report-engine
Pour un historique de branche partagé, un merge ou un revert est généralement plus sûr que la réécriture de commits que vos coéquipiers utilisent peut-être déjà.
Code / commandes
1. Démarrer une branche de fonctionnalité à partir d’un main à jour
git switch main
git pull --ff-only
git switch -c feature/report-engine
Cela évite de créer la branche à partir d’un main local obsolète.
Utilisez --ff-only pour éviter de créer un commit de merge inattendu lors de la mise à jour du main local.
2. Créer une branche à partir d’une base distante précise
git fetch origin
git switch -c feature/report-engine origin/main
Utilisez cette méthode lorsque vous voulez que la branche parte directement du dernier main de suivi distant (remote-tracking).
3. Afficher la branche courante
git branch --show-current
À utiliser avant un commit ou un merge en cas de doute sur la branche où vous vous trouvez.
4. Lister les branches
Locales :
git branch
Locales + de suivi distant :
git branch -a
Avec le suivi de l’upstream :
git branch -vv
Utilisez -vv pour voir si la branche est en avance ou en retard sur son upstream.
5. Changer de branche en toute sécurité
git switch feature/report-engine
Git peut refuser si des modifications non commitées risquent d’être écrasées.
Ne forcez pas le changement de branche simplement pour « passer » l’avertissement.
Faites un commit, un stash ou réglez l’état de l’arbre de travail de manière intentionnelle.
6. Renommer la branche courante
git branch -m feature/new-name
Si l’ancienne branche a déjà fait l’objet d’un push, la branche distante n’est pas renommée automatiquement.
En général, vous ferez un push du nouveau nom et supprimerez l’ancienne branche distante séparément.
7. Comparer les commits de la branche de fonctionnalité avec main
git log --oneline origin/main..HEAD
Cette commande affiche les commits que votre branche courante possède et que origin/main n’a pas.
À utiliser avant d’ouvrir ou de mettre à jour une pull request.
8. Voir les commits de main que votre branche n’a pas
git log --oneline HEAD..origin/main
Si cette commande renvoie des commits, votre branche est en retard sur origin/main.
9. Comparer les modifications de code avec main
git diff origin/main...HEAD
La syntaxe à trois points compare votre branche avec la base de fusion (merge base).
Cela représente généralement l’ensemble des modifications introduites par la branche de fonctionnalité.
10. Afficher uniquement les fichiers modifiés
git diff --name-status origin/main...HEAD
Utile pour vérifier rapidement le périmètre.
Exemple :
M src/api.py
A src/report_engine.py
D src/legacy_report.py
11. Lancer git fetch avant de choisir comment mettre à jour
git fetch origin
Cette commande met à jour les références de suivi distant sans modifier votre arbre de travail.
Inspectez ensuite :
git log --oneline --graph --decorate --all -20
Ne faites pas de merge ni de rebase sur un origin/main périmé.
12. Fusionner le dernier main dans la branche de fonctionnalité
git merge origin/main
Utilisez cette approche lorsque :
- la préservation de l’historique est privilégiée
- la branche est déjà partagée
- la réécriture des commits serait perturbatrice
Cela peut créer un commit de merge si les historiques ont divergé.
13. Faire un rebase de la branche de fonctionnalité sur le dernier main
git rebase origin/main
À utiliser lorsque :
- la branche est principalement la vôtre
- le workflow de l’équipe privilégie un historique linéaire
- la réécriture des commits de la branche de fonctionnalité est acceptable
Évitez de faire un rebase à la légère sur des commits dont vos coéquipiers dépendent déjà.
14. Comprendre merge ou rebase
Conceptuellement :
MERGE
A---B---C main
\ \
D---E---M feature
par rapport à :
REBASE
A---B---C main
\
D'---E' feature
Le rebase crée de nouveaux identifiants de commit pour les commits rejoués.
Le merge préserve les commits d’origine et ajoute un historique de fusion si nécessaire.
15. Fusionner une autre branche dans la branche courante
git merge feature/other-work
Vérifiez toujours d’abord la branche courante :
git branch --show-current
Git fusionne dans la branche sur laquelle vous vous trouvez.
16. Fusionner en fast-forward lorsque c’est possible
Si la branche courante n’a aucun commit qui lui est propre :
git merge --ff-only feature/report-engine
Cette commande fait avancer le pointeur de branche sans créer de commit de merge.
Si le fast-forward est impossible, Git s’arrête au lieu d’appliquer une autre stratégie de merge.
17. Forcer volontairement un commit de merge
git merge --no-ff feature/report-engine
À utiliser uniquement si le workflow du dépôt préserve intentionnellement les commits de merge des branches de fonctionnalité.
N’ajoutez pas de commits de merge par défaut lorsque l’équipe privilégie un historique linéaire.
18. Évaluer à l’avance si un merge s’annonce simple
git log --oneline --graph --decorate --all -30
et :
git diff HEAD...feature/report-engine
Git ne propose pas de simulation (dry-run) parfaite pour tous les résultats de merge, mais inspecter d’abord la divergence réduit les surprises.
19. Annuler un merge en cours
git merge --abort
À utiliser lorsque :
- vous êtes parti de la mauvaise branche
- les conflits sont plus étendus que prévu
- vous devez revenir à l’état antérieur au merge
Ne réinitialisez pas manuellement des fichiers pendant qu’un merge est actif, sauf si vous en comprenez les conséquences.
20. Détecter un merge actif
git status
Git indiquera qu’il existe des conflits ou qu’un merge est en cours.
git status doit être la première commande après un merge interrompu.
21. Résoudre les conflits de fusion de manière délibérée
Un fichier en conflit peut contenir :
<<<<<<< HEAD
version de la branche courante
=======
version de la branche entrante
>>>>>>> feature/other-work
Modifiez le fichier pour obtenir le résultat final voulu.
Ensuite :
git add path/to/file
Une fois tous les conflits résolus :
git commit
ou laissez Git terminer le merge selon l’état courant.
Ne laissez pas de marqueurs de conflit dans le code commité.
22. Lister les fichiers en conflit
git diff --name-only --diff-filter=U
À utiliser lors de la résolution d’un conflit volumineux.
23. Inspecter les blocs en conflit
git diff
Pendant un conflit de fusion, Git affiche les sections non résolues.
À utiliser avant de choisir l’un ou l’autre côté.
24. Comprendre ours et theirs pendant un merge
Pendant un merge :
ours
→ branche courante
theirs
→ branche en cours de fusion
Exemple :
git checkout --ours path/to/file
ou la forme moderne avec restore :
git restore --ours path/to/file
N’utilisez pas --ours / --theirs à l’aveugle.
Une résolution correcte combine souvent les deux versions.
25. Indexer les fichiers résolus
git add src/app.py
git add README.md
Puis vérifiez :
git status
Le merge n’est terminé que lorsque chaque conflit est résolu et indexé (ajouté à la zone de préparation, ou staging area).
26. Poursuivre le merge après les conflits
En général :
git commit
Git proposera un message de commit de merge.
Relisez-le avant de l’enregistrer.
27. Fusionner une branche après sa revue
Flux local typique :
git switch main
git pull --ff-only
git merge --ff-only feature/report-engine
Cela ne fonctionne que si la branche de fonctionnalité est déjà basée directement sur le dernier main.
Sinon, la politique de merge du dépôt peut exiger :
- un commit de merge
- un squash merge
- un rebase merge
Cela est souvent géré par la plateforme d’hébergement Git.
28. Regrouper le travail de la fonctionnalité en un seul commit local
git merge --squash feature/report-engine
git commit -m "Add report engine"
Cette commande applique les modifications de la fonctionnalité à l’arbre de travail et à l’index sans créer de relation de merge avec la branche de fonctionnalité.
À utiliser uniquement lorsque l’historique en squash est la politique voulue.
29. Comprendre le compromis du squash merge
Le squash produit un seul nouveau commit contenant le diff final.
Avantages :
- historique de main compact
- revert facile au niveau de la fonctionnalité
Compromis :
- les commits individuels de la fonctionnalité ne sont pas conservés sur
main - Git n’enregistre pas de relation de merge normale avec la branche de fonctionnalité
Cela affecte les comparaisons de branches ultérieures et le comportement des merges répétés.
30. Faire un push d’une nouvelle branche de fonctionnalité
git push -u origin feature/report-engine
Une fois l’upstream défini :
git push
31. Faire un push après avoir fusionné main dans une branche de fonctionnalité
git push
Un merge normal ne réécrit pas les commits existants de la fonctionnalité ; un push classique suffit donc généralement.
32. Faire un push après un rebase d’une branche de fonctionnalité distante
Si vous avez fait un rebase de commits déjà poussés :
git push --force-with-lease
Préférez cette commande à :
git push --force
À utiliser uniquement lorsque la réécriture de cette branche de fonctionnalité est acceptable.
33. Éviter le rebase des branches d’intégration partagées
Ne faites pas de rebase à la légère sur :
main
develop
release
branches d’équipe partagées
car les identifiants de commit changent et vos collaborateurs ont peut-être déjà basé leur travail dessus.
34. Supprimer en toute sécurité une branche locale fusionnée
git branch -d feature/report-engine
-d refuse de supprimer une branche que Git ne considère pas comme entièrement fusionnée.
C’est plus sûr que -D.
35. Vérifier les commits non fusionnés avant la suppression
git log main..feature/report-engine
Si cette commande affiche des commits, vérifiez qu’ils peuvent intentionnellement être abandonnés avant de supprimer la branche.
36. Forcer la suppression d’une branche locale uniquement si nécessaire
git branch -D feature/report-engine
Cette commande peut supprimer le nom de la branche même s’il reste des commits qui lui sont propres.
À utiliser uniquement après avoir confirmé que ces commits sont conservés ailleurs ou ne sont plus nécessaires.
37. Supprimer une branche distante
git push origin --delete feature/report-engine
La suppression d’une branche distante affecte les autres collaborateurs.
Faites-la après le merge ou la clôture, conformément au workflow de l’équipe.
38. Élaguer les branches de suivi distant obsolètes
git fetch --prune
Cette commande supprime les références obsolètes telles que :
origin/feature/old-branch
lorsque la branche distante correspondante n’existe plus.
Elle ne supprime pas les branches locales.
39. Trouver les branches locales déjà fusionnées dans main
git branch --merged main
Utilisez-la comme aide au nettoyage.
Vérifiez tout de même les branches importantes avant de les supprimer.
40. Trouver les branches locales non fusionnées dans main
git branch --no-merged main
Cela permet d’identifier le travail qui pourrait encore être unique.
41. Comprendre les branches de suivi distant
origin/main n’est pas la branche distante elle-même.
C’est la dernière vue récupérée par git fetch de la branche distante dans votre dépôt local.
Mettez-la à jour avec :
git fetch origin
Ne supposez pas que origin/main est à jour si vous n’avez pas lancé git fetch récemment.
42. Définir l’upstream d’une branche
git branch \
--set-upstream-to=origin/feature/report-engine \
feature/report-engine
En général, git push -u s’en charge lors du premier push d’une branche.
43. Inspecter l’état d’avance/de retard
git status
ou :
git branch -vv
Pour obtenir le nombre exact de commits :
git rev-list \
--left-right \
--count \
origin/main...HEAD
Exemple :
3 2
signifie :
3 commits propres à origin/main
2 commits propres à HEAD
44. Trouver la base de fusion
git merge-base origin/main HEAD
Cette commande affiche l’ancêtre commun utilisé pour les comparaisons à trois points.
Utile pour comprendre la divergence entre branches.
45. Afficher le graphe des branches
git log \
--oneline \
--graph \
--decorate \
--all \
-30
À utiliser lorsque la relation entre les branches prête à confusion.
46. Comparer directement les extrémités de deux branches
git diff main feature/report-engine
Cette commande compare les instantanés aux extrémités des deux branches.
Elle diffère de :
git diff main...feature/report-engine
qui compare à partir de la base de fusion et convient généralement mieux à la revue d’une branche de fonctionnalité.
47. Ne pas fusionner accidentellement un main obsolète
Avant de fusionner une fonctionnalité terminée dans le main local :
git switch main
git fetch origin
git pull --ff-only
Effectuez ensuite le merge prévu.
Cela évite d’intégrer dans une base locale obsolète.
48. Créer une branche de sauvegarde avant des modifications d’historique complexes
git branch backup-before-integration
Faites-le avant :
- un rebase risqué
- une résolution de conflits complexe
- une chirurgie de branche locale
La création d’une branche ne coûte presque rien et fournit un point de récupération.
49. Utiliser le reflog si un déplacement de branche tourne mal
git reflog
Retrouvez le commit précédent :
git show <commit>
Créez une branche de récupération :
git switch -c recovery <commit>
Le reflog est particulièrement utile après un reset ou un rebase accidentel.
50. Garder des branches de fonctionnalité ciblées
Privilégiez :
feature/report-engine
pour contenir un ensemble de travail cohérent.
Évitez de mélanger :
- des refactorisations sans rapport
- des mises à niveau de dépendances
- du reformatage sur l’ensemble du dépôt
- des travaux sur des fonctionnalités distinctes
Des branches ciblées produisent des merges plus simples et moins de conflits.
Interpréter le résultat
| Opération | Effet sur l’historique | Usage typique |
|---|---|---|
git switch -c |
Crée un nouveau pointeur de branche | Démarrer un travail isolé |
git fetch |
Met à jour les références de suivi distant | Inspecter l’état actuel du dépôt distant |
git merge |
Préserve les deux historiques | Intégrer des branches en toute sécurité |
git merge --ff-only |
Déplace uniquement le pointeur de branche | Intégration propre en fast-forward |
git merge --no-ff |
Force un commit de merge | Préserver la délimitation de la branche de fonctionnalité |
git merge --squash |
Applique uniquement le diff combiné | Un seul commit pour la fonctionnalité |
git rebase |
Réécrit les identifiants des commits rejoués | Linéariser l’historique d’une fonctionnalité privée |
git branch -d |
Supprime la référence de la branche locale fusionnée | Nettoyage sûr |
git push --delete |
Supprime la branche distante | Nettoyage côté distant |
git merge --abort |
Annule le merge actif | Revenir d’un merge erroné ou risqué |
La décision centrale est :
Besoin de préserver l’historique partagé ?
→ merge
Besoin de linéariser l’historique d’une fonctionnalité privée ?
→ un rebase peut convenir
Points à vérifier
La branche de fonctionnalité contient des commits inattendus
Exécutez :
git log --oneline origin/main..HEAD
et inspectez le graphe.
La branche a peut-être été créée à partir de la mauvaise base.
Le merge crée de nombreux conflits
Causes probables :
- branche de longue durée
- refactorisation étendue qui se chevauche
- branche de fonctionnalité obsolète
- nombreuses modifications sans rapport dans une même branche
Rétablissez d’abord la justesse du code, puis envisagez de modifier le workflow de branches.
Le merge indique « Already up to date »
Vous êtes peut-être sur la mauvaise branche ou vous fusionnez dans le mauvais sens.
Vérifiez :
git branch --show-current
git log --oneline --graph --decorate --all -20
La branche distante a changé après votre rebase
Ne l’écrasez pas à l’aveugle.
Lancez git fetch et vérifiez si quelqu’un d’autre a poussé des modifications.
La suppression de la branche est refusée
Git estime que la branche contient des commits non fusionnés dans l’historique cible.
Inspectez-les avant d’utiliser -D.
Le même conflit réapparaît sans cesse
Une divergence de longue durée ou des rebases/cherry-picks répétés peuvent provoquer des chevauchements récurrents.
Envisagez des branches plus petites et une intégration plus fréquente.
Notes de production
La politique de branches doit correspondre à la collaboration de l’équipe
Il n’existe pas de politique universellement meilleure.
Les modèles courants sont notamment :
commits de merge
squash merge
rebase + fast-forward
Choisissez-en une délibérément et appliquez-la de manière cohérente.
Les branches partagées doivent éviter la réécriture de l’historique
Dès que d’autres personnes dépendent des identifiants de commit, la réécriture entraîne une coordination et des risques inutiles.
Des branches de courte durée réduisent le coût des conflits
Plus une branche de fonctionnalité diverge longtemps de main, plus une résolution de conflits importante devient probable.
Intégrez suffisamment souvent pour que les différences restent gérables.
La résolution des conflits de fusion est une revue de code
Un conflit n’est pas qu’un simple problème mécanique de Git.
L’ingénieur doit comprendre le comportement combiné attendu.
Le CI/CD s’exécute généralement sur l’état de la branche, pas sur l’intention
Avant de fusionner, vérifiez :
- la bonne branche
- les commits attendus
- un arbre de travail propre
- l’état des tests et du build
- l’absence de fichiers ajoutés par accident
Les branches de suivi distant sont des instantanés
Lancez toujours git fetch avant de prendre des décisions d’intégration fondées sur origin/*.
Erreurs fréquentes
1. Créer une branche de fonctionnalité à partir d’un main obsolète
Vous démarrez avec une divergence évitable.
2. Fusionner en étant sur la mauvaise branche
Git fusionne dans la branche courante.
Vérifiez d’abord.
3. Faire un rebase d’une branche que vos coéquipiers utilisent déjà
Cela réécrit les identifiants de commit et complique leur historique.
4. Faire un force push après un merge normal
Un merge ne nécessite normalement pas de force push.
5. Choisir --ours ou --theirs à l’aveugle
Une résolution de conflit correcte peut nécessiter les deux côtés.
6. Supprimer une branche avec -D sans vérifier ses commits propres
Vous pouvez perdre le pointeur de branche vers du travail non fusionné.
7. Considérer le squash merge comme identique à un merge normal
Le squash ne préserve pas la même relation d’ascendance.
8. Comparer les extrémités des branches alors que vous voulez seulement les modifications de la fonctionnalité
Pour une revue de type pull request, la comparaison à trois points est généralement plus utile.
9. Supposer que origin/main est à jour sans lancer git fetch
Les références de suivi distant peuvent être obsolètes.
10. Garder des branches de fonctionnalité ouvertes trop longtemps
Une divergence prolongée augmente la complexité des conflits et de la revue.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.