Android Academy · Leçon

État avec remember et mutableStateOf

Conservez l'état de l'interface dans les composables.

Leçon 1 sur 413 étapes

État avec remember et mutableStateOf est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Qu’est-ce que l’état ?

L’état est toute valeur susceptible de changer au fil du temps et à laquelle l’interface utilisateur doit réagir : un compteur, le contenu d’un champ de texte ou l’état activé d’une case à cocher. Lorsque l’état change, Compose redessine l’interface.

mutableStateOf

mutableStateOf crée une valeur observable. Lorsque vous lui attribuez une valeur, Compose sait qu’il doit réexécuter toute fonction composable qui l’a lue.

val count = mutableStateOf(0)
// read with count.value, write with count.value = 1

Pourquoi utiliser remember ?

Les fonctions composables peuvent être exécutées de nombreuses fois (recomposition). Si vous créez l’état à chaque exécution, il est réinitialisé à chaque fois. remember indique à Compose de conserver la valeur entre les recompositions.

val count = remember { mutableStateOf(0) }

Le délégué by

Lire et écrire .value partout rend le code verbeux. Le délégué de propriété Kotlin by vous permet de traiter l’état comme une variable normale.

var count by remember { mutableStateOf(0) }
// now use count directly, no .value

Importations nécessaires

Pour utiliser le délégué by, vous importez les fonctions auxiliaires d’accès en lecture et en écriture. Android Studio les ajoute automatiquement.

import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

Une fonction composable de compteur

Voici un compteur fonctionnel. Appuyer sur le bouton incrémente count, et le Text se met automatiquement à jour.

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) {
        Text(text = "Count: $count")
    }
}

La lecture déclenche la mise à jour

Voici le point essentiel : Text lit count. Compose enregistre cette lecture. Ainsi, lorsque count change, seule cette partie est recomposée et affiche la nouvelle valeur.

L’état peut contenir n’importe quel type

L’état ne sert pas uniquement aux nombres. Vous pouvez y stocker un String, un Boolean, une liste ou votre propre classe de données.

var name by remember { mutableStateOf("") }
var isOn by remember { mutableStateOf(false) }

TextField avec un état

Un champ de texte modifiable a besoin de l’état correspondant à sa valeur actuelle ainsi que d’un rappel pour le mettre à jour.

var text by remember { mutableStateOf("") }
TextField(
    value = text,
    onValueChange = { text = it }
)

L’état est local

L’état créé avec remember vit à l’intérieur de la fonction composable. Deux appels à Counter() possèdent chacun leur propre compteur indépendant.

Exemple complet

Un écran de compteur complet qui regroupe tous les éléments de cette leçon.

@Composable
fun CounterScreen() {
    var count by remember { mutableStateOf(0) }
    Column {
        Text(text = "You tapped $count times")
        Button(onClick = { count++ }) {
            Text(text = "Tap")
        }
    }
}

Vérification rapide

Pourquoi encapsulons-nous mutableStateOf dans remember ?

Réponds-y dans la leçon interactive

Récapitulatif

Principes de base de l’état :

mutableStateOf crée une valeur observable.
remember la conserve entre les recompositions.
by permet d’éviter .value.
Lire l’état abonne une fonction composable à ses changements.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 36
Leçons: 152

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « État avec remember et mutableStateOf » est-elle gratuite ?

Oui — le texte complet de « État avec remember et mutableStateOf » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « État avec remember et mutableStateOf » ?

Conservez l'état de l'interface dans les composables. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « État avec remember et mutableStateOf » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy