0Pricing
Kotlin Academy · Lezione

Scegliere la funzione di ambito corretta: guida decisionale

Selezioni la funzione di ambito corretta in base al receiver, al tipo restituito e all'obiettivo.

Scegliere la funzione di ambito corretta: guida decisionale è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Cinque funzioni, due assi

Le funzioni di ambito di Kotlin variano lungo due assi: stile del ricevitore (this o it) e valore restituito (ricevitore o risultato della lambda). Scelga in base all'intento.

La matrice decisionale

apply: this / ricevitore. also: it / ricevitore. run: this / lambda. let: it / lambda. with: this / lambda (senza ricevitore tramite il punto).

apply: configurare e restituire

Usi apply per configurare oggetti in una catena nello stile dei builder.

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: effetti collaterali

Usi also per registrare, convalidare o attivare un effetto collaterale mentre il ricevitore prosegue nella catena.

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

let: trasformazione e sicurezza rispetto ai valori null

Usi let per trasformazioni null-safe o per limitare l'ambito di una variabile.

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

run: accesso a più membri con risultato

Usi run quando calcola un risultato a partire da molti membri del ricevitore — evita i prefissi it..

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

with: raggruppare operazioni su un oggetto esistente

Usi with(obj) { ... } quando non controlla il punto della chiamata (nessuna catena con il punto), ma desidera raggruppare operazioni usando 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
}

Scegliere in base all'intento

Si chieda: (1) mi serve di nuovo il ricevitore o un risultato derivato? (2) preferisco this o it? Le risposte determinano la funzione da usare.

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")
}

Confronto: apply e also

Entrambe restituiscono il ricevitore. apply usa this (utile per impostare i campi). also usa it (utile per fare riferimento esplicitamente al ricevitore, spesso negli effetti collaterali).

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}")
}

Confronto: let e run

Entrambe restituiscono il risultato della lambda. let usa it (utile per semplici trasformazioni e per la sicurezza rispetto ai valori null). run usa this (utile quando chiama molti membri).

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")
}

Pipeline pratica

Una catena reale usa spesso più funzioni di ambito insieme.

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)
}

Cheat sheet

Un riferimento rapido per scegliere lo strumento giusto.

// 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") }

Verifica rapida

Quale funzione di ambito usa this come ricevitore e restituisce il ricevitore stesso?

Riepilogo

Scelga la funzione di ambito in base all'intento: apply (configurazione + restituzione del ricevitore), also (effetto collaterale + restituzione del ricevitore), let (trasformazione con it), run (trasformazione con this), with (raggruppamento di operazioni su un oggetto esistente). Due assi — stile del ricevitore e valore restituito — determinano la scelta corretta.

Domande Frequenti

La lezione «Scegliere la funzione di ambito corretta: guida decisionale» è gratuita?

Sì — il testo completo di «Scegliere la funzione di ambito corretta: guida decisionale» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Scegliere la funzione di ambito corretta: guida decisionale»?

Selezioni la funzione di ambito corretta in base al receiver, al tipo restituito e all'obiettivo. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Scegliere la funzione di ambito corretta: guida decisionale»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. apply e with: configurare e restituire
  2. let e run: trasformare e definire l'ambito
  3. also: effetti collaterali senza modificare il receiver
  4. Scegliere la funzione di ambito corretta: guida decisionale
← Torna a Kotlin Academy