Kotlin Academy · Leçon

let et run : transformer et définir une portée

Utilisez let pour des transformations sûres vis-à-vis de null et run pour des calculs locaux.

Leçon 2 sur 413 étapes

let et run : transformer et définir une portée est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

let et run

let utilise it comme récepteur ; run utilise this. Les deux renvoient la dernière expression de la lambda. Choisissez selon que vous préférez des références explicites.

Notions de base de let

let transmet le récepteur à la lambda sous le nom it. C'est utile pour transformer une valeur ou limiter la portée d'une variable.

fun main() {
    val length = "Kotlin".let { it.length }
    println(length) // 6
}

let avec une valeur nullable

Idiomatique : obj?.let { ... } exécute le bloc uniquement lorsque obj n'est pas nul.

fun main() {
    val name: String? = "Ada"
    val upper = name?.let { it.uppercase() } ?: "(unknown)"
    println(upper) // ADA
}

Transformer avec let

Utilisez let pour convertir une valeur tout en gardant la chaîne lisible.

fun main() {
    val numStr = "42"
    val doubled = numStr.let { it.toInt() }.let { it * 2 }
    println(doubled) // 84
}

Limiter la portée avec let

Limitez la visibilité d'une variable à un petit bloc — une façon claire d'éviter de polluer l'espace de noms.

fun main() {
    val username = readUserConfig().let { config ->
        config.uppercase()
    }
    println(username)
}
fun readUserConfig() = "ada"

Notions de base de run

run fonctionne comme let, mais utilise this au lieu de it. C'est utile lorsque vous souhaitez appeler plusieurs membres du récepteur.

class Rect(val w: Int, val h: Int) {
    fun area() = w * h
    fun perimeter() = 2 * (w + h)
}
fun main() {
    val description = Rect(3, 4).run {
        "area=${area()}, perimeter=${perimeter()}"
    }
    println(description)
}

run comme bloc autonome

run { ... } (sans récepteur) exécute le bloc et renvoie son résultat — utile pour regrouper des calculs.

fun main() {
    val result = run {
        val a = 10
        val b = 20
        a + b
    }
    println(result) // 30
}

let et run selon le style de récepteur

Si le corps de la lambda accède à de nombreux membres du récepteur, run évite les préfixes it.. S'il utilise le récepteur seulement une ou deux fois, let reste lisible.

class User(val name: String, val email: String, val age: Int)
fun main() {
    val user = User("Ada", "ada@x.io", 35)
    // run: this-style
    val s1 = user.run { "$name <$email> age $age" }
    // let: it-style
    val s2 = user.let { "${it.name} <${it.email}> age ${it.age}" }
    println(s1); println(s2)
}

Combiner let et Elvis

La combinaison de ?.let { ... } et de ?: constitue un modèle puissant de chaîne de traitement sûre vis-à-vis des valeurs nulles.

fun main() {
    val raw: String? = "  hello  "
    val cleaned = raw?.let { it.trim().uppercase() } ?: "(empty)"
    println(cleaned) // HELLO
}

run avec configuration et résultat

Combinez la préparation (via this) et une valeur renvoyée dans un seul bloc.

class Connection {
    var host: String = ""
    fun connect() = "connected to $host"
}
fun main() {
    val status = Connection().run {
        host = "localhost"
        connect()
    }
    println(status)
}

Anti-modèle : utiliser let à outrance

N'encapsulez pas des vérifications simples de nullité dans let lorsqu'un if est plus clair. Utilisez les fonctions de portée uniquement lorsqu'elles sont réellement utiles.

fun main() {
    val name: String? = "Ada"
    // OK
    name?.let { println(it.length) }
    // Equivalent and clearer for trivial cases:
    if (name != null) println(name.length)
}

Vérification rapide

Quelle fonction de portée transmet le récepteur à la lambda sous le nom it AND renvoie le résultat de la lambda ?

Réponds-y dans la leçon interactive

Récapitulatif

let utilise it et renvoie le résultat de la lambda — idéal pour les transformations sûres vis-à-vis des valeurs nulles et pour limiter la portée. run utilise this et renvoie le résultat de la lambda — idéal lorsque vous appelez de nombreux membres du récepteur. Les deux conviennent parfaitement au code fondé sur des expressions.

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: 51
Leçons: 203

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « let et run : transformer et définir une portée » est-elle gratuite ?

Oui — le texte complet de « let et run : transformer et définir une portée » 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « let et run : transformer et définir une portée » ?

Utilisez let pour des transformations sûres vis-à-vis de null et run pour des calculs locaux. Tu pratiques Kotlin 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 Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin 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 2 sur 4.

Combien de temps prend la leçon « let et run : transformer et définir une portée » ?

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 Kotlin Academy ?

Oui. Chaque leçon Kotlin 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

apply et with : configurer et renvoyer
let et run : transformer et définir une portée
also : effets secondaires sans modifier le récepteur
Choisir la bonne fonction de portée : guide de décision

← Retour à Kotlin Academy