Kotlin Academy · Lezione

when esaustivo

Copra tutti i casi

when esaustivo è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Gestire tutti i casi

Un esaustivo when gestisce ogni valore possibile. Quando viene usato come espressione, Kotlin lo richiede affinché venga sempre prodotto un risultato.

Questa lezione mostra come rendere when esaustivo e perché è utile.

else rende l'espressione esaustiva

Per soggetti aperti come Int, un ramo else copre tutto ciò che non è stato elencato.

In questo modo si garantisce che when trovi sempre una corrispondenza.

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

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

Gli enum consentono l'esaustività

Con un enum, il compilatore conosce ogni valore possibile. Se li elenca tutti, può omettere 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))
}

Omettere un caso dell'enum

Se si dimentica un valore dell'enum in un'espressione when, il compilatore segnala un errore.

In questo modo gli errori vengono individuati nel momento stesso in cui si aggiunge una nuova costante dell'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))
}

Classi sealed

Una classe sealed ha un insieme fisso di sottoclassi note al momento della compilazione.

Questo consente a when di gestire tutti i sottotipi senza 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)))
}

Perché l'esaustività è utile

Un when esaustivo trasforma i casi mancanti in errori di compilazione invece che in errori silenziosi.

Quando si aggiunge una nuova sottoclasse o un nuovo valore dell'enum, il compilatore indica ogni when da aggiornare.

Le istruzioni non devono essere esaustive

Quando viene usato come istruzione (senza assegnarlo), when non richiede l'esaustività.

Tuttavia, per gli enum e i tipi sealed, è comunque buona pratica coprire tutti i casi.

enum class Light { RED, GREEN }

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

Combinare sealed e data

Le gerarchie sealed usano spesso sottoclassi data class, offrendo sia il controllo esaustivo dei casi sia gli smart cast per accedere alle proprietà.

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 come rete di sicurezza

È comunque possibile aggiungere else a un when su un tipo sealed o un enum, ma in tal caso il compilatore smette di segnalare i nuovi casi.

Omettere else mantiene la sicurezza verificata in fase di compilazione, quindi è preferibile farlo con i tipi chiusi.

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 e soggetti chiusi

Un Boolean ha solo due valori, quindi elencarli entrambi rende when esaustivo senza else.

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

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

Riepilogo

Un when esaustivo significa che tutti i casi sono coperti:

else copre soggetti aperti come Int
Enum, classi sealed e Boolean possono essere esaustivi senza else
Il compilatore segnala i casi mancanti quando se ne aggiungono di nuovi

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 rapida

Verifichi la Sua comprensione di when esaustivo.

Riepilogo

Ha imparato a rendere when esaustivo:

else gestisce i soggetti aperti
Enum, classi sealed e Boolean possono essere coperti completamente
I controlli in fase di compilazione individuano i casi mancanti

Ha completato il corso Espressioni when e smart cast.

Domande Frequenti

La lezione «when esaustivo» è gratuita?

Sì — il testo completo di «when esaustivo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «when esaustivo»?

Copra tutti i casi Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «when esaustivo»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy