Enum con when
Gestione esaustiva
Enum con when è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 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.
Le enum si combinano bene con when
L'espressione when è il modo naturale per diramare il codice in base a una enum. Ogni costante dispone del proprio ramo.
enum class Light { RED, YELLOW, GREEN }
fun action(l: Light) = when (l) {
Light.RED -> "Stop"
Light.YELLOW -> "Slow"
Light.GREEN -> "Go"
}
fun main() {
println(action(Light.GREEN))
}Completezza
Quando when viene utilizzato come espressione su una enum e copre ogni costante, non è necessario alcun ramo else. Il compilatore verifica che non manchi alcun caso.
enum class Coin { HEADS, TAILS }
fun flip(c: Coin) = when (c) {
Coin.HEADS -> "Win"
Coin.TAILS -> "Lose"
}
fun main() {
println(flip(Coin.HEADS))
}Il compilatore protegge il codice
Se in seguito aggiunge una nuova costante ma dimentica un ramo, il compilatore segnala un errore. In questo modo le enum insieme a when possono evolvere in modo molto sicuro.
enum class Size { S, M, L }
fun label(s: Size) = when (s) {
Size.S -> "Small"
Size.M -> "Medium"
Size.L -> "Large"
}
fun main() {
println(label(Size.M))
}Importazione delle costanti
È possibile importare i membri della enum per omettere il prefisso del tipo all'interno di when, rendendo i rami più brevi.
enum class Dir { UP, DOWN }
import Dir.UP
import Dir.DOWN
fun move(d: Dir) = when (d) {
UP -> "y + 1"
DOWN -> "y - 1"
}
fun main() {
println(move(Dir.UP))
}Raggruppamento dei rami
È possibile usare lo stesso ramo per più costanti elencandole separate da virgole.
enum class Day { MON, TUE, WED, SAT, SUN }
fun kind(d: Day) = when (d) {
Day.SAT, Day.SUN -> "Weekend"
else -> "Weekday"
}
fun main() {
println(kind(Day.SAT))
}Restituzione di tipi diversi
Ogni ramo può produrre un valore; l'intero when diventa quel valore.
enum class Tier { FREE, PRO }
fun limit(t: Tier): Int = when (t) {
Tier.FREE -> 10
Tier.PRO -> 1000
}
fun main() {
println(limit(Tier.PRO))
}when senza argomento
È anche possibile diramare il codice in base a condizioni, ma per le enum la forma con soggetto è più chiara e abilita il controllo di completezza.
enum class Mood { HAPPY, SAD }
fun emoji(m: Mood) = when (m) {
Mood.HAPPY -> ":)"
Mood.SAD -> ":("
}
fun main() {
println(emoji(Mood.HAPPY))
}Effetti collaterali nei rami
I rami possono eseguire istruzioni, non solo restituire valori.
enum class Cmd { START, STOP }
fun run(c: Cmd) {
when (c) {
Cmd.START -> println("Starting...")
Cmd.STOP -> println("Stopping...")
}
}
fun main() {
run(Cmd.START)
}Eviti else quando possibile
L'utilizzo di else impedisce il controllo di completezza: una nuova costante finirebbe silenziosamente nel ramo else. Per le enum, preferisca rami espliciti.
enum class State { ON, OFF }
fun text(s: State) = when (s) {
State.ON -> "on"
State.OFF -> "off"
}
fun main() {
println(text(State.OFF))
}Un router realistico
Associare i ruoli degli utenti alle autorizzazioni è un uso chiaro di when completo.
enum class Role { ADMIN, USER, GUEST }
fun canDelete(r: Role) = when (r) {
Role.ADMIN -> true
Role.USER -> false
Role.GUEST -> false
}
fun main() {
println(canDelete(Role.ADMIN))
}Combinazione con le proprietà
È possibile diramare il codice in base a una enum e utilizzare anche le sue proprietà all'interno dei rami.
enum class Coin(val cents: Int) { PENNY(1), DIME(10) }
fun describe(c: Coin) = when (c) {
Coin.PENNY -> "Worth ${c.cents}"
Coin.DIME -> "Worth ${c.cents}"
}
fun main() {
println(describe(Coin.DIME))
}Verifica rapida
Verifichi la propria comprensione dell'utilizzo delle enum con when.
Riepilogo
Ha imparato a combinare le enum con when:
- Un
whensu una enum può essere completo senzaelse. - Il compilatore impone la copertura di tutte le costanti.
- Raggruppi le costanti con le virgole; ogni ramo produce un valore.
- Eviti
elseper mantenere la sicurezza offerta dal controllo di completezza.
enum class Light { RED, GREEN }
fun go(l: Light) = when (l) {
Light.RED -> false
Light.GREEN -> true
}
fun main() {
println(go(Light.GREEN))
}
Impara Kotlin con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «Enum con when» è gratuita?
Sì — il testo completo di «Enum con when» è 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 «Enum con when»?
Gestione esaustiva 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 3 di 4.
Quanto tempo richiede la lezione «Enum con when»?
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.