Plusieurs variables dans let en Kotlin : 3 façons élégantes

Plusieurs variables dans let : un problème que vous n'aviez pas remarqué

Avez-vous déjà écrit du code en Kotlin et soudain réalisé : "Je dois traiter deux variables nullable à la fois" ? Vous vous tournez vers votre let préféré, mais... stop. let ne fonctionne qu'avec une seule variable. Que faire si vous en avez deux, trois ou plus ?

Cette question est l'une des plus populaires sur Stack Overflow concernant Kotlin. Des milliers de développeurs butent sur cette tâche apparemment simple. Et aujourd'hui, nous allons une fois pour toutes comprendre comment la résoudre de manière élégante et correcte.

Dans cet article, nous ne donnerons pas simplement des exemples secs. Nous comparerons 3 approches, discuterons de leurs avantages, inconvénients et best practices. Vous apprendrez quelle méthode choisir en fonction de la situation, et vous arrêterez d'écrire des let imbriqués disgracieux.

Pourquoi le problème "Multiple variable let" est-il si populaire ?

Kotlin est un langage qui adore la null safety. Les fonctions de portée (scope functions) — let, run, with, apply, also — sont notre arme secrète pour travailler en toute sécurité avec les types nullable. Mais elles ont une limitation : chaque fonction est conçue pour un seul objet récepteur.

Imaginez la situation : vous recevez de l'API deux champs nullable — le nom d'utilisateur et son email. Vous devez vérifier que les deux ne sont pas null, et ensuite seulement effectuer une action (par exemple, envoyer un email de bienvenue).

Les débutants écrivent souvent ainsi :

val name: String? = getUserName()val email: String? = getUserEmail()

if (name != null && email != null) {    sendWelcomeEmail(name, email)}

Cela fonctionne, mais ce n'est pas la façon Kotlin. Nous pouvons rendre le code plus concis et plus sûr. Voyons comment.

Approche 1 : let imbriqués — simple, mais pas joli

La façon la plus évidente est d'imbriquer un let dans un autre. C'est la première chose qui vient à l'esprit :

val name: String? = getUserName()val email: String? = getUserEmail()

name?.let { safeName ->    email?.let { safeEmail ->        sendWelcomeEmail(safeName, safeEmail)    }}

Avantages :

• Fonctionne "prêt à l'emploi", ne nécessite pas de fonctions supplémentaires
• Le code se lit séquentiellement

Inconvénients :

• Lorsque le nombre de variables augmente (3, 4 et plus), le code se transforme en "pyramide de l'horreur"
• Difficile à lire et à maintenir
• Chaque niveau d'imbrication ajoute une indentation supplémentaire

Cette approche ne convient que pour deux variables. Pour trois ou plus, cherchez une alternative.

Approche 2 : Utilisation de Pair, Triple et data class

Kotlin fournit les classes intégrées Pair et Triple. L'idée est de combiner les variables nullable en un seul objet, puis de le vérifier via let.

val name: String? = getUserName()val email: String? = getUserEmail()

val pair = name?.let { n ->    email?.let { e -> n to e }}

pair?.let { (safeName, safeEmail) ->    sendWelcomeEmail(safeName, safeEmail)}

Pour trois variables, nous utilisons Triple :

val name: String? = getUserName()val email: String? = getUserEmail()val age: Int? = getUserAge()

val triple = name?.let { n ->    email?.let { e ->        age?.let { a -> Triple(n, e, a) }    }}

triple?.let { (safeName, safeEmail, safeAge) ->    sendWelcomeEmail(safeName, safeEmail, safeAge)}

Avantages :

• Pas d'imbrication profonde dans l'appel final
• La déstructuration rend le code propre

Inconvénients :

• L'imbrication interne (lors de la création de Pair/Triple) est toujours présente
• Triple est le maximum pour la bibliothèque standard. Pour 4 variables ou plus, il faut