0Pricing
Kotlin Academy · Leçon

Choisir la bonne fonction de portée : guide de décision

Sélectionnez la fonction de portée appropriée selon le récepteur, le type de retour et l’intention.

Choisir la bonne fonction de portée : guide de décision est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Cinq fonctions, deux axes

Les fonctions de portée de Kotlin varient selon deux axes : le style du récepteur (this ou it) et la valeur renvoyée (le récepteur ou le résultat de la lambda). Choisissez selon l'intention.

La matrice de décision

apply : this / récepteur. also : it / récepteur. run : this / lambda. let : it / lambda. with : this / lambda (sans récepteur via un point).

apply : configurer et renvoyer

Utilisez apply pour configurer un objet dans une chaîne de style générateur.

class Config {
    var host: String = ""
    var port: Int = 0
}
fun main() {
    val cfg = Config().apply {
        host = "localhost"
        port = 8080
    }
    println("${cfg.host}:${cfg.port}")
}

also : effets secondaires

Utilisez also pour journaliser, valider ou déclencher un effet secondaire tout en transmettant le récepteur.

fun main() {
    val items = listOf(1, 2, 3, 4)
        .also { println("got ${it.size} items") }
        .filter { it % 2 == 0 }
    println(items)
}

let : transformer et assurer la sécurité vis-à-vis des valeurs nulles

Utilisez let pour les transformations sûres vis-à-vis des valeurs nulles ou pour limiter la portée d'une variable.

fun main() {
    val name: String? = "Ada"
    val length = name?.let { it.length } ?: 0
    println(length)
}

run : accéder à plusieurs membres avec un résultat

Utilisez run lorsque vous calculez un résultat à partir de plusieurs membres du récepteur — cela évite les préfixes it..

class User(val name: String, val age: Int)
fun main() {
    val description = User("Ada", 35).run {
        "Name: $name, Age: $age"
    }
    println(description)
}

with : regrouper des opérations sur un objet existant

Utilisez with(obj) { ... } lorsque vous ne contrôlez pas le point d'appel (pas de chaîne avec point), mais que vous souhaitez regrouper des opérations en utilisant this.

class Builder {
    val parts = mutableListOf<String>()
    fun add(s: String) { parts.add(s) }
    fun build(): String = parts.joinToString("-")
}
fun main() {
    val b = Builder()
    val result = with(b) {
        add("hello")
        add("kotlin")
        build()
    }
    println(result) // hello-kotlin
}

Choisir selon l'intention

Demandez-vous : (1) Ai-je besoin de récupérer le récepteur ou d'obtenir un résultat dérivé ? (2) Est-ce que je préfère this ou it ? Les réponses déterminent la fonction à utiliser.

class Box { var w = 0; var h = 0; fun area() = w * h }
fun main() {
    // Configure and return Box -> apply
    val box = Box().apply { w = 3; h = 4 }
    // Compute area from box -> let or run
    val area = box.let { it.area() }
    // Side effect, keep box -> also
    val sameBox = box.also { println("area=${it.area()}") }
    println("$box / $area / $sameBox")
}

Comparaison : apply et also

Les deux renvoient le récepteur. apply utilise this (pratique pour définir des champs). also utilise it (pratique pour référencer explicitement le récepteur, souvent dans des effets secondaires).

class Item { var name = "" }
fun main() {
    val a = Item().apply { name = "apply" } // implicit this
    val b = Item().also { it.name = "also" } // explicit it
    println("${a.name} / ${b.name}")
}

Comparaison : let et run

Les deux renvoient le résultat de la lambda. let utilise it (pratique pour les transformations simples et la sécurité vis-à-vis des valeurs nulles). run utilise this (pratique lorsque vous appelez de nombreux membres).

class Calculator(val a: Int, val b: Int) {
    fun sum() = a + b
    fun product() = a * b
}
fun main() {
    val calc = Calculator(3, 4)
    val s = calc.let { it.sum() }                  // simple
    val combo = calc.run { "sum=${sum()} product=${product()}" } // multi-member
    println("$s / $combo")
}

Chaîne de traitement pratique

Dans un cas réel, une chaîne utilise souvent plusieurs fonctions de portée ensemble.

class Request(var url: String = "", var headers: Map<String, String> = emptyMap())
fun main() {
    val response = Request()
        .apply {
            url = "https://api.example.com"
            headers = mapOf("Accept" to "json")
        }
        .also { println("request: ${it.url}") }
        .let { req -> "GET ${req.url}" }
    println(response)
}

Aide-mémoire

Une référence rapide pour choisir le bon outil.

// apply: this, returns receiver — configure object
// also: it, returns receiver — side effects in chain
// let: it, returns lambda result — transform / null-safety
// run: this, returns lambda result — multi-member compute
// with: this, returns lambda result — group operations on existing obj
fun main() { println("Scope functions: pick by receiver style + return value") }

Vérification rapide

Quelle fonction de portée utilise this comme récepteur AND renvoie le récepteur lui-même ?

Récapitulatif

Choisissez la fonction de portée selon l'intention : apply (configuration + renvoyer l'objet lui-même), also (effet secondaire + renvoyer l'objet lui-même), let (transformer avec it), run (transformer avec this), with (regrouper des opérations sur un objet existant). Deux axes — le style du récepteur et la valeur renvoyée — déterminent le bon choix.

Questions Fréquemment Posées

La leçon « Choisir la bonne fonction de portée : guide de décision » est-elle gratuite ?

Oui — le texte complet de « Choisir la bonne fonction de portée : guide de décision » 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 « Choisir la bonne fonction de portée : guide de décision » ?

Sélectionnez la fonction de portée appropriée selon le récepteur, le type de retour et l’intention. 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 4 sur 4.

Combien de temps prend la leçon « Choisir la bonne fonction de portée : guide de décision » ?

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. apply et with : configurer et renvoyer
  2. let et run : transformer et définir une portée
  3. also : effets secondaires sans modifier le récepteur
  4. Choisir la bonne fonction de portée : guide de décision
← Retour à Kotlin Academy