when exhaustivo con jerarquías selladas
Escriba expresiones when completas que cubran todas las variantes selladas.
when exhaustivo con jerarquías selladas 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.
when exhaustivo
Una expresión when utilizada como expresión debe ser exhaustiva: debe gestionar todos los valores posibles. Las jerarquías sealed permiten que el compilador lo verifique por usted.
when no exhaustivo sobre un tipo abierto
Para las clases ordinarias, el compilador no puede comprobar todos los subtipos; requiere una rama else.
open class Shape
class Circle : Shape()
class Square : Shape()
fun describe(s: Shape) = when (s) {
is Circle -> "circle"
is Square -> "square"
else -> "unknown" // required
}
fun main() { println(describe(Circle())) }when exhaustivo sobre sealed
Para una sealed class, el compilador conoce todos los subtipos. No se necesita else si se cubren todos los casos.
sealed class Result
class Success(val value: Int) : Result()
class Failure(val msg: String) : Result()
fun describe(r: Result) = when (r) {
is Success -> "ok: ${r.value}"
is Failure -> "err: ${r.msg}"
}
fun main() {
println(describe(Success(42)))
println(describe(Failure("nope")))
}Sealed interface
Las sealed interface proporcionan comprobación de exhaustividad incluso cuando las clases necesitan herencia múltiple.
sealed interface Animal
class Dog : Animal
class Cat : Animal
fun speak(a: Animal) = when (a) {
is Dog -> "woof"
is Cat -> "meow"
}
fun main() {
println(speak(Dog()))
println(speak(Cat()))
}Smart casts en las ramas
Dentro de cada rama is, Kotlin convierte automáticamente la variable al tipo específico mediante smart cast; no se necesita ninguna conversión manual.
sealed class Event
data class Click(val x: Int, val y: Int) : Event()
data class Key(val char: Char) : Event()
fun handle(e: Event) = when (e) {
is Click -> "clicked at (${e.x},${e.y})" // smart-cast
is Key -> "key=${e.char}"
}
fun main() {
println(handle(Click(10, 20)))
println(handle(Key('A')))
}Olvidar un caso
Si añade una variante nueva más adelante, todos los when exhaustivos que sigan utilizando el tipo sealed como expresión dejarán de compilar; es una excelente red de seguridad.
sealed class Status
object Idle : Status()
object Running : Status()
// If we add object Done : Status(), every exhaustive when must update.
fun text(s: Status): String = when (s) {
is Idle -> "idle"
is Running -> "running"
}
fun main() { println(text(Idle)) }Sealed con data classes
Patrón habitual: utilizar data classes como variantes de una jerarquía sealed.
sealed class UiState {
object Loading : UiState()
data class Success(val data: List<String>) : UiState()
data class Error(val message: String) : UiState()
}
fun render(state: UiState) = when (state) {
UiState.Loading -> "loading..."
is UiState.Success -> "got ${state.data.size} items"
is UiState.Error -> "error: ${state.message}"
}
fun main() {
println(render(UiState.Loading))
println(render(UiState.Success(listOf("a", "b"))))
println(render(UiState.Error("404")))
}Usar when como sentencia
Cuando se utiliza como sentencia (no como expresión), when no necesita ser exhaustivo. Sin embargo, se pierde la red de seguridad.
sealed class Cmd
object Start : Cmd()
object Stop : Cmd()
fun execute(c: Cmd) {
// Statement form: no error if incomplete (avoid this style)
when (c) {
Start -> println("started")
Stop -> println("stopped")
}
}
fun main() { execute(Start); execute(Stop) }Forzar la comprobación de exhaustividad en una sentencia
Asigne when a un valor (o utilice el truco .exhaustive) para que el compilador garantice que se cubran todos los casos.
sealed class Cmd
object Start : Cmd()
object Stop : Cmd()
fun execute(c: Cmd) {
val handled: Unit = when (c) { // expression context now
Start -> println("started")
Stop -> println("stopped")
}
}
fun main() { execute(Start) }Ramas con varios casos
Agrupe los casos con comas para compartir un cuerpo entre varias variantes.
sealed class Event
class Click : Event()
class Tap : Event()
class Drag : Event()
fun isPointer(e: Event) = when (e) {
is Click, is Tap, is Drag -> true
}
fun main() { println(isPointer(Tap())) }Tipos sealed anidados
Las jerarquías sealed pueden anidarse; la comprobación de exhaustividad sigue funcionando en árboles profundos.
sealed class Network {
sealed class Wifi : Network() {
object Open : Wifi()
data class Secured(val ssid: String) : Wifi()
}
object Cellular : Network()
}
fun describe(n: Network) = when (n) {
Network.Wifi.Open -> "open wifi"
is Network.Wifi.Secured -> "secured: ${n.ssid}"
Network.Cellular -> "cellular"
}
fun main() {
println(describe(Network.Wifi.Secured("home")))
println(describe(Network.Cellular))
}Comprobación rápida
¿Cuál es el principal beneficio de utilizar when con jerarquías sealed?
Resumen
Combine clases e interfaces sealed con when para obtener exhaustividad en tiempo de compilación. Los smart casts simplifican el cuerpo de las ramas. Utilícelo como expresión (o asigne el resultado) para forzar la comprobación; agrupe los casos con comas y anide los tipos sealed para representar estados en forma de árbol.
Preguntas frecuentes
¿La lección «when exhaustivo con jerarquías selladas» es gratis?
Sí — el texto completo de «when exhaustivo con jerarquías selladas» 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 con jerarquías selladas»?
Escriba expresiones when completas que cubran todas las variantes selladas. 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 «when exhaustivo con jerarquías selladas»?
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
- sealed class frente a sealed interface: cuándo usar cada una
- when exhaustivo con jerarquías selladas
- Modelar el estado de la interfaz con clases selladas
- Anidar y combinar jerarquías selladas