Différence entre mutabelStateOf et rememberUpdatedState dans Jetpack Compose ?

Question

Je suis confus, quelqu'un peut-il m'expliquer la différence entre :

val variable by remember { mutableStateOf() }

y

val variable by rememberUpdatedState()

Lorsque je vérifie le code source de rememberUpdatedStates En fait, je vois : remember { mutableStateOf() }

@Composable
fun <T> rememberUpdatedState(newValue: T): State<T> = remember {
    mutableStateOf(newValue)
}.apply { value = newValue }

Answer 1

La différence entre souvenez-vous de y rememberUpdatedStates son:

souvenez-vous de

Se souvenir de la valeur produite par le calcul. Le calcul ne sera évalué que pendant la composition. La recomposition retournera toujours la valeur produite par la composition.

Lorsque vous utilisez remember, chaque appel consécutif à la recomposition ne renverra que la même valeur qui a été calculée initialement lors du premier appel à remember. Vous pouvez considérer ceci comme un état en lecture seule que vous ne pouvez pas mettre à jour lors d'une référence future alors que la recomposition fera référence à l'évaluation initiale.

---

rememberUpdatedStates

mémorise un mutableStateOf et met à jour sa valeur en newValue à chaque recomposition de l'appel rememberUpdatedState.

rememberUpdatedState doit être utilisé lorsque des paramètres ou des valeurs calculés pendant la composition sont référencés par une expression lambda ou objet à longue durée de vie. La recomposition mettra à jour l'état résultant sans recréer le lambda ou l'objet à longue durée de vie, ce qui permet à cet objet de persister sans avoir à annuler et à réabonner, ou à relancer une opération à longue durée de vie qui peut être coûteuse ou prohibitive à recréer et à relancer.

Ici, on s'attend à ce que votre calcul prenne parfois un certain temps et que le calcul soit considérablement lent. Dans de tels cas, on vous fournit la dernière valeur plutôt que la lambda qui aura un impact à chaque recomposition afin que vous puissiez avoir une référence à la dernière valeur produite par le calcul.

En utilisant cette méthode, vous vous assurez que votre interface utilisateur est mise à jour par chaque recomposition sans recréer les lambdas à longue durée de vie ou relancer les opérations à longue durée de vie que vous pouvez avoir pendant les rappels lambda de la méthode remember.