Elegir la función de alcance adecuada: guía de decisión
Seleccione la función de alcance correcta según el receptor, el tipo de retorno y la intención.
Elegir la función de alcance adecuada: guía de decisión es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 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.
Cinco funciones, dos ejes
Las funciones de ámbito de Kotlin varían en dos ejes: el estilo del receptor (this o it) y el valor devuelto (el receptor o el resultado de la lambda). Elija según la intención.
La matriz de decisión
apply: this / receptor. also: it / receptor. run: this / lambda. let: it / lambda. with: this / lambda (sin receptor mediante punto).
apply: configurar y devolver
Use apply para configurar objetos dentro de una cadena con estilo de patrón 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: efectos secundarios
Use also para registrar información, validar o activar un efecto secundario mientras el receptor sigue fluyendo.
fun main() {
val items = listOf(1, 2, 3, 4)
.also { println("got ${it.size} items") }
.filter { it % 2 == 0 }
println(items)
}let: transformar y gestionar la seguridad frente a null
Use let para realizar transformaciones seguras frente a null o limitar el ámbito de una variable.
fun main() {
val name: String? = "Ada"
val length = name?.let { it.length } ?: 0
println(length)
}run: acceder a varios miembros con resultado
Use run al calcular un resultado a partir de varios miembros del receptor; así evita los prefijos it..
class User(val name: String, val age: Int)
fun main() {
val description = User("Ada", 35).run {
"Name: $name, Age: $age"
}
println(description)
}with: agrupar operaciones sobre un objeto existente
Use with(obj) { ... } cuando no controle el punto de llamada (no hay una cadena con punto), pero quiera agrupar operaciones 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
}Elegir según la intención
Pregúntese: (1) ¿Necesito recuperar el receptor o un resultado derivado? (2) ¿Prefiero this o it? Las respuestas determinan la función.
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")
}Comparación: apply frente a also
Ambas devuelven el receptor. apply usa this (es adecuado para establecer campos). also usa it (es adecuado para referenciar explícitamente el receptor, a menudo en efectos secundarios).
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}")
}Comparación: let frente a run
Ambas devuelven el resultado de la lambda. let usa it (es adecuado para transformaciones sencillas y seguridad frente a null). run usa this (es adecuado cuando llama a muchos miembros).
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")
}Cadena de procesamiento práctica
En una cadena de uso real suelen combinarse varias funciones de ámbito.
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)
}Guía rápida
Referencia rápida para elegir la herramienta adecuada.
// 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") }Comprobación rápida
¿Qué función de ámbito toma this como receptor y devuelve el propio receptor?
Resumen
Elija la función de ámbito según la intención: apply (configurar y devolver el propio objeto), also (efecto secundario y devolver el propio objeto), let (transformar con it), run (transformar con this) y with (agrupar operaciones sobre un objeto existente). Dos ejes, el estilo del receptor y el valor devuelto, determinan la opción adecuada.
Aprende Kotlin con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Elegir la función de alcance adecuada: guía de decisión» es gratis?
Sí — el texto completo de «Elegir la función de alcance adecuada: guía de decisión» 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 «Elegir la función de alcance adecuada: guía de decisión»?
Seleccione la función de alcance correcta según el receptor, el tipo de retorno y la intención. 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 4 de 4.
¿Cuánto tiempo toma la lección «Elegir la función de alcance adecuada: guía de decisión»?
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
- apply y with: configurar y devolver
- let y run: transformar y delimitar el alcance
- also: efectos secundarios sin cambiar el receptor
- Elegir la función de alcance adecuada: guía de decisión