Rebase interactif Git dans une interface graphique : écraser, corriger, reformuler, réorganiser et supprimer les commits

Une interface graphique de rebase interactive vous permet de réécrire les commits sur votre branche à partir d'une liste au lieu d'un fichier texte : choisissez un commit de départ, attribuez à chaque commit au-dessus une action (sélectionner, écraser, corriger, reformuler, modifier ou déposer), faites-les glisser dans un nouvel ordre et laissez Git les rejouer. Il exécute la même opération que git rebase -i, le résultat est donc identique à la ligne de commande. Dans GitTree, cliquez avec le bouton droit sur les commits juste en dessous de ceux que vous souhaitez modifier, choisissez Rebase interactif des commits ci-dessus…, définissez les actions et cliquez sur Start Rebase. Si le résultat est faux, Undo remet la branche en place.

Ce didacticiel de rebase interactif couvre chaque action, trois façons d'écraser les commits, les commandes correspondantes, l'autosquash et le filet de sécurité. Les captures d'écran montrent l'éditeur de rebase interactif de {GitTree, un client Git pour macOS, Windows et Linux, mais le comportement de Git est le même dans n'importe quel outil.

Que fait le rebase interactif Git et quand l'utiliser

Un rebase normal déplace une série de commits vers une nouvelle base. Un rebase interactif vous permet également de modifier cette série en cours de route : Git affiche les commits qu'il est sur le point de rejouer, vous modifiez la liste et Git reconstruit la branche pour qu'elle corresponde. Chaque commit réécrit obtient un nouvel identifiant, c'est pourquoi le rebase interactif appartient à l'étape précédant le partage de votre travail. Raisons typiques pour y parvenir :

• Réduisez une série de commits « wip », « correction de faute de frappe » et « révision d'adresse » en un seul commit significatif avant d'ouvrir une pull request.
• Reformulez un message de validation contenant une faute de frappe, un numéro de ticket manquant ou un résumé vague.
• Incorporez une modification oubliée dans le commit auquel il appartient, afin que chaque commit se construise tout seul.
• Reorder s'engage pour qu'un refactor atterrisse avant la fonctionnalité qui en dépend.
• Supprimez une validation de débogage ou une expérience qui ne devrait jamais atteindre la branche principale.

Choisir, écraser, corriger, reformuler, éditer et supprimer : les actions de rebase expliquées

Chaque ligne d'un plan de rebase interactif correspond à un commit plus une action. Voici ceux que vous utiliserez au quotidien (le fichier todo de Git en contient quelques autres pour les scripts, tels que exec et break) :

L'ordre est important, et c'est l'opposé de `git log`. Le plan répertorie le commit le plus ancien en haut, dans l'ordre de relecture, tandis que git log et la plupart des graphiques de commit affichent en premier le commit le plus récent. Un squash ou une correction se fond toujours dans le commit directement au-dessus, le plus ancien. Si une courge se retrouve en haut sans rien dans quoi se replier, GitTree refuse de démarrer jusqu'à ce que vous la déplaciez en dessous d'un commit que vous conservez.

L'équivalent en ligne de commande : git rebase -i

Sur la ligne de commande, vous nommez les commits juste en dessous de ceux que vous souhaitez modifier : comptez à rebours à partir de HEAD, ou utilisez le point où votre branche a quitté main.

# rewrite the last 5 commits
git rebase -i HEAD~5

# rewrite everything since the branch left main, without moving its base
git rebase -i $(git merge-base main HEAD)

Git ouvre votre éditeur avec une liste de tâches. Celui-ci est le même plan que la capture d'écran plus bas : le deuxième commit est écrasé dans le premier et le quatrième reçoit un nouveau message.

pick f2cd67d chore(deps): upgrade Next.js and React
squash 19a1104 ci: cache pnpm store and run tests in parallel
pick f52edc8 refactor(api): extract repository layer from handlers
reword 05dfac2 feat(api): rate limit public endpoints
pick bf2385e fix(web): focus trap in the invite dialog

Enregistrez et fermez le fichier et Git commence la relecture. Il demande le message d'écrasement et le message reformulé, et s'arrête sur toute étape ou conflit edit, où vous continuez ou abandonnez :

git rebase --continue   # after amending or resolving a conflict
git rebase --abort      # stop and put the branch back where it was

Une interface graphique change la façon dont vous écrivez le plan, pas ce que Git en fait. GitTree exécute le même plan avec Git déjà installé sur votre ordinateur (version 2.39 ou plus récente), de sorte que l'application et un terminal produisent les mêmes commits. Pour les compromis plus larges, lisez Git GUI vs command line.

Comment écraser les commits dans une interface graphique Git

La réponse courte à la façon d'écraser les commits : placez-les les uns à côté des autres, laissez le premier comme choix, marquez le reste comme écrasement ou correction, et rejouez. GitTree vous propose trois façons d'y arriver.

Écraser un groupe de commits dans l'éditeur de rebase

Ouvrez l'éditeur à partir du commit sous le groupe, définissez son premier commit sur pick et les autres sur squash, ou sur fixup si vous ne voulez pas leurs messages. Faites glisser les commits parasites en place si le groupe n’est pas contigu. GitTree prévisualise chaque groupe contenant une courge comme le commit qu'il deviendra, avec le message combiné dans une zone que vous pouvez modifier.

Sélectionnez les commits dans le graphique et choisissez Squash Commits

Pour un écrasement rapide, sélectionnez au moins deux validations consécutives de la branche actuelle dans le graphique, cliquez avec le bouton droit et choisissez Squash Commits. GitTree exécute le rebase pour vous et Undo peut remettre les validations séparées. Le même menu réécrit les commits uniques en une seule étape : Edit Commit Message…, Drop Commit…, Move Commit Up et Move Commit Down. Ces raccourcis fonctionnent sur les commits qui ne sont pas encore sur une télécommande ; pour les commits poussés, utilisez l'éditeur, qui vous demande d'abord de confirmer.

Écrasez lorsque vous fusionnez la demande d'extraction

Si votre équipe conserve un commit par demande d'extraction, vous n'aurez peut-être pas besoin de réécrire la branche : la vue de la demande d'extraction de GitTree peut fusionner avec squash et votre branche locale reste telle qu'elle était.

Correction des commits et autosquash : corrigez un ancien commit sans le réorganiser manuellement

Pendant que vous travaillez, validez chaque petite correction en tant que correction du commit auquel elle appartient ; Git l'intitule fixup! <original title>. Plus tard, un rebase interactif avec autosquash déplace chaque correction directement sous sa cible et la marque comme une correction, il vous suffit donc de vérifier la liste et de commencer.

# record a correction for an earlier commit
git commit --fixup=05dfac2

# correct the commit and replace its message too
git commit --fixup=amend:05dfac2

# later: fold every fixup! and amend! commit into its target
git rebase -i --autosquash main

# turn autosquash on for every interactive rebase
git config --global rebase.autoSquash true

Dans GitTree, exécutez ces commandes dans le terminal intégré ancré sous le graphique, ou tapez fixup!, un espace et le titre original dans la zone de message de validation ; Git correspond aux corrections par titre, donc les deux créent le même commit. Avec Arrange fixup !, écrasez ! et modifiez ! commits activée, l'éditeur s'ouvre déjà organisé et ce que vous voyez est exactement ce que Git exécute.

Un commit amend! devient fixup -C dans le plan (« Fixup, utilisez son message » dans GitTree) : ses modifications sont intégrées et son message remplace celui de la cible. Selon la documentation git-commit, ni l'un ni l'autre ne change l'auteur du commit d'origine.

Le rebase interactif est-il sûr ? Annuler, le reflog et forcer avec bail

Un rebase ne supprime pas immédiatement les anciens commits : ils restent accessibles depuis le reflog jusqu'à ce que le garbage collection de Git efface les objets inaccessibles beaucoup plus tard. Les vrais risques sont de perdre la trace de l’ancienne branche et d’écraser le travail d’un collègue sur la télécommande.

Annuler un rebase terminé

GitTree prend un instantané de la branche avant chaque rebase, donc Annuler dans la barre d'outils la remet en un clic, y compris les autres branches que le rebase a déplacées avec update-refs, tant que rien n'a déplacé la branche depuis. Comment annuler une réinitialisation, un rebase ou un commit de git couvre le reste de ce filet de sécurité. Sur la ligne de commande :

# still in the middle of the rebase
git rebase --abort

# already finished: go back to the tip from before the rebase
git reflog show --date=relative
git reset --hard ORIG_HEAD

Git définit ORIG_HEAD sur l'ancienne astuce lorsqu'un rebase démarre, mais une exécution de git reset pendant le rebase (pour diviser un commit, par exemple) le déplace. Juste après le rebase, @{1}, la position précédente de la branche actuelle, pointe toujours vers l'ancienne astuce, donc git reset --hard @{1} fonctionne aussi. git reset --hard supprime les modifications non validées, alors validez-les ou cachez-les d'abord.

La réécriture des commits que vous avez déjà poussés

GitTree étiquette les commits qui sont déjà sur une télécommande avec « Sur une télécommande » et vous demande de confirmer avant de les réécrire. Ensuite, une poussée normale est refusée, il faut donc une poussée forcée. Utilisez le formulaire de location, qui n'écrase la branche distante que si elle pointe toujours là où vous l'avez vue pour la dernière fois :

git push --force-with-lease

# safer when something fetches in the background
git push --force-with-lease --force-if-includes

Une récupération en arrière-plan peut actualiser votre branche de suivi à distance et affaiblir le bail, c'est pourquoi la documentation git-push suggère d'ajouter --force-if-includes. Dans GitTree, une poussée forcée utilise toujours --force-with-lease, épinglé à l'astuce distante affichée lorsque vous confirmez, et cette astuce est conservée localement sous refs/ogt/trash, de sorte que les validations qu'il supprime de la télécommande ne sont pas perdues. L'annulation ne peut pas inverser une poussée forcée, car elle a modifié la télécommande.

Lorsqu'une étape s'arrête : modifications et conflits

Une étape edit ou un commit qui ne s'applique plus proprement met le rebase en pause. GitTree affiche la progression du plan et une bannière pour continuer ou abandonner. Les conflits s'ouvrent dans l'éditeur à trois voies, abordés dans résolution des conflits de fusion dans une interface graphique. Lors d'un rebase, Git échange les côtés d'une fusion : « la nôtre » est la branche sur laquelle vous vous rebasez et « la leur » est votre propre commit, donc GitTree les étiquete « rebasage sur » et « votre commit ». La leçon Continuer, sauter ou abandonner une opération active pratique chaque choix, et pour copier un seul commit au lieu de réécrire une branche, voir cherry-pick.

Conseils pour un historique de validation propre avant une pull request

• Créez chaque build de commit et réussissez ses tests de manière indépendante, et séparez les modifications non liées : un commit pour le refactor, un pour la fonctionnalité.
• Rebasez-vous sur le dernier main avant d'ouvrir la demande d'extraction, afin que les réviseurs ne voient que vos modifications.
• Travailler avec des branches empilées ? Activez update-refs pour que les branches construites sur la vôtre bougent avec les commits réécrits.
• Si la plage contient un commit de fusion, GitTree l'affiche mais ne le réécrira pas ; utilisez git rebase -i --rebase-merges pour ce cas.
• Vérifiez le résultat dans le commit graph avant de pousser, et laissez votre propre IA coder des messages CLI, comme dans AI commit messages with Claude Code and Codex.
• Entraînez-vous d'abord sur un référentiel jetable avec la leçon gratuite Rebase un travail non publié sur une nouvelle base.

GitTree propose un forfait gratuit qui couvre toutes les fonctionnalités de Git, dépôts privés inclus, sur macOS, Windows et Linux, en English and Arabic ; Nour, l'assistant IA, est fourni avec GitTree Pro (voir tarification). Il a besoin de Git 2.39 ou plus récent et d'un compte GitTree pour se connecter. Obtenez-le depuis la page de téléchargement, ou comparez d'abord les meilleurs clients Git GUI.