Comment j’ai corrigé les onglets dupliqués dans Expo Router
Expo Router est assez simple quand vos onglets constituent toute l’application.
Ça devient plus intéressant quand l’application a des onglets, mais aussi des routes plein écran en dehors des onglets, pour des écrans de détail, de traitement, de résultat, d’achat ou d’onboarding.
C’était ma configuration.
Et le bug n’était pas vraiment « Expo Router est cassé ».
Le bug, c’est que je créais par accident un second sous-arbre d’onglets.
L’application semblait revenir à l’accueil, mais ce n’était pas la même instance d’onglets.
C’est un problème très différent du simple fait d’atterrir sur le mauvais écran.
J’atterrissais sur un écran qui avait l’air correct, mais l’arbre d’onglets en dessous était tout neuf.
Le vrai mode de défaillance était donc : onglets dupliqués, interface identique en apparence, mauvaise instance.
C’est pour ça que le feed pouvait se réinitialiser, que le state propre à un onglet pouvait disparaître et que l’application pouvait sembler incohérente alors que l’utilisateur était « de retour sur l’accueil ».
Cet article existe parce que j’ai rencontré exactement ce problème et que j’ai dû le corriger.
Mon application n’avait pas un simple graphe composé uniquement d’onglets
Le détail important était le suivant :
mon tab navigator n’était pas toute l’application.
J’avais un root stack, et les onglets n’étaient qu’une branche à l’intérieur.
<Stack>
<Stack.Screen name="(tabs)" />
<Stack.Screen name="details/[id]" />
<Stack.Screen name="processing/[id]" />
<Stack.Screen name="result/[id]" />
<Stack.Screen name="purchase" />
</Stack>
Cette structure était voulue.
Je voulais details, processing et result en dehors des onglets pour qu’ils puissent occuper tout l’écran et masquer la tab bar.
Cette partie-là fonctionnait bien.
Le problème a commencé quand je revenais dans les onglets comme si /(tabs) était une route ordinaire parmi d’autres.
C’est là que la duplication se produisait.
Je ne revenais pas toujours dans la branche d’onglets existante.
Parfois, j’en créais en fait une nouvelle.
Autrement dit, l’application avait déjà un shell d’onglets vivant dans le root stack, et je montais par accident un autre shell d’onglets qui affichait la même interface d’accueil.

La façon la plus simple de dupliquer vos onglets
Dès que vous avez un graphe mixte, ce genre d’actions devient dangereux :
router.replace("/(tabs)/(home)");
router.dismissTo("/");
Elles semblent inoffensives, mais elles ne reviennent pas à « retourner dans l’instance d’onglets existante ».
Ce que je voulais, c’était ceci :
root stack
├─ (tabs) // existing tabs instance
├─ details/[id]
├─ processing/[id]
└─ result/[id]
back action -> return to the existing (tabs) branch
Ce que je faisais parfois à la place, c’était ceci :
root stack
├─ (tabs) // original tabs instance still exists
├─ details/[id]
├─ processing/[id]
├─ result/[id]
└─ (tabs) // fresh tabs instance mounted again
Ce second cas est le vrai bug.
Il signifie que l’utilisateur voit un écran d’accueil et une tab bar, mais qu’il n’est plus dans la branche d’onglets qu’il avait construite avant.
En pratique, cela se traduisait par :
- le montage d’une seconde branche d’onglets par-dessus l’originale
- la reconstruction de la branche d’onglets au lieu du retour dans celle qui existait
- la perte du state de l’onglet courant
- la perte de la position de scroll ou du state chargé de l’onglet
- un historique de navigation qui paraissait incohérent
Le plus pénible, c’est que ce bug passe facilement inaperçu.
Vous voyez toujours un écran d’accueil.
Vous voyez toujours une tab bar.
Mais vous êtes maintenant dans une instance d’onglets toute neuve, au lieu de celle que l’utilisateur avait déjà construite.
C’est pour ça que le state des onglets semble cassé au hasard.

Soyez précis sur ce que « accueil » veut vraiment dire
Après ça, j’ai arrêté de traiter « retourner à l’accueil » comme une idée vague.
Je l’ai rendu explicite :
export const TAB_HOME_ROUTE = "/(tabs)/(home)";
export const TAB_CREATE_ROUTE = "/(tabs)/(create)";
export const TAB_PROFILE_ROUTE = "/(tabs)/(profile)";
Et quand je devais revenir aux onglets, je visais la vraie route de l’onglet :
router.dismissTo("/(tabs)/(home)");
Et non :
router.dismissTo("/");
router.replace("/(tabs)/(home)");
J’ai fini par m’appuyer sur dismissTo pour ça, mais l’important n’était pas l’API elle-même.
L’important, c’est que la destination a cessé d’être vague.
C’était le premier vrai correctif.
Une fois la cible précise, la navigation cesse d’être approximative et commence à correspondre au graphe réel.
Le symptôme n’était pas « mauvais écran », mais « mauvaise instance »
Cette distinction compte.
L’utilisateur regardait souvent toujours le bon onglet.
Le problème, c’est qu’il s’agissait d’un nouvel arbre d’onglets.
C’est pour ça que la casse apparaissait de manière indirecte :
- la position de scroll avait disparu
- le state de l’onglet chargé auparavant avait disparu
- l’application semblait avoir oublié où l’utilisateur se trouvait
- les parcours répétés rendaient le stack de plus en plus étrange avec le temps
Dès que j’ai commencé à me demander « est-ce que je reviens dans l’instance d’onglets existante, ou est-ce que j’en crée une nouvelle ? », tout le problème est devenu beaucoup plus facile à comprendre.
Gardez les cibles de retour dynamiques sous contrôle
J’avais aussi des parcours qui transportaient un paramètre returnTo.
Cette partie peut vite devenir chaotique.
Si vous laissez n’importe quelle valeur décider où l’application doit aller ensuite, vous obtenez une navigation à la fois difficile à comprendre et facile à casser.
La règle que j’ai adoptée était donc simple :
- garder des cibles de retour très limitées
- se rabattre sur une vraie route d’onglet quand la cible est absente ou invalide
- ne pas laisser « retourner d’où l’on vient » recréer une autre branche de l’application
Cette partie est moins excitante que le bug des onglets dupliqués, mais elle sert le même objectif :
ramener l’utilisateur dans la branche de navigation existante, pas dans une copie neuve de quelque chose qui a seulement l’air correct.
Ce qui a vraiment résolu le problème
Si je devais résumer tout ça en quelques règles, ce seraient celles-ci :
- ne pas traiter
/(tabs)comme un raccourci générique vers l’accueil - utiliser la route d’onglet exacte voulue, comme
/(tabs)/(home) - raisonner en termes d’« instance d’onglets existante » plutôt que de « une route d’accueil quelconque »
- faire passer les cibles de retour dynamiques par une petite whitelist
- privilégier le retour dans la branche d’onglets actuelle, plutôt que la recréation d’une nouvelle
Pour conclure
L’erreur principale était de ne pas assez bien comprendre le graphe.
Une fois que j’ai accepté que les onglets n’étaient qu’une branche dans un root stack plus large, les règles de navigation sont devenues beaucoup plus simples.
Et pour rendre justice à Expo Router, le correctif n’avait rien d’un contournement bancal.
La partie difficile consistait simplement à être honnête sur la forme réelle du graphe de l’application.
Les onglets n’étaient pas l’application.
Ils étaient un sous-arbre à l’intérieur de l’application.
Dès que j’ai arrêté de naviguer vers « l’accueil » de façon approximative et que j’ai commencé à revenir dans la branche d’onglets exacte qui existait déjà, le problème des onglets dupliqués a disparu.
Si votre application a un graphe mixte, avec un root stack et des onglets, c’est par là que je commencerais.