0Pricing
Kotlin Academy · Leçon

let, also et run avec des récepteurs nullables

Utilisez les fonctions de portée pour n’exécuter du code que lorsqu’une valeur n’est pas nulle.

let, also et run avec des récepteurs nullables est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Les fonctions de portée et les valeurs nullables

Les fonctions de portée let, also et run s’associent parfaitement à l’appel sûr ?. pour exécuter un bloc uniquement lorsque le récepteur n’est pas null.

let avec un appel sûr

obj?.let { ... } exécute le bloc uniquement si obj n’est pas null ; à l’intérieur, it désigne la valeur non nullable.

fun main() {
    val name: String? = "Kotlin"
    name?.let {
        println("Length: ${it.length}")
        println("Upper: ${it.uppercase()}")
    }
}

let ignore le bloc lorsque la valeur est null

Si le récepteur est null, l’intégralité du bloc let est ignorée.

fun main() {
    val name: String? = null
    val result = name?.let {
        println("never printed")
        it.length
    }
    println(result) // null
}

let renvoie une valeur

let renvoie la dernière expression de son bloc, ce qui permet de le chaîner avec l’opérateur Elvis pour définir des valeurs par défaut.

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

also pour les effets de bord

also exécute un bloc pour ses effets de bord et renvoie le récepteur d’origine, ce qui est idéal pour la journalisation au sein d’une chaîne.

fun main() {
    val name: String? = "Alice"
    val len = name?.also { println("Processing: $it") }?.length
    println("len = $len")
}

also préserve la valeur

Contrairement à let, also renvoie le récepteur inchangé. Utilisez-le lorsque vous souhaitez observer une valeur sans la transformer.

fun main() {
    val items: List<Int>? = listOf(1, 2, 3)
    items?.also { println("Got list of size ${it.size}") }
           ?.forEach { println(it) }
}

run avec un appel sûr

obj?.run { ... } exécute le bloc avec this associé au récepteur. Utilisez-le lorsque vous souhaitez accéder aux membres sans le préfixe it..

fun main() {
    val name: String? = "Kotlin"
    val info = name?.run {
        "len=$length upper=${uppercase()}"
    }
    println(info)
}

let ou run

let utilise it (l’argument de la lambda) ; run utilise this (le récepteur). Choisissez la forme la plus lisible.

class User(val name: String, val age: Int)
fun main() {
    val user: User? = User("Ada", 35)
    user?.let { "${it.name} age ${it.age}" }.also(::println)
    user?.run { "$name age $age" }.also(::println)
}

Chaîner plusieurs portées

Chaînez des fonctions de portée dans une chaîne de traitement pour effectuer une transformation étape par étape et assurer la journalisation.

fun main() {
    val raw: String? = "  hello  "
    val result = raw
        ?.also { println("raw: '$it'") }
        ?.let { it.trim() }
        ?.also { println("trimmed: '$it'") }
        ?.uppercase()
    println(result) // HELLO
}

let avec takeIf

Combinez takeIf (filtrage) avec let pour exécuter une action en fonction d’un prédicat.

fun main() {
    val name: String? = "Kotlin"
    name?.takeIf { it.length > 3 }
        ?.let { println("Long name: $it") }
}

Anti-modèle&nbsp;: if imbriqués

Avant les fonctions de portée :

fun main() {
    val name: String? = "Alice"
    // OLD WAY:
    if (name != null) {
        val upper = name.uppercase()
        println(upper)
    }
    // NEW WAY:
    name?.let { println(it.uppercase()) }
}

Vérification rapide

Quelle fonction de portée renvoie le récepteur inchangé et sert principalement à produire des effets de bord ?

Récapitulatif

Combinez ?. avec let (le bloc renvoie une valeur et utilise it), run (le bloc renvoie une valeur et utilise this) ou also (renvoie le récepteur pour produire des effets de bord). Toutes ignorent l’exécution si le récepteur est null.

Questions Fréquemment Posées

La leçon « let, also et run avec des récepteurs nullables » est-elle gratuite ?

Oui — le texte complet de « let, also et run avec des récepteurs nullables » 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, also et run avec des récepteurs nullables » ?

Utilisez les fonctions de portée pour n’exécuter du code que lorsqu’une valeur n’est pas nulle. 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 3 sur 4.

Combien de temps prend la leçon « let, also et run avec des récepteurs nullables » ?

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

  1. Types nullables et modificateur ?
  2. Appel sécurisé ?. et Elvis ?: en pratique
  3. let, also et run avec des récepteurs nullables
  4. Opérateur !! : quand et pourquoi l’éviter
← Retour à Kotlin Academy