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