0Pricing
Kotlin Academy · Lección

let y run: transformar y delimitar el alcance

Aplique let para transformaciones seguras frente a null y run para cálculos locales.

let y run: transformar y delimitar el alcance es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

let y run

let usa it como receptor; run usa this. Ambas devuelven la última expresión de la lambda. Elija una según prefiera referencias explícitas o no.

Conceptos básicos de let

let pasa el receptor a la lambda como it. Es útil para transformar un valor o limitar el ámbito de una variable.

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

let con valores anulables

Patrón clásico: obj?.let { ... } ejecuta el bloque solo cuando obj no es null.

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

Usar let para transformar

Use let para convertir un valor y mantener la cadena legible.

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

Usar let para limitar el ámbito

Limite la visibilidad de una variable a un bloque pequeño; es una forma limpia de evitar la contaminación del espacio de nombres.

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

Conceptos básicos de run

run funciona como let, pero usa this en lugar de it. Es útil cuando quiere llamar a varios miembros del receptor.

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 como bloque independiente

run { ... } (sin receptor) ejecuta el bloque y devuelve su resultado; es útil para agrupar cálculos.

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

let frente a run según el estilo del receptor

Si el cuerpo de la lambda accede a muchos miembros del receptor, run evita usar it.. Si usa el receptor solo una o dos veces, let resulta claro.

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

Combinar let y Elvis

La combinación de ?.let { ... } y ?: es un potente patrón de procesamiento seguro frente a null.

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

run con configuración y resultado

Combine la configuración (mediante this) con un valor devuelto en un solo bloque.

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

Antipatrón: usar let en exceso

No envuelva comprobaciones sencillas de null en let cuando un if resulte más claro. Use las funciones de ámbito cuando realmente aporten valor.

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

Comprobación rápida

¿Qué función de ámbito pasa el receptor a la lambda como it y devuelve el resultado de la lambda?

Resumen

let usa it y devuelve el resultado de la lambda; es ideal para transformaciones seguras frente a null y para limitar el ámbito. run usa this y devuelve el resultado de la lambda; es ideal cuando llama a muchos miembros del receptor. Ambas son excelentes para escribir código con estilo de expresiones.

Preguntas frecuentes

¿La lección «let y run: transformar y delimitar el alcance» es gratis?

Sí — el texto completo de «let y run: transformar y delimitar el alcance» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «let y run: transformar y delimitar el alcance»?

Aplique let para transformaciones seguras frente a null y run para cálculos locales. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «let y run: transformar y delimitar el alcance»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. apply y with: configurar y devolver
  2. let y run: transformar y delimitar el alcance
  3. also: efectos secundarios sin cambiar el receptor
  4. Elegir la función de alcance adecuada: guía de decisión
← Volver a Kotlin Academy