when Exaustivo
Aborde todos os casos
when Exaustivo é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.
Abrangendo todos os casos
Um when exaustivo lida com todos os valores possíveis. Quando usado como expressão, o Kotlin exige isso para garantir que um resultado seja sempre produzido.
Esta lição mostra como tornar when exaustivo e por que isso é útil.
else Torna a Expressão Exaustiva
Para valores com possibilidades abertas, como Int, um ramo else cobre tudo o que não foi listado.
Isso garante que o when sempre encontre uma correspondência.
fun label(n: Int): String = when (n) {
0 -> "zero"
1 -> "one"
else -> "many"
}
fun main() {
println(label(0))
println(label(5))
}Enumerações Permitem a Exaustividade
Com uma enumeração, o compilador conhece todos os valores possíveis. Liste todos eles e você poderá 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))
}Caso de Enumeração Ausente
Se você esquecer um valor de enumeração em uma expressão when, o compilador informará um erro.
Isso detecta erros assim que você adiciona uma nova constante à enumeração.
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))
}Classes Seladas
Uma classe selada tem um conjunto fixo de subclasses conhecido no momento da compilação.
Isso permite que when seja exaustivo para todos os subtipos sem 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 Que a Exaustividade Ajuda
Um when exaustivo transforma casos ausentes em erros de compilação, em vez de erros silenciosos.
Adicione uma nova subclasse ou um novo valor de enumeração, e o compilador indicará todos os when que você deverá atualizar.
Instruções Não São Obrigadas
Quando usado como uma instrução (sem atribuição), when não exige exaustividade.
Mas, para enumerações e tipos selados, ser exaustivo mesmo assim é uma boa prática.
enum class Light { RED, GREEN }
fun main() {
val light = Light.RED
when (light) {
Light.RED -> println("stop")
Light.GREEN -> println("go")
}
}Combinando Classes Seladas e de Dados
Hierarquias seladas costumam usar subclasses de classes de dados, proporcionando correspondência exaustiva e conversões inteligentes para acessar propriedades.
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 Rede de Segurança
Você ainda pode adicionar else a um when de tipo selado ou de enumeração, mas então o compilador deixa de emitir avisos sobre novos casos.
Omitir else mantém a segurança em tempo de compilação; por isso, prefira essa opção para tipos fechados.
enum class Coin { HEADS, TAILS }
fun flip(c: Coin): Int = when (c) {
Coin.HEADS -> 1
Coin.TAILS -> 0
}
fun main() {
println(flip(Coin.HEADS))
}Booleanos e Valores Fechados
Um Boolean tem apenas dois valores, portanto listar ambos torna o when exaustivo sem else.
fun yesNo(flag: Boolean): String = when (flag) {
true -> "yes"
false -> "no"
}
fun main() {
println(yesNo(true))
println(yesNo(false))
}Reunindo Tudo
Um when exaustivo significa que todos os casos são cobertos:
elsecobre valores com possibilidades abertas, comoInt- Enumerações, classes seladas e
Booleanpodem ser exaustivos semelse - O compilador sinaliza casos ausentes quando você adiciona novos casos
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))
}Verificação Rápida
Teste sua compreensão sobre when exaustivo.
Recapitulação
Você aprendeu a tornar when exaustivo:
elsetrata valores com possibilidades abertas- Enumerações, classes seladas e
Booleanpodem ser totalmente cobertos - As verificações em tempo de compilação detectam casos ausentes
Isso conclui o curso de Expressões when e Conversões Inteligentes.
Perguntas Frequentes
A aula “when Exaustivo” é grátis?
Sim — o texto completo de “when Exaustivo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.
O que vou aprender em “when Exaustivo”?
Aborde todos os casos Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Kotlin Academy?
Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “when Exaustivo”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Kotlin Academy?
Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.