Parcourir les aide-mémoire · Git

Technologie: GitCatégorie: Gestion de versionsNiveau: IntermédiaireMis à jour

Rebase : référence rapide

Faites un rebase de vos branches Git en toute sécurité pour rejouer vos commits locaux sur une nouvelle base, résoudre les conflits de manière réfléchie, nettoyer un historique privé et récupérer la situation lorsqu’un rebase tourne mal.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Vérifier l’arbre de travail avant le rebase
  5. 2. Récupérer d’abord le dernier état du dépôt distant
  6. 3. Faire un rebase de la branche actuelle sur la dernière version de main
  7. 4. Faire un rebase sur une branche main locale
  8. 5. Vérifier ce qui va être rejoué
  9. 6. Inspecter le graphe des branches
  10. 7. Trouver la base de fusion
  11. 8. Résoudre un conflit de rebase
  12. 9. Lister les fichiers non résolus
  13. 10. Inspecter le contenu du conflit
  14. 11. Poursuivre après avoir résolu les conflits
  15. 12. Ignorer un commit uniquement s’il n’est vraiment plus nécessaire
  16. 13. Annuler le rebase
  17. 14. Quitter un rebase sans réinitialiser l’état de la branche
  18. 15. Pousser une branche de fonctionnalité après un rebase
  19. 16. Pourquoi --force-with-lease est plus sûr
  20. 17. Ne pas faire de rebase à la légère sur les branches d’intégration partagées
  21. 18. Faire un rebase interactif des commits récents
  22. 19. Actions courantes du rebase interactif
  23. 20. Reformuler un message de commit
  24. 21. Regrouper des commits liés avec squash
  25. 22. Utiliser fixup pour les commits de nettoyage
  26. 23. Supprimer un commit local indésirable
  27. 24. Réordonner des commits
  28. 25. Modifier un commit pendant un rebase interactif
  29. 26. Scinder un commit en plusieurs commits
  30. 27. Utiliser autosquash avec des commits fixup
  31. 28. Créer un commit fixup à partir des modifications en cours
  32. 29. Faire un rebase d’une branche sur une autre base
  33. 30. Inspecter les commits avant d’utiliser --onto
  34. 31. Faire un rebase d’une branche en étant positionné sur une autre
  35. 32. Préserver la topologie des merges avec --rebase-merges
  36. 33. Éviter le rebase à la légère d’un historique partagé riche en merges
  37. 34. Vérifier l’état actuel du rebase
  38. 35. Modifier la liste de tâches restante du rebase
  39. 36. Récupérer après un rebase accidentel grâce au reflog
  40. 37. Créer une branche de sauvegarde avant le rebase
  41. 38. Comparer avant et après le rebase
  42. 39. Vérifier le contenu de la fonctionnalité après le rebase
  43. 40. Lancer les tests après la résolution des conflits
  44. 41. Faire un rebase sur la dernière version de main distante sans changer de branche
  45. 42. Configurer délibérément le comportement de pull
  46. 43. Faire un rebase avec autostash lorsque c’est approprié
  47. 44. Éviter le rebase avec des fichiers générés ou d’environnement non commités
  48. 45. Ne rejouer que les commits qui appartiennent à la fonctionnalité
  49. 46. Ne pas faire de rebase uniquement pour que l’historique « ait l’air propre »
  50. 47. Comprendre que les identifiants de commit changent
  51. 48. Le rebase peut rejouer les conflits plusieurs fois
  52. 49. N’utiliser rerere que si votre équipe le comprend
  53. 50. Préférer merge lorsque le risque du rebase dépasse son bénéfice
  54. Interpréter le résultat
  55. Points à vérifier
  56. Le push est rejeté après un rebase réussi
  57. Le rebase inclut des commits inattendus
  58. Le même conflit apparaît à plusieurs reprises
  59. Le rebase s’est terminé, mais le diff de la fonctionnalité a changé
  60. Un commit a disparu
  61. Un collègue indique que sa branche est cassée après votre push forcé
  62. Notes de production
  63. Le rebase est le plus sûr avant le partage
  64. Force-with-lease doit rester intentionnel
  65. La CI/CD référence les identifiants de commit
  66. La résolution des conflits peut modifier le comportement
  67. Le rebase interactif sert à concevoir l’historique
  68. Les branches de sauvegarde et le reflog sécurisent la réécriture locale
  69. Erreurs fréquentes
  70. 1. Faire un rebase sans lancer fetch au préalable
  71. 2. Faire un rebase de branches partagées
  72. 3. Faire un push forcé avec --force
  73. 4. Utiliser --skip simplement pour passer outre un conflit
  74. 5. Traiter la résolution des conflits de façon mécanique
  75. 6. Utiliser le rebase interactif sur un historique déjà partagé sans coordination
  76. 7. Mal réordonner des commits dépendants
  77. 8. Regrouper des commits sans rapport
  78. 9. Supposer que le rebase préserve automatiquement le contenu exact
  79. 10. Utiliser rebase alors que merge est plus simple et plus sûr
  80. Étape suivante
  81. Pour aller plus loin

Problème

Vous devez mettre à jour ou nettoyer une branche de fonctionnalité sans introduire de commits de merge inutiles.

Les cas d’usage typiques du rebase sont les suivants :

  • rejouer une branche de fonctionnalité par-dessus la dernière version de main
  • garder linéaire l’historique d’une branche privée
  • réordonner, regrouper (squash) ou modifier des commits locaux
  • supprimer des commits accidentels avant d’ouvrir une pull request
  • résoudre les conflits pendant que les commits sont rejoués
  • récupérer la situation après un rebase échoué ou incorrect

Le principal risque est que le rebase réécrit l’historique des commits.

C’est sans danger pour des branches de fonctionnalité privées ou volontairement réécrites, mais dangereux pour des commits partagés dont vos collègues dépendent déjà.

Réponse rapide

Mettez à jour une branche de fonctionnalité privée sur la dernière version de main :

git status
git fetch origin
git rebase origin/main

En cas de conflits :

git status
# edit conflicted files
git add path/to/resolved-file
git rebase --continue

Annulez si nécessaire :

git rebase --abort

Si la branche a déjà été poussée et que la réécrire est acceptable :

git push --force-with-lease

La règle centrale est la suivante :

Historique de fonctionnalité privé
→ le rebase est généralement sans danger

Historique partagé
→ évitez de le réécrire, sauf coordination explicite de l’équipe

Code / commandes

1. Vérifier l’arbre de travail avant le rebase

git status

Partez de préférence d’un arbre de travail (working tree) propre.

S’il existe des modifications sans rapport :

git stash push -u -m "WIP before rebase"

ou faites-en un commit sur la branche appropriée.

Ne commencez pas un rebase complexe avec du travail non commité sans rapport, à moins de comprendre exactement comment Git va le gérer.


2. Récupérer d’abord le dernier état du dépôt distant

git fetch origin

Cette commande met à jour :

origin/main
origin/develop
origin/feature/...

sans modifier votre arbre de travail actuel.

Ne faites pas de rebase sur une vue locale obsolète de la branche distante.


3. Faire un rebase de la branche actuelle sur la dernière version de main

git rebase origin/main

Conceptuellement :

Avant :

A---B---C  origin/main
     \
      D---E  feature

Après :

A---B---C  origin/main
         \
          D'---E'  feature

D' et E' sont de nouveaux commits avec de nouveaux identifiants de commit.


4. Faire un rebase sur une branche main locale

Si la branche main locale est déjà à jour :

git rebase main

Workflow plus sûr :

git switch main
git pull --ff-only
git switch feature/report-engine
git rebase main

Utiliser origin/main après git fetch est souvent plus direct.


5. Vérifier ce qui va être rejoué

Avant le rebase :

git log --oneline origin/main..HEAD

Cette commande affiche les commits propres à votre branche actuelle.

Ce sont ces commits que Git rejouera en général.


6. Inspecter le graphe des branches

git log \
  --oneline \
  --graph \
  --decorate \
  --all \
  -30

Utilisez cette commande lorsque l’ascendance des branches n’est pas évidente.

Ne lancez pas de rebase avant d’avoir compris quelle branche sert de base et quels commits sont propres à votre branche.


7. Trouver la base de fusion

git merge-base origin/main HEAD

Cette commande identifie l’ancêtre commun.

Elle est utile lorsqu’une branche a été créée à partir d’une base inattendue.


8. Résoudre un conflit de rebase

Lorsque Git s’arrête :

git status

Ouvrez les fichiers en conflit et résolvez-les selon le contenu final voulu.

Ajoutez-les ensuite à l’index (zone de préparation) :

git add path/to/file

Poursuivez :

git rebase --continue

Répétez jusqu’à ce que tous les commits aient été rejoués.


9. Lister les fichiers non résolus

git diff --name-only --diff-filter=U

À utiliser lors de la résolution d’un conflit de grande ampleur.


10. Inspecter le contenu du conflit

git diff

Les marqueurs de conflit peuvent ressembler à ceci :

<<<<<<< HEAD
version de la branche de base
=======
version du commit rejoué
>>>>>>> commit-message

Pendant un rebase, la signification de ours et theirs peut être contre-intuitive, car Git rejoue les commits sur la nouvelle base.

Ne choisissez pas un camp de façon mécanique.

Résolvez le code en fonction de l’état final voulu.


11. Poursuivre après avoir résolu les conflits

git add src/app.py
git rebase --continue

Si Git ouvre l’éditeur de message de commit, relisez le message avant de poursuivre.


12. Ignorer un commit uniquement s’il n’est vraiment plus nécessaire

git rebase --skip

N’utilisez cette commande que si les modifications du commit en cours sont déjà présentes ou volontairement abandonnées.

Ignorer un commit le retire de la branche rejouée.

N’utilisez pas --skip simplement pour passer outre un conflit.


13. Annuler le rebase

git rebase --abort

Cette commande ramène la branche à son état d’avant le rebase.

À utiliser lorsque :

  • vous êtes parti de la mauvaise base
  • les conflits révèlent que l’approche n’est pas sûre
  • vous devez repenser l’historique de la branche

Il vaut mieux annuler que d’improviser des resets destructeurs pendant un rebase en cours.


14. Quitter un rebase sans réinitialiser l’état de la branche

git rebase --quit

Cette commande arrête la mécanique du rebase sans nécessairement restaurer l’état d’origine de la branche.

Ne l’utilisez que si vous comprenez la différence avec :

git rebase --abort

Dans la plupart des scénarios de récupération, --abort est le choix le plus sûr.


15. Pousser une branche de fonctionnalité après un rebase

Si la branche n’a jamais été poussée :

git push -u origin feature/report-engine

Si elle a déjà été poussée et que la réécrire est acceptable :

git push --force-with-lease

Préférez cette commande à :

git push --force

16. Pourquoi --force-with-lease est plus sûr

--force-with-lease vérifie que la branche distante pointe toujours vers le commit attendu par votre dépôt local.

Si quelqu’un d’autre a poussé de nouveaux commits, le push forcé est refusé.

Cela réduit le risque d’écraser le travail d’un autre développeur.

Cela ne rend pas pour autant la réécriture de l’historique sans risque.


17. Ne pas faire de rebase à la légère sur les branches d’intégration partagées

Évitez de réécrire :

main
develop
release
branches d’équipe partagées

sauf si le workflow du dépôt l’exige explicitement et le coordonne.

Le rebase est surtout adapté aux branches de fonctionnalité privées ou volontairement réécrivables.


18. Faire un rebase interactif des commits récents

git rebase -i HEAD~5

Cette commande ouvre les cinq derniers commits dans une liste de tâches (todo list) interactive.

Exemple :

pick a1b2c3d Add report endpoint
pick d4e5f6a Fix typo
pick 1112223 Add validation
pick 3334445 Debug logging
pick 5556667 Remove debug logging

Vous pouvez changer l’action de chaque commit.


19. Actions courantes du rebase interactif

Commandes typiques :

pick
reword
edit
squash
fixup
drop

Utilisation :

pick
→ conserver le commit

reword
→ conserver les modifications, modifier le message

edit
→ marquer une pause pour pouvoir modifier le commit

squash
→ combiner avec le commit précédent et modifier le message combiné

fixup
→ combiner avec le commit précédent et abandonner le message de ce commit

drop
→ supprimer le commit

20. Reformuler un message de commit

Rebase interactif :

git rebase -i HEAD~3

Remplacez :

pick a1b2c3d bad message

par :

reword a1b2c3d bad message

Git s’arrêtera pour que vous puissiez modifier le message.


21. Regrouper des commits liés avec squash

Exemple de liste de tâches :

pick a1b2c3d Add report endpoint
squash d4e5f6a Add validation
squash 1112223 Fix endpoint naming

Git combine les commits en un seul.

Utilisez cette action lorsque l’historique final est plus clair sous la forme d’une seule modification logique.

Ne regroupez pas du travail sans rapport simplement pour réduire le nombre de commits.


22. Utiliser fixup pour les commits de nettoyage

Exemple :

pick a1b2c3d Add report endpoint
fixup d4e5f6a Fix typo
fixup 1112223 Remove debug print

Le commit final conserve le message du premier commit.

C’est utile pour les petits commits correctifs créés pendant le développement.


23. Supprimer un commit local indésirable

Rebase interactif :

pick a1b2c3d Add endpoint
drop d4e5f6a Add temporary debug file
pick 1112223 Add tests

Vous pouvez aussi supprimer la ligne dans la liste de tâches.

À réserver aux commits non publiés ou aux cas où une réécriture coordonnée de l’historique est acceptable.


24. Réordonner des commits

Le rebase interactif permet de changer l’ordre des commits :

pick 1112223 Add data model
pick a1b2c3d Add endpoint
pick d4e5f6a Add tests

au lieu de :

pick a1b2c3d Add endpoint
pick 1112223 Add data model
pick d4e5f6a Add tests

Ne réordonnez que si les commits suivants s’appliquent toujours proprement et que l’historique obtenu reste logiquement correct.


25. Modifier un commit pendant un rebase interactif

Remplacez :

pick a1b2c3d Add endpoint

par :

edit a1b2c3d Add endpoint

Lorsque Git s’arrête :

# modify files
git add path/to/file
git commit --amend
git rebase --continue

Utilisez cette méthode pour corriger le contenu d’un ancien commit local.


26. Scinder un commit en plusieurs commits

Commencez :

git rebase -i HEAD~5

Marquez le commit ciblé :

edit

Lorsque Git s’arrête :

git reset HEAD^

Cela conserve les modifications dans l’arbre de travail, mais supprime le commit.

Ajoutez ensuite à l’index et faites des commits par morceaux logiques :

git add -p
git commit -m "Add report model"

git add -p
git commit -m "Add report API"

Puis :

git rebase --continue

À n’utiliser que sur un historique local et non partagé.


27. Utiliser autosquash avec des commits fixup

Créez un commit fixup :

git commit --fixup=<commit>

Puis :

git rebase -i --autosquash origin/main

Git place automatiquement le commit fixup à côté de sa cible et le marque comme fixup.

C’est utile pendant le développement actif d’une fonctionnalité.


28. Créer un commit fixup à partir des modifications en cours

git add path/to/file
git commit --fixup=a1b2c3d

Plus tard :

git rebase -i --autosquash origin/main

Vous gardez ainsi un développement rapide tout en produisant un historique propre avant la revue.


29. Faire un rebase d’une branche sur une autre base

Syntaxe avancée :

git rebase --onto <new-base> <old-base> <branch>

Exemple :

git rebase \
  --onto origin/main \
  origin/develop \
  feature/report-engine

Cette commande indique à Git :

Prends les commits de feature/report-engine
qui suivent origin/develop
et rejoue-les sur origin/main

Utilisez-la lorsqu’une branche a été créée à partir de la mauvaise base ou doit passer d’une ligne de release à une autre.


30. Inspecter les commits avant d’utiliser --onto

Avant d’exécuter :

git rebase --onto ...

inspectez :

git log --oneline <old-base>..<branch>

Ce sont les commits qui seront probablement rejoués.

Si la plage est incorrecte, n’allez pas plus loin.


31. Faire un rebase d’une branche en étant positionné sur une autre

Les versions récentes de Git acceptent :

git rebase origin/main feature/report-engine

Cette commande fait un checkout interne de la branche indiquée, puis en fait le rebase.

Pour la clarté des workflows manuels, il est souvent plus simple de basculer d’abord sur la branche.


32. Préserver la topologie des merges avec --rebase-merges

git rebase --rebase-merges origin/main

Utilisez cette option lorsque la branche de fonctionnalité contient des commits de merge significatifs qui doivent être reconstruits plutôt qu’aplatis.

Il s’agit d’un workflow avancé.

Ne l’utilisez que si la préservation de la topologie des branches compte.


33. Éviter le rebase à la légère d’un historique partagé riche en merges

Les commits de merge peuvent encoder des décisions d’intégration.

Les aplatir ou les recréer modifie la structure de l’historique.

Comprenez le modèle de branches avant de les réécrire.


34. Vérifier l’état actuel du rebase

git status

Git indiquera :

  • qu’un rebase est en cours
  • le commit en cours de rejeu
  • les conflits
  • les commandes terminées/restantes

Lancez git status avant de deviner la suite.


35. Modifier la liste de tâches restante du rebase

Pendant un rebase interactif :

git rebase --edit-todo

Utilisez cette commande pour modifier les actions à venir.

Ne modifiez pas manuellement les fichiers internes du rebase dans .git, à moins de comprendre le fonctionnement interne de Git.


36. Récupérer après un rebase accidentel grâce au reflog

git reflog

Retrouvez la pointe de la branche d’avant le rebase.

Inspectez :

git show <old-commit>

Créez une branche de récupération :

git switch -c recovery-before-rebase <old-commit>

Le reflog est l’un des moyens les plus sûrs de récupérer un historique local après une réécriture.


37. Créer une branche de sauvegarde avant le rebase

Avant une réécriture compliquée :

git branch backup-before-rebase

Lancez ensuite le rebase.

En cas de problème :

git switch backup-before-rebase

C’est une assurance peu coûteuse.


38. Comparer avant et après le rebase

Avant le rebase, enregistrez l’ancienne pointe :

git branch backup-before-rebase

Comparez ensuite :

git diff backup-before-rebase...HEAD

Pour un simple nettoyage de l’historique, le contenu final des fichiers doit normalement rester équivalent.


39. Vérifier le contenu de la fonctionnalité après le rebase

git diff origin/main...HEAD

Le résultat doit toujours représenter la modification voulue pour la fonctionnalité.

Inspectez aussi :

git log --oneline origin/main..HEAD

Assurez-vous qu’aucun commit de la fonctionnalité n’a disparu de manière inattendue.


40. Lancer les tests après la résolution des conflits

Un rebase peut produire du code fusionnable sur le plan syntaxique, mais logiquement faux.

Après la résolution des conflits :

build
tests
lint
vérification des types

selon ce qui convient au projet.

Ne considérez pas un rebase sans conflit comme une preuve d’exactitude.


41. Faire un rebase sur la dernière version de main distante sans changer de branche

Flux concis typique :

git fetch origin
git rebase origin/main

C’est souvent la mise à jour quotidienne la plus propre d’une branche de fonctionnalité.


42. Configurer délibérément le comportement de pull

Git peut être configuré pour utiliser un merge, un rebase ou uniquement l’avance rapide (fast-forward) pour git pull.

Exemples :

git config pull.rebase true

ou :

git config pull.ff only

Ne modifiez pas le comportement global sans comprendre le workflow de l’équipe.

Des commandes explicites sont souvent plus claires dans les environnements d’ingénierie de production.


43. Faire un rebase avec autostash lorsque c’est approprié

git rebase --autostash origin/main

Git met temporairement de côté les modifications locales avec stash et les réapplique après le rebase.

C’est pratique, mais cela peut tout de même créer des conflits au moment de restaurer le travail mis de côté.

Un arbre de travail propre reste plus facile à appréhender.


44. Éviter le rebase avec des fichiers générés ou d’environnement non commités

Si des fichiers locaux générés ou de configuration diffèrent selon l’environnement, réglez la question avant le rebase.

Ne laissez pas des fichiers non suivis ou générés compliquer inutilement les opérations sur l’historique.


45. Ne rejouer que les commits qui appartiennent à la fonctionnalité

Si :

git log origin/main..HEAD

affiche des commits sans rapport, examinez la base de la branche avant le rebase.

Vous aurez peut-être besoin de :

git rebase --onto

au lieu d’un rebase normal.


46. Ne pas faire de rebase uniquement pour que l’historique « ait l’air propre »

Le nettoyage de l’historique doit améliorer :

  • la facilité de revue
  • la facilité de revert
  • le regroupement logique
  • la compréhension

Ne réécrivez pas un historique partagé stable pour des raisons esthétiques.


47. Comprendre que les identifiants de commit changent

Après un rebase :

ancien commit :
a1b2c3d

commit rejoué :
e4f5a6b

Le contenu peut être similaire, mais l’objet commit est différent parce que son parent/historique a changé.

C’est pourquoi les branches distantes exigent souvent --force-with-lease après un rebase.


48. Le rebase peut rejouer les conflits plusieurs fois

Si plusieurs commits touchent la même zone, des conflits similaires peuvent apparaître à plusieurs reprises au fil du rejeu de chaque commit.

Réponses possibles :

  • résoudre chaque commit fidèlement
  • regrouper d’abord les commits liés lorsque c’est approprié
  • annuler et utiliser merge si la réécriture ne vaut pas la complexité

49. N’utiliser rerere que si votre équipe le comprend

Git peut mémoriser les résolutions de conflits avec :

git config rerere.enabled true

Cela peut aider lorsque le même conflit se reproduit.

C’est utile dans les workflows avancés, mais la réutilisation automatique d’une résolution antérieure doit tout de même être relue.


50. Préférer merge lorsque le risque du rebase dépasse son bénéfice

Préférez merge lorsque :

  • la branche est partagée
  • des identifiants de commit sont déjà référencés à l’extérieur
  • la préservation de la topologie compte
  • le rejeu des conflits serait inutilement complexe
  • la politique de l’équipe interdit la réécriture

Le rebase est un outil, pas une obligation.

Interpréter le résultat

Commande Ce qu’elle fait Historique réécrit ?
git rebase origin/main Rejoue les commits de la branche actuelle sur la dernière version de main Oui
git rebase -i Réécrit de manière interactive la séquence de commits locaux Oui
git rebase --continue Poursuit après un conflit ou une modification Poursuit la réécriture
git rebase --skip Abandonne le commit en cours de rejeu Oui
git rebase --abort Restaure l’état de la branche d’avant le rebase Aucune réécriture finale conservée
git rebase --onto Déplace la plage de commits sélectionnée vers une nouvelle base Oui
git rebase --autostash Met temporairement le travail local de côté avec stash le temps du rebase Oui
git push --force-with-lease Met à jour de manière relativement sûre l’historique distant réécrit de la fonctionnalité Historique distant réécrit

La distinction principale est la suivante :

merge
→ combine des historiques existants

rebase
→ reconstruit les commits sur une nouvelle base

Points à vérifier

Le push est rejeté après un rebase réussi

C’est attendu si l’ancienne version de la branche existe déjà sur le dépôt distant.

Si la réécriture de la branche est autorisée :

git push --force-with-lease

N’utilisez pas --force seul par défaut.

Le rebase inclut des commits inattendus

Arrêtez-vous et inspectez :

git log origin/main..HEAD
git merge-base origin/main HEAD

La branche a peut-être la mauvaise base.

Le même conflit apparaît à plusieurs reprises

Plusieurs commits rejoués modifient la même zone.

Demandez-vous si :

  • les commits devraient être regroupés
  • un merge serait plus simple
  • la divergence de la branche est devenue trop importante

Le rebase s’est terminé, mais le diff de la fonctionnalité a changé

Comparez :

git diff backup-before-rebase...HEAD

Des modifications de contenu inattendues signifient que la résolution des conflits a probablement modifié le comportement.

Un commit a disparu

Vérifiez s’il a été :

  • ignoré (skip)
  • supprimé (drop)
  • absorbé comme patch déjà appliqué
  • omis par erreur pendant le rebase interactif

Utilisez git reflog pour récupérer l’ancienne pointe de la branche.

Un collègue indique que sa branche est cassée après votre push forcé

Vous avez probablement réécrit des commits partagés.

Arrêtez toute réécriture supplémentaire et coordonnez la récupération à l’aide du reflog ou des identifiants de commit distants connus.

Notes de production

Le rebase est le plus sûr avant le partage

Le meilleur moment pour nettoyer l’historique d’une fonctionnalité est avant que d’autres développeurs ne dépendent de ces identifiants de commit.

Force-with-lease doit rester intentionnel

C’est une vérification de sécurité, pas une autorisation de réécrire n’importe quelle branche partagée.

La CI/CD référence les identifiants de commit

Un rebase change les SHA des commits.

Cela peut affecter :

  • les références de build
  • les liens de déploiement
  • les commentaires de revue de code
  • les rapports d’incident

Ne réécrivez pas l’historique à la légère une fois que des workflows de déploiement ou de release y font référence.

La résolution des conflits peut modifier le comportement

Git ne connaît que l’historique textuel.

Il ne sait pas si le résultat fusionné préserve la sémantique de l’application.

Lancez les tests après un rebase riche en conflits.

Le rebase interactif sert à concevoir l’historique

Utilisez-le pour obtenir des commits :

  • ciblés
  • ordonnés logiquement
  • faciles à relire
  • réversibles

Ne réduisez pas automatiquement chaque fonctionnalité à un seul commit géant.

Les branches de sauvegarde et le reflog sécurisent la réécriture locale

Avant une réécriture complexe :

git branch backup-before-rebase

et gardez à l’esprit que :

git reflog

permet souvent de récupérer l’ancienne pointe.

Erreurs fréquentes

1. Faire un rebase sans lancer fetch au préalable

Vous risquez de faire un rebase sur un état distant obsolète.

2. Faire un rebase de branches partagées

Cela change des identifiants de commit dont d’autres développeurs peuvent dépendre.

3. Faire un push forcé avec --force

Utilisez --force-with-lease lorsque la réécriture est réellement nécessaire.

4. Utiliser --skip simplement pour passer outre un conflit

Cela supprime le commit en cours de rejeu.

5. Traiter la résolution des conflits de façon mécanique

Le bon résultat peut combiner les deux versions.

6. Utiliser le rebase interactif sur un historique déjà partagé sans coordination

Chaque commit modifié, regroupé ou réordonné reçoit une nouvelle identité.

7. Mal réordonner des commits dépendants

Les commits suivants peuvent s’appuyer sur des modifications antérieures.

Préservez les dépendances logiques.

8. Regrouper des commits sans rapport

Cela nuit à la facilité de revue et aux futurs reverts.

9. Supposer que le rebase préserve automatiquement le contenu exact

La résolution des conflits peut modifier le comportement final.

Comparez et testez ensuite.

10. Utiliser rebase alors que merge est plus simple et plus sûr

Un graphe linéaire ne vaut pas un risque opérationnel inutile.

Étape suivante

Choisissez l’action suivante en fonction de l’état de la branche.

  • La branche de fonctionnalité privée est en retard sur main → lancez fetch, puis faites un rebase sur origin/main.
  • La branche est déjà largement partagée → préférez merge, sauf si la réécriture est coordonnée.
  • Besoin de nettoyer des commits locaux → utilisez le rebase interactif.
  • Besoin de combiner des commits fixup → utilisez --fixup + --autosquash.
  • La branche est partie de la mauvaise base → inspectez la plage de commits, puis utilisez rebase --onto.
  • Un conflit apparaît → résolvez-le, ajoutez-le à l’index, puis lancez rebase --continue.
  • La direction ou la base du rebase est incorrecte → git rebase --abort.
  • Le rebase a réussi, mais le dépôt distant rejette le push → n’utilisez --force-with-lease que si la réécriture du distant est prévue.
  • Vous pensez que du travail a disparu → inspectez git reflog.
  • Les conflits sont trop complexes pour un rejeu sûr → annulez et envisagez merge.

← Tous les aide-mémoire