Recomposed
Modifier

L'ordre des modifiers compte : c'est une chaîne de wrappers, pas un sac de propriétés

Oct 4, 2026 · 6 min read

L'ordre des modifiers compte : c'est une chaîne de wrappers, pas un sac de propriétés

L'intuition

Modifier.a().b().c() se lit comme si on définissait trois propriétés indépendantes sur un composable, mais ce n'est pas ce qui se passe.

  • Chaque modifier englobe tout ce qui vient après lui dans la chaîne.
  • L'ordre change ce que chaque modifier perçoit comme son entrée : taille disponible, contenu, zone tactile.
  • Les mêmes modifiers dans un ordre différent produisent des pixels et un comportement différents.

L'entrée s'écoule vers le bas de la chaîne : a décide de ce avec quoi b peut travailler, b décide de ce que c obtient, et ainsi de suite. Les résultats remontent ensuite : la taille et l'apparence propres de a dépendent de ce que deviennent finalement b, c et le contenu. Échangez a et b, et vous échangez qui décide pour qui.

Exemple classique : padding vs background

// padding englobe background : l'espace disponible se réduit d'abord, puis
// background peint dans ce qui reste. Aucun rouge visible dans l'espace du padding.
Modifier.padding(16.dp).background(Color.Red)
 
// background englobe padding : background peint d'abord la taille complète, puis
// padding ne fait que repousser le contenu vers l'intérieur. Le rouge remplit toute la zone.
Modifier.background(Color.Red).padding(16.dp)

Même forme, mêmes deux modifiers, ordre différent, résultat différent, car on ne définit pas des propriétés, on imbrique des wrappers.

FIG. 01
Mêmes deux modifiers, ordre inversé : padding-puis-background laisse un espace (gauche), background-puis-padding le remplit (droite).

Même logique, autres paires

  • clickable().padding() vs padding().clickable() : le ripple et la zone tactile correspondent à la taille qu'avait le nœud au moment où clickable a été inséré dans la chaîne. Placez clickable avant padding et la zone de padding devient cliquable aussi ; placez-le après et elle ne l'est pas.
  • L'ordre de dessin suit la même règle : l'ordre des modifiers dans la chaîne est aussi l'ordre de dessin, c'est pourquoi .background().padding() et .padding().background() ont un rendu différent, à la fois en disposition et en ordre de peinture.

Où l'ordre n'a pas d'importance

La règle est « l'ordre d'enveloppement change le comportement », pas « l'ordre d'enveloppement change toujours le comportement ». Quelques paires commutent réellement, et il est utile de savoir lesquelles pour ne pas remettre en question un ordre qui n'a jamais été le problème.

clip() + size(). clip() ne déplace ni ne redimensionne rien ; c'est une pure restriction des limites de dessin sur ce qui est imbriqué à l'intérieur. L'associer à size() est un cas où l'ordre n'a pas vraiment d'importance, puisque clip() hérite simplement de la taille qui se retrouve à l'intérieur dans les deux cas :

// size à l'extérieur, clip à l'intérieur : size impose 100dp à tout ce qui est
// imbriqué à l'intérieur (y compris clip), donc les limites de clip finissent aussi à 100dp.
Modifier.size(100.dp).clip(CircleShape)
 
// clip à l'extérieur, size à l'intérieur : clip n'a pas de taille propre, il
// laisse simplement passer les contraintes intactes, donc size impose
// quand même 100dp, et les limites de clip restent 100dp.
Modifier.clip(CircleShape).size(100.dp)

Les deux produisent le même cercle. clip() ne devient sensible à l'ordre que lorsqu'il est associé à un modifier qui dessine quelque chose lui-même, comme border() ou background().

Empiler deux modifiers du même type. padding() réduit les contraintes d'une quantité fixe, et l'addition commute, donc deux appels padding() empilés aboutissent toujours au même décalage total quel que soit l'ordre :

Modifier.padding(start = 8.dp).padding(top = 4.dp)
Modifier.padding(top = 4.dp).padding(start = 8.dp)
// même résultat dans les deux cas : 8dp de marge depuis le bord de départ, 4dp depuis le haut

Même logique pour alpha() : chaque appel multiplie l'opacité actuelle, et la multiplication commute aussi, donc alpha(0.5f).alpha(0.8f) et alpha(0.8f).alpha(0.5f) aboutissent tous les deux à une opacité finale de 0.4.

Chaque fois que l'« enveloppement » effectué par un modifier n'est qu'une opération associative/commutative (addition de marges, multiplication d'opacité), l'ordre cesse d'avoir de l'importance, de la même manière que 2 + 3 == 3 + 2 dans le Callout ci-dessous.

Ce sont les modifiers qui consomment la taille, le contenu ou les limites de dessin (background, clip, clickable) pour lesquels l'ordre est déterminant.

Le fondamental

C'est de la composition de fonctions : Modifier.a().b() se comporte comme a(b(x)). La composition de fonctions dépend de l'ordre : f(g(x)) n'est généralement pas identique à g(f(x)), de la même manière que 2 + 3 et 3 + 2 sont identiques mais que x / 2 et 2 / x ne le sont pas.

De manière équivalente, c'est le pattern decorator : chaque decorator enveloppe l'objet qu'on lui transmet, et l'ordre d'enveloppement change le comportement parce que chaque couche ne voit que ce qui est à l'intérieur d'elle, pas ce qui est à l'extérieur.

Ailleurs : même fondamental, framework différent

  • Les intercepteurs OkHttp : la chaîne d'intercepteurs s'exécute dans l'ordre d'enregistrement, et chaque intercepteur enveloppe le suivant. Un intercepteur de logging placé avant un intercepteur de retry ne voit que la première tentative ; placé après, il voit chaque tentative rejouée. Le même mécanisme « l'ordre des wrappers change ce que chaque couche peut observer ».
  • transform en CSS : transform: translate(50px) rotate(45deg) vs rotate(45deg) translate(50px) donne des résultats différents, parce que chaque fonction de transformation opère dans l'espace de coordonnées laissé par celle qui la précède.
  • Les view modifiers de SwiftUI : l'analogue le plus proche de tous. Chaque modifier retourne un nouveau type View enveloppant, donc .padding().background() vs .background().padding() est le piège identique, et .clipShape() placé avant ou après .background()/.overlay() reproduit le même bug de coins arrondis.
  • Les widgets Flutter : encore plus littéral, puisque Flutter écrit directement l'arbre de wrappers sans syntaxe de chaînage par-dessus. ClipRRect(child: Container(color: ...)) vs Container(color: ..., child: ClipRRect(...)) est l'exemple clip/background, simplement formulé comme des constructeurs imbriqués plutôt que des appels chaînés.
  • WPF/XAML : <Border Padding="16"><Border Background="Red"/></Border> vs l'imbrication inversée se comporte de la même manière, car les éléments XAML sont littéralement des objets imbriqués, même mécanisme que CSS, simplement écrit comme du markup.

Où cela piège vraiment les gens

Ce ne sont pas des exemples inventés, ce sont des rapports de bugs que les gens déposent réellement.

Le fond d'une carte arrondie apparaît carré aux coins

Le coupable habituel : la surcharge simple background(color) ne fait que peindre un rectangle, elle n'a aucune idée des formes. Elle ne sort arrondie que si elle est imbriquée à l'intérieur d'un clip() :

// clip à l'extérieur, background à l'intérieur : la peinture carrée est imbriquée
// à l'intérieur de clip, donc elle est découpée selon la forme arrondie. Les coins correspondent.
Modifier.clip(RoundedCornerShape(12.dp))
    .background(Color.Gray)
 
// background à l'extérieur, clip à l'intérieur : background peint son carré complet
// avant que clip (imbriqué à l'intérieur) ne s'exécute, donc les coins ne sont jamais
// découpés, même si clip est bien présent dans la chaîne.
Modifier.background(Color.Gray)
    .clip(RoundedCornerShape(12.dp))
FIG. 02
Mêmes deux modifiers, ordre inversé : clip-puis-background suit les coins arrondis (gauche), background-puis-clip dépasse les coins carrés au-delà du clip arrondi (droite).

(border(width, color, shape) n'a pas ce problème : il prend une forme explicite et dessine toujours son trait le long de celle-ci, donc l'ordre du clip ne l'affecte pas. Ce sont spécifiquement les modifiers sans forme comme background(color) brut, ou un contenu brut comme une Image, qui dépendent du bon positionnement d'un clip() externe.)

Le ripple dépasse d'une carte clickable arrondie sous forme carrée

Même cause profonde : le ripple de clickable() est dessiné comme faisant partie de son propre nœud, donc il n'est découpé que si clip() englobe autour de clickable(), pas l'inverse :

// clip à l'extérieur, clickable à l'intérieur : le ripple est imbriqué à l'intérieur de
// clip, il est donc découpé selon la forme arrondie.
Modifier.clip(RoundedCornerShape(12.dp)).clickable { }
 
// clickable à l'extérieur, clip à l'intérieur : le ripple se dessine au niveau du
// propre nœud de clickable, qui se trouve à l'extérieur de clip dans la chaîne, donc il
// ignore complètement les coins arrondis.
Modifier.clickable { }.clip(RoundedCornerShape(12.dp))

L'ordre de padding() + border() change l'emplacement de la bordure

Pas seulement le contenu :

// border à l'extérieur, padding à l'intérieur : border se dessine sur les limites
// complètes de fillMaxWidth ; padding, imbriqué à l'intérieur, ne fait que repousser
// le contenu vers l'intérieur. La bordure se trouve à fleur du bord de son conteneur.
Modifier.fillMaxWidth().border(1.dp, Color.Gray).padding(16.dp)
 
// padding à l'extérieur, border à l'intérieur : padding réduit l'espace avant même
// que border ne s'exécute, donc les propres limites de border sont déjà réduites.
// La bordure se trouve à 16dp du bord.
Modifier.fillMaxWidth().padding(16.dp).border(1.dp, Color.Gray)

Le modèle mental à utiliser réellement

Arrêtez de demander « quelles propriétés suis-je en train de définir ». Demandez plutôt : « qu'est-ce que ce modifier perçoit comme son entrée : taille, contenu, zone tactile, en fonction de ce qui se trouve à sa gauche dans la chaîne ? » Cette question suffit à prédire le résultat à chaque fois.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail