0Pricing
Kotlin Academy · Lezione

let e run: trasformare e definire l'ambito

Applichi let alle trasformazioni null-safe e run ai calcoli locali.

let e run: trasformare e definire l'ambito è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 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.

let e run

let usa it come ricevitore; run usa this. Entrambe restituiscono l'ultima espressione della lambda. Scelga in base alla sua preferenza per i riferimenti espliciti.

Nozioni di base di let

let passa il ricevitore alla lambda come it. È utile per trasformare un valore o limitare l'ambito di una variabile.

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

let con valori nullable

Idiom classico: obj?.let { ... } esegue il blocco solo quando obj non è null.

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

Trasformare con let

Usi let per convertire un valore mantenendo leggibile la catena.

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

Limitare l'ambito con let

Limiti la visibilità di una variabile a un blocco ristretto — un modo ordinato per evitare l'inquinamento dello spazio dei nomi.

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

Nozioni di base di run

run funziona come let, ma usa this invece di it. È utile quando desidera chiamare diversi membri del ricevitore.

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 come blocco autonomo

run { ... } (senza ricevitore) esegue il blocco e ne restituisce il risultato — utile per raggruppare i calcoli.

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

let e run in base allo stile del ricevitore

Se il corpo della lambda accede a molti membri del ricevitore, run evita it.. Se usa il ricevitore solo una o due volte, let è più leggibile.

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

Combinare let ed Elvis

La combinazione di ?.let { ... } e ?: è un potente modello di pipeline null-safe.

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

run con configurazione e risultato

Combini la configurazione (tramite this) con un valore restituito in un unico blocco.

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

Anti-pattern: usare let eccessivamente

Non racchiuda semplici controlli sui valori null in let quando un if è più chiaro. Usi le funzioni di ambito solo quando offrono un vantaggio concreto.

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

Verifica rapida

Quale funzione di ambito passa il ricevitore alla lambda come it e restituisce il risultato della lambda?

Riepilogo

let usa it e restituisce il risultato della lambda — ideale per trasformazioni null-safe e per limitare l'ambito. run usa this e restituisce il risultato della lambda — ideale quando chiama molti membri del ricevitore. Entrambe sono ottime per il codice in stile espressione.

Domande Frequenti

La lezione «let e run: trasformare e definire l'ambito» è gratuita?

Sì — il testo completo di «let e run: trasformare e definire l'ambito» è 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 «let e run: trasformare e definire l'ambito»?

Applichi let alle trasformazioni null-safe e run ai calcoli locali. 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 2 di 4.

Quanto tempo richiede la lezione «let e run: trasformare e definire l'ambito»?

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