Die Intuition
Modifier.a().b().c() liest sich, als würde man drei unabhängige
Eigenschaften auf einem Composable setzen, aber das ist nicht, was
tatsächlich passiert.
- Jeder Modifier umschließt alles, was danach in der Kette kommt.
- Die Reihenfolge ändert, was jeder Modifier als seinen Input sieht: verfügbare Größe, Inhalt, Touch-Target.
- Dieselben Modifier in anderer Reihenfolge erzeugen unterschiedliche Pixel und unterschiedliches Verhalten.
Der Input fließt die Kette hinunter: a entscheidet, womit b arbeiten
darf, b entscheidet, was c bekommt, und so weiter. Die Ergebnisse
fließen wieder nach oben: as eigene Größe und Erscheinung hängen davon
ab, was b, c und der Inhalt letztlich sind. Tauscht man a und b,
tauscht man, wer für wen entscheidet.
Klassisches Beispiel: Padding vs. Background
// padding umschließt background: der verfügbare Platz schrumpft zuerst,
// dann malt background innerhalb dessen, was übrig bleibt. Kein Rot im
// Padding-Zwischenraum sichtbar.
Modifier.padding(16.dp).background(Color.Red)
// background umschließt padding: background malt zuerst die volle
// Größe, dann drückt padding den Inhalt lediglich nach innen. Rot
// füllt den gesamten Bereich.
Modifier.background(Color.Red).padding(16.dp)Gleiche Form, dieselben zwei Modifier, andere Reihenfolge, anderes Ergebnis, weil man keine Eigenschaften setzt, sondern Wrapper verschachtelt.
Gleiche Logik, andere Paare
clickable().padding()vs.padding().clickable(): Der Ripple und das Touch-Target haben genau die Größe, die der Node an dem Punkt hatte, an demclickablein die Kette eingefügt wurde. Setzt manclickablevorpadding, ist der Padding-Bereich ebenfalls klickbar; setzt man es danach, ist er es nicht.- Die Zeichenreihenfolge folgt derselben Regel: Die Modifier-Reihenfolge
in der Kette ist auch die Zeichenreihenfolge, weshalb
.background().padding()und.padding().background()sich sowohl im Layout als auch in der Zeichenreihenfolge unterscheiden.
Wo die Reihenfolge keine Rolle spielt
Die Regel lautet „Wrapping-Reihenfolge ändert Verhalten", nicht „Wrapping-Reihenfolge ändert immer das Verhalten." Ein paar Paare sind tatsächlich kommutativ, und es lohnt sich zu wissen, welche, damit man nicht an einer Reihenfolge zweifelt, die nie das Problem war.
clip() + size(). clip() bewegt oder verändert nichts in der
Größe; es ist eine reine Einschränkung der Zeichengrenzen für alles, was
innerhalb davon verschachtelt ist. Es mit size() zu kombinieren ist
ein Fall, in dem die Reihenfolge kaum eine Rolle spielt, da clip() in
beiden Fällen einfach die Größe erbt, die am Ende innerhalb davon landet:
// size außen, clip innen: size zwingt allem, was darin verschachtelt
// ist (einschließlich clip), 100dp auf, also landen clips Grenzen
// ebenfalls bei 100dp.
Modifier.size(100.dp).clip(CircleShape)
// clip außen, size innen: clip hat keine eigene Größe, es gibt
// Constraints einfach unverändert weiter, also erzwingt size
// trotzdem 100dp, und clips Grenzen liegen weiterhin bei 100dp.
Modifier.clip(CircleShape).size(100.dp)Beide erzeugen denselben Kreis. clip() wird nur dann
reihenfolgeabhängig, wenn es mit einem Modifier kombiniert wird, der
selbst etwas zeichnet, wie border() oder background().
Zwei Modifier derselben Art stapeln. padding() verkleinert
Constraints um einen festen Betrag, und Addition ist kommutativ, also
ergeben zwei gestapelte padding()-Aufrufe unabhängig von der
Reihenfolge immer dieselbe Gesamteinrückung:
Modifier.padding(start = 8.dp).padding(top = 4.dp)
Modifier.padding(top = 4.dp).padding(start = 8.dp)
// in beiden Fällen dasselbe Ergebnis: 8dp Einrückung von der
// Startkante, 4dp von obenDieselbe Logik gilt für alpha(): Jeder Aufruf multipliziert die
aktuelle Deckkraft, und Multiplikation ist ebenfalls kommutativ, also
landen alpha(0.5f).alpha(0.8f) und alpha(0.8f).alpha(0.5f) beide bei
0,4 finaler Deckkraft.
Immer wenn das „Wrapping", das ein Modifier vornimmt, nur eine
assoziative/kommutative Operation ist (Einrückungen addieren, Deckkraft
multiplizieren), hört die Reihenfolge auf, eine Rolle zu spielen, genauso
wie 2 + 3 == 3 + 2 in der Callout unten.
Es sind die Modifier, die Größe, Inhalt oder Zeichengrenzen verbrauchen
(background, clip, clickable), bei denen die Reihenfolge
tragend ist.
Das Grundprinzip
Das ist Funktionskomposition: Modifier.a().b() verhält sich wie
a(b(x)). Funktionskomposition ist reihenfolgeabhängig: f(g(x)) ist
meist nicht dasselbe wie g(f(x)), so wie 2 + 3 und 3 + 2 gleich
sind, x / 2 und 2 / x aber nicht.
Äquivalent dazu ist es das Decorator-Pattern: Jeder Decorator umschließt das ihm übergebene Objekt, und die Wrapping-Reihenfolge ändert das Verhalten, weil jede Schicht nur sieht, was innerhalb von ihr liegt, nicht was außerhalb davon liegt.
Anderswo: gleiches Grundprinzip, anderes Framework
- OkHttp-Interceptors: Die Interceptor-Kette läuft in Registrierungsreihenfolge, und jeder Interceptor umschließt den nächsten. Ein Logging-Interceptor, der vor einem Retry-Interceptor platziert ist, sieht nur den ersten Versuch; platziert man ihn danach, sieht er jeden wiederholten Versuch. Derselbe Mechanismus „Wrapper-Reihenfolge ändert, was jede Schicht beobachten kann".
- CSS
transform:transform: translate(50px) rotate(45deg)vs.rotate(45deg) translate(50px)liefert unterschiedliche Ergebnisse, weil jede Transform-Funktion in dem Koordinatenraum arbeitet, der von der vorherigen zurückgelassen wurde. - SwiftUI View-Modifier: die naheliegendste Analogie von allen.
Jeder Modifier gibt einen neuen umschließenden
View-Typ zurück, also ist.padding().background()vs..background().padding()genau die gleiche Falle, und.clipShape()vor bzw. nach.background()/.overlay()platziert reproduziert denselben Bug mit abgerundeten Ecken. - Flutter-Widgets: noch wortwörtlicher, da Flutter den Wrapper-Baum
direkt ausschreibt, ohne eine Chain-Syntax darüber.
ClipRRect(child: Container(color: ...))vs.Container(color: ..., child: ClipRRect(...))ist das Clip/Background-Beispiel, nur als verschachtelte Konstruktoren statt verketteter Aufrufe geschrieben. - WPF/XAML:
<Border Padding="16"><Border Background="Red"/></Border>vs. der umgekehrten Verschachtelung verhält sich genauso, weil XAML-Elemente buchstäblich verschachtelte Objekte sind, derselbe Mechanismus wie bei CSS, nur als Markup geschrieben.
Wo das tatsächlich zu Problemen führt
Das sind keine erfundenen Beispiele, es sind Bug-Reports, die tatsächlich eingereicht werden.
Abgerundeter Card-Background sieht an den Ecken eckig aus
Der übliche Übeltäter: Die einfache background(color)-Überladung malt
nur ein Rechteck, sie weiß nichts von Formen. Sie kommt nur gerundet
heraus, wenn sie innerhalb eines clip() verschachtelt ist:
// clip außen, background innen: das quadratische Paint ist innerhalb
// von clip verschachtelt, wird also auf die abgerundete Form
// zugeschnitten. Ecken passen zusammen.
Modifier.clip(RoundedCornerShape(12.dp))
.background(Color.Gray)
// background außen, clip innen: background malt sein volles Quadrat,
// bevor clip (darin verschachtelt) überhaupt läuft, also werden die
// Ecken nie zugeschnitten, obwohl clip direkt in der Kette steht.
Modifier.background(Color.Gray)
.clip(RoundedCornerShape(12.dp))(border(width, color, shape) hat dieses Problem nicht: Es nimmt eine
explizite Form entgegen und zeichnet seinen Strich immer entlang dieser,
sodass die Clip-Reihenfolge es nicht beeinflusst. Es sind speziell die
formlosen Modifier wie das einfache background(color), oder
Rohinhalte wie ein Image, die darauf angewiesen sind, dass ein
externes clip() korrekt positioniert ist.)
Ripple läuft bei einer abgerundeten clickable-Card quadratisch über
Gleiche Ursache: Der Ripple von clickable() wird als Teil seines
eigenen Nodes gezeichnet, also wird er nur zugeschnitten, wenn clip()
sich um `clickable()* herum befindet, nicht umgekehrt:
// clip außen, clickable innen: Ripple ist innerhalb von clip
// verschachtelt, wird auf die abgerundete Form zugeschnitten.
Modifier.clip(RoundedCornerShape(12.dp)).clickable { }
// clickable außen, clip innen: der Ripple zeichnet sich am eigenen
// Node von clickable, das in der Kette außerhalb von clip liegt,
// also ignoriert er die abgerundeten Ecken vollständig.
Modifier.clickable { }.clip(RoundedCornerShape(12.dp))padding() + border()-Reihenfolge ändert, wo der Border sitzt
Nicht nur der Inhalt:
// border außen, padding innen: border zeichnet an den vollen
// fillMaxWidth-Grenzen; padding, darin verschachtelt, drückt nur den
// Inhalt nach innen. Border sitzt bündig an der Kante seines
// Containers.
Modifier.fillMaxWidth().border(1.dp, Color.Gray).padding(16.dp)
// padding außen, border innen: padding verkleinert den Platz, bevor
// border überhaupt läuft, also sind borders eigene Grenzen bereits
// eingerückt. Border sitzt 16dp von der Kante entfernt.
Modifier.fillMaxWidth().padding(16.dp).border(1.dp, Color.Gray)Mentales Modell, das man wirklich anwenden sollte
Hört auf zu fragen „welche Eigenschaften setze ich". Fragt statt dessen: „Was sieht dieser Modifier als seinen Input: Größe, Inhalt, Touch-Target, basierend darauf, was links von ihm in der Kette steht?" Diese Frage reicht aus, um das Ergebnis jedes Mal vorherzusagen.



