Kotlin Academy · Lección

when exhaustivo

Cubra todos los casos

when exhaustivo 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.

Cubrir todos los casos

Un when exhaustivo gestiona todos los valores posibles. Cuando se usa como expresión, Kotlin lo exige para garantizar que siempre se produzca un resultado.

En esta lección verá cómo hacer que when sea exhaustivo y por qué resulta útil.

else hace que sea exhaustivo

En sujetos abiertos como Int, una rama else cubre todo lo que no se haya enumerado.

Esto garantiza que when siempre encuentre una coincidencia.

fun label(n: Int): String = when (n) {
    0 -> "zero"
    1 -> "one"
    else -> "many"
}

fun main() {
    println(label(0))
    println(label(5))
}

Los enums permiten la exhaustividad

Con un enum, el compilador conoce todos los valores posibles. Enumérelos todos y puede omitir else.

enum class Direction { NORTH, SOUTH, EAST, WEST }

fun turn(d: Direction): String = when (d) {
    Direction.NORTH -> "up"
    Direction.SOUTH -> "down"
    Direction.EAST -> "right"
    Direction.WEST -> "left"
}

fun main() {
    println(turn(Direction.EAST))
}

Falta un caso de enum

Si olvida un valor de enum en una expresión when, el compilador informa de un error.

Esto detecta errores en cuanto añade una nueva constante del enum.

enum class Status { ACTIVE, PAUSED, STOPPED }

fun describe(s: Status): String = when (s) {
    Status.ACTIVE -> "running"
    Status.PAUSED -> "paused"
    Status.STOPPED -> "stopped"
}

fun main() {
    println(describe(Status.PAUSED))
}

Clases selladas

Una clase sellada tiene un conjunto fijo de subclases conocido en tiempo de compilación.

Esto permite que when sea exhaustivo con todos los subtipos sin else.

sealed class Shape
class Circle(val r: Double) : Shape()
class Square(val s: Double) : Shape()

fun area(shape: Shape): Double = when (shape) {
    is Circle -> 3.14159 * shape.r * shape.r
    is Square -> shape.s * shape.s
}

fun main() {
    println(area(Square(4.0)))
}

Por qué ayuda la exhaustividad

Un when exhaustivo convierte los casos que faltan en errores de compilación, en lugar de errores silenciosos.

Añada una nueva subclase o un nuevo valor de enum y el compilador señalará cada when que deba actualizar.

Las sentencias no exigen exhaustividad

Cuando se usa como sentencia (sin asignar su resultado), when no exige exhaustividad.

Pero, con enums y tipos sealed, seguir siendo exhaustivo es una buena práctica.

enum class Light { RED, GREEN }

fun main() {
    val light = Light.RED
    when (light) {
        Light.RED -> println("stop")
        Light.GREEN -> println("go")
    }
}

Combinar sealed y data

Las jerarquías sealed suelen usar subclases data class, lo que le ofrece coincidencias exhaustivas y smart casts para acceder a las propiedades.

sealed class Result
data class Ok(val value: Int) : Result()
data class Err(val message: String) : Result()

fun show(r: Result): String = when (r) {
    is Ok -> "ok: " + r.value
    is Err -> "error: " + r.message
}

fun main() {
    println(show(Ok(42)))
    println(show(Err("boom")))
}

else como red de seguridad

Aun así, puede añadir else a un when de tipo sealed o enum, pero entonces el compilador deja de advertirle sobre los casos nuevos.

Omitir else mantiene la seguridad en tiempo de compilación, así que prefiera esta opción para los tipos cerrados.

enum class Coin { HEADS, TAILS }

fun flip(c: Coin): Int = when (c) {
    Coin.HEADS -> 1
    Coin.TAILS -> 0
}

fun main() {
    println(flip(Coin.HEADS))
}

Boolean y sujetos cerrados

Un Boolean solo tiene dos valores, por lo que enumerar ambos hace que when sea exhaustivo sin else.

fun yesNo(flag: Boolean): String = when (flag) {
    true -> "yes"
    false -> "no"
}

fun main() {
    println(yesNo(true))
    println(yesNo(false))
}

Todo junto

Un when exhaustivo significa que todos los casos están cubiertos:

else cubre sujetos abiertos como Int
Los enums, las clases sealed y Boolean pueden ser exhaustivos sin else
El compilador señala los casos que faltan cuando añade otros nuevos

sealed class Event
object Start : Event()
object Stop : Event()

fun handle(e: Event): String = when (e) {
    is Start -> "starting"
    is Stop -> "stopping"
}

fun main() {
    println(handle(Start))
    println(handle(Stop))
}

Comprobación rápida

Compruebe cuánto ha entendido sobre when exhaustivo.

Recapitulación

Ha aprendido a hacer que when sea exhaustivo:

else gestiona los sujetos abiertos
Los enums, las clases sealed y Boolean pueden cubrirse por completo
Las comprobaciones en tiempo de compilación detectan los casos que faltan

Con esto termina el curso Expresiones when y Smart Casts.

Preguntas frecuentes

¿La lección «when exhaustivo» es gratis?

Sí — el texto completo de «when exhaustivo» 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 «when exhaustivo»?

Cubra todos los casos 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 «when exhaustivo»?

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