0Pricing
Kotlin Academy · Lección

also: efectos secundarios sin cambiar el receptor

Use also para registrar información, depurar y realizar operaciones exclusivamente de efecto secundario.

also: efectos secundarios sin cambiar el receptor es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 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.

also de un vistazo

also ejecuta un bloque con el receptor como it y devuelve el receptor sin cambios. Es perfecto para efectos secundarios, como registrar información, depurar o validar, sin interrumpir una cadena.

Conceptos básicos de also

also { ... } realiza un efecto secundario y devuelve el mismo valor, de modo que las llamadas fluyen de forma natural.

fun main() {
    val nums = listOf(1, 2, 3, 4)
        .also { println("input: $it") }
        .filter { it % 2 == 0 }
        .also { println("filtered: $it") }
    println(nums)
}

Usar also para registrar información

Añada instrucciones de registro en mitad de una cadena de procesamiento sin interrumpir el flujo.

fun main() {
    val processed = "  Hello, Kotlin!  "
        .also { println("raw: '$it'") }
        .trim()
        .also { println("trimmed: '$it'") }
        .uppercase()
    println(processed)
}

Usar also para depurar

Use also para inspeccionar el estado intermedio durante una refactorización; después puede quitarlo sin cambiar la cadena.

fun main() {
    val sum = (1..5).toList()
        .also { println("list: $it") }
        .sum()
        .also { println("sum: $it") }
    println("final: $sum")
}

also frente a apply

apply usa this (mejor para asignaciones). also usa it (mejor para referencias explícitas y efectos secundarios).

class Counter {
    var value: Int = 0
}
fun main() {
    val c = Counter().apply { value = 10 } // uses this implicitly
    val d = Counter().also { it.value = 10 } // uses it explicitly
    println("${c.value} / ${d.value}")
}

also para efectos secundarios de inicialización

Es útil cuando necesita hacer algo con un objeto durante su creación que no consiste en establecer una propiedad.

class Repository {
    val cache = mutableMapOf<String, String>()
    fun init() = println("Repository initialized")
}
fun main() {
    val r = Repository().also { it.init() }
    r.cache["key"] = "value"
    println(r.cache)
}

also devuelve el original

El receptor continúa sin cambios, por lo que resulta fácil encadenar llamadas.

fun main() {
    val len = "Hello".also { println("got: $it") }.length
    println(len) // 5
}

also para validar

Ejecute aserciones en mitad de una cadena.

fun main() {
    val n = listOf(1, 2, 3, 4)
        .filter { it > 0 }
        .also { require(it.isNotEmpty()) { "must have positives" } }
        .sum()
    println(n)
}

Combinar also y let

Use also para los efectos secundarios y let para la transformación dentro de la misma cadena de procesamiento.

fun main() {
    val raw: String? = "  42  "
    val n = raw
        ?.also { println("raw: '$it'") }
        ?.let { it.trim().toIntOrNull() }
        ?.also { println("parsed: $it") }
    println(n)
}

also para añadir elementos a una colección

Añada un objeto construido a una lista directamente en la cadena.

class User(val name: String)
fun main() {
    val users = mutableListOf<User>()
    val ada = User("Ada").also { users.add(it) }
    val ben = User("Ben").also { users.add(it) }
    println(users.map { it.name })
}

Cuándo usar also

Use also cuando necesite un efecto secundario (registrar, validar o registrar en otro sistema), pero quiera que el valor original siga fluyendo.

fun main() {
    val total = listOf(10, 20, 30, 40, 50)
        .also { println("count: ${it.size}") }
        .filter { it >= 30 }
        .also { println("kept: $it") }
        .sum()
    println("total: $total")
}

Antipatrón: usar also para reasignar

No use also cuando en realidad necesite transformar un valor; para eso están let y run.

fun main() {
    val name = "ada"
    // BAD: also returns receiver, so upper is wrong
    // val upper = name.also { it.uppercase() } // upper == "ada"
    val upper = name.let { it.uppercase() }
    println(upper) // ADA
}

Comprobación rápida

¿Qué valor devuelve also después de ejecutar su bloque?

Resumen

also ejecuta un bloque de efecto secundario con it y devuelve el receptor. Úselo para registrar información, depurar, validar o registrar en otro sistema; en cualquier situación en la que necesite inspeccionar un valor sin modificarlo. Para las transformaciones, use let o run.

Preguntas frecuentes

¿La lección «also: efectos secundarios sin cambiar el receptor» es gratis?

Sí — el texto completo de «also: efectos secundarios sin cambiar el receptor» 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 «also: efectos secundarios sin cambiar el receptor»?

Use also para registrar información, depurar y realizar operaciones exclusivamente de efecto secundario. 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 3 de 4.

¿Cuánto tiempo toma la lección «also: efectos secundarios sin cambiar el receptor»?

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