State Hoisting
Heben Sie den Zustand für wiederverwendbare Composables nach oben.
State Hoisting ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist State Hoisting?
State Hoisting bedeutet, den Zustand nach oben aus einem Composable in dessen aufrufenden Code zu verschieben. Das Composable wird zustandslos: Es empfängt lediglich einen Wert und meldet Änderungen.
Zustandsbehaftet oder zustandslos
Ein zustandsbehaftetes Composable besitzt seinen Zustand mit remember. Ein zustandsloses Composable enthält keinen Zustand, sondern nimmt den Wert als Parameter entgegen und stellt ein Ereignis bereit. Zustandslose Composables lassen sich einfacher wiederverwenden und testen.
Das Muster value + onValueChange
Das standardmäßige Muster für State Hoisting hat zwei Parameter: einen value (den aktuellen Zustand, nach unten übergeben) und ein onValueChange-Lambda (das Ereignis, nach oben übergeben).
@Composable
fun NameField(value: String, onValueChange: (String) -> Unit) {
TextField(value = value, onValueChange = onValueChange)
}Vor dem State Hoisting
Hier besitzt das Composable seinen Zustand selbst. Es funktioniert, aber das übergeordnete Composable hat keinen Zugriff auf den Text und das Composable lässt sich schwieriger wiederverwenden.
@Composable
fun NameField() {
var name by remember { mutableStateOf("") }
TextField(value = name, onValueChange = { name = it })
}Nach dem State Hoisting
Jetzt befindet sich der Zustand im übergeordneten Composable. Das Feld ist zustandslos und wiederverwendbar; das übergeordnete Composable steuert den Wert.
@Composable
fun Parent() {
var name by remember { mutableStateOf("") }
NameField(value = name, onValueChange = { name = it })
}Nach unten und nach oben
Das Muster lautet: Zustand fließt nach unten, Ereignisse fließen nach oben. Der Wert wird als Parameter nach unten übergeben, Änderungen werden über den Callback nach oben weitergeleitet. Dies wird als unidirectional data flow bezeichnet.
Warum State Hoisting?
State Hoisting ermöglicht es mehreren Composables, denselben Zustand zu teilen, dem übergeordneten Composable auf Änderungen zu reagieren und das untergeordnete Composable zu einer reinen Funktion seiner Eingaben zu machen — ideal für Vorschauen und Tests.
Wohin den Zustand verschieben?
Verschieben Sie den Zustand zum niedrigsten gemeinsamen Vorfahren, der ihn benötigt. Wenn nur ein Composable den Zustand verwendet, ist State Hoisting möglicherweise nicht erforderlich. Verschieben Sie ihn nach oben, sobald etwas darüber ihn lesen oder steuern muss.
Ein gemeinsames Beispiel
Hier steuert ein einzelner Zustandswert sowohl ein Feld als auch eine Live-Vorschau — möglich ist das nur, weil der Zustand nach oben verschoben wurde.
@Composable
fun Editor() {
var text by remember { mutableStateOf("") }
Column {
TextField(value = text, onValueChange = { text = it })
Text(text = "Preview: $text")
}
}Zustandslos bedeutet wiederverwendbar
Da ein zustandsloses Composable seinen Wert als Parameter erhält, können Sie es mit Beispieldaten in einer Vorschau anzeigen und überall mit unterschiedlichen Zustandsbesitzern verwenden.
@Preview
@Composable
fun NameFieldPreview() {
NameField(value = "Sample", onValueChange = {})
}Alles zusammenführen
Ein wiederverwendbarer Zähler, bei dem das übergeordnete Composable den Zähler besitzt und die Schaltfläche zustandslos ist.
@Composable
fun CounterButton(count: Int, onIncrement: () -> Unit) {
Button(onClick = onIncrement) {
Text(text = "Count: $count")
}
}
@Composable
fun Screen() {
var count by remember { mutableStateOf(0) }
CounterButton(count = count, onIncrement = { count++ })
}Kurzer Check
Welche zwei Dinge stellt das zustandslose Composable beim State Hoisting typischerweise bereit?
Zusammenfassung
State Hoisting:
- Verschieben Sie den Zustand in den aufrufenden Code und machen Sie das untergeordnete Composable zustandslos.
- Verwenden Sie das Muster
value+onValueChange. - Zustand nach unten, Ereignisse nach oben — unidirektionaler Datenfluss.
- Verschieben Sie den Zustand zum niedrigsten gemeinsamen Vorfahren, der ihn benötigt.
Häufig gestellte Fragen
Ist die Lektion „State Hoisting“ kostenlos?
Ja — der vollständige Text von „State Hoisting“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „State Hoisting“?
Heben Sie den Zustand für wiederverwendbare Composables nach oben. Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Android Academy zu starten?
Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „State Hoisting“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?
Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.