Kotlin Academy · Lección

let y run

Opere sobre objetos

let y run es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 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.

¿Qué son las funciones de ámbito?

Kotlin ofrece cinco funciones de ámbito: let, run, with, apply y also. Permiten ejecutar un bloque de código sobre un objeto dentro de un ámbito temporal.

Se hace referencia al objeto como it o this.
El bloque devuelve el propio objeto o el resultado de la lambda.

En esta lección nos centraremos en let y run.

La función let

let ejecuta un bloque en el que el objeto está disponible como it y devuelve el resultado de la lambda.

Es ideal para ejecutar código solo cuando un valor no es null y para transformar un valor en otra cosa.

fun main() {
    val name = "Alice"
    val length = name.let {
        println("Name is $it")
        it.length
    }
    println("Length: $length")
}

let con valores anulables

El uso más común de let es con el operador de llamada segura ?. El bloque se ejecuta solo cuando el valor no es null.

fun main() {
    val name: String? = "Bob"
    name?.let {
        println("Hello, $it")
    }
    val empty: String? = null
    empty?.let {
        println("This never prints")
    }
    println("Done")
}

Cambiar el nombre de it en let

Dentro de let puede cambiar el nombre de it por uno significativo declarando un parámetro de lambda.

fun main() {
    val price = 100
    price.let { amount ->
        println("The amount is $amount")
    }
}

La función run

run ejecuta un bloque en el que el objeto está disponible como this y devuelve el resultado de la lambda.

Úsela cuando quiera acceder directamente a los miembros sin un prefijo.

fun main() {
    val text = "Kotlin"
    val upper = text.run {
        println("Length is $length")
        uppercase()
    }
    println(upper)
}

run sin receptor

run también se puede llamar sin un objeto. Simplemente ejecuta un bloque y devuelve su resultado. Esto resulta útil para agrupar instrucciones y calcular un valor.

fun main() {
    val result = run {
        val a = 5
        val b = 10
        a + b
    }
    println("Result: $result")
}

it frente a this

La diferencia clave entre let y run es cómo hacen referencia al objeto:

let usa it (un parámetro).
run usa this (un receptor, a menudo implícito).

Ambas devuelven el resultado de la última expresión del bloque.

fun main() {
    val word = "hi"
    val a = word.let { it.length }
    val b = word.run { length }
    println("$a $b")
}

Encadenar con let

Como let devuelve el resultado de la lambda, puede encadenar llamadas y transformar un valor paso a paso.

fun main() {
    val number = 4
    val output = number
        .let { it * 2 }
        .let { it + 1 }
    println(output)
}

run para comprobar null y calcular

Al igual que let, run funciona con llamadas seguras. Combina una comprobación de null con el acceso a miembros en un solo bloque.

fun main() {
    val message: String? = "Welcome"
    val length = message?.run {
        println(this)
        length
    }
    println("Length: $length")
}

Devolver tipos diferentes

Ambas funciones pueden devolver un tipo diferente del objeto. El tipo de retorno es el que corresponda al resultado de evaluar la última línea.

fun main() {
    val n = 10
    val label: String = n.let { "Value is $it" }
    println(label)
}

Cuándo usar let o run

Use let para operaciones seguras frente a null y transformaciones de valores en las que it resulte claro.

Use run cuando quiera llamar a varios miembros del objeto y calcular un resultado, con this para acceder directamente a ellos.

Comprobación rápida

Compruebe cuánto ha entendido sobre let y run.

Repaso

Ha aprendido las dos funciones de ámbito que devuelven un resultado:

let expone el objeto como it y devuelve el resultado de la lambda; es ideal para transformaciones seguras frente a null.
run expone el objeto como this y devuelve el resultado de la lambda; es ideal para agrupar el acceso a miembros.

A continuación configurará objetos con apply y añadirá efectos secundarios con also.

Preguntas frecuentes

¿La lección «let y run» es gratis?

Sí — el texto completo de «let y run» 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»?

Opere sobre objetos 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 1 de 4.

¿Cuánto tiempo toma la lección «let y run»?

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

← Volver a Kotlin Academy