Kotlin Academy · Lekcja

Enumy z when

Obsługa wszystkich przypadków

Enumy z when to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Enumy dobrze współpracują z when

Wyrażenie when jest naturalnym sposobem rozgałęziania logiki na podstawie enum. Każda stała otrzymuje własną gałąź.

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))
}

Kompletność

Gdy when jest używane jako wyrażenie dla enum i obejmuje każdą stałą, gałąź else nie jest potrzebna. Kompilator sprawdza kompletność.

enum class Coin { HEADS, TAILS }

fun flip(c: Coin) = when (c) {
    Coin.HEADS -> "Win"
    Coin.TAILS -> "Lose"
}

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

Kompilator czuwa

Jeśli później dodadzą Państwo nową stałą, ale zapomną o gałęzi, kompilator zgłosi błąd. Dzięki temu połączenie enumów z when można bezpiecznie rozwijać.

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))
}

Importowanie stałych

Można importować elementy enum, aby pominąć prefiks typu wewnątrz when i skrócić gałęzie.

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))
}

Grupowanie gałęzi

Wiele stałych może współdzielić jedną gałąź, jeśli zostaną wymienione po przecinku.

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))
}

Zwracanie różnych typów

Każda gałąź może generować wartość; całe wyrażenie when staje się tą wartością.

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 bez argumentu

Można również rozgałęziać logikę na podstawie warunków, ale w przypadku enumów najczytelniejsza jest forma z obiektem sprawdzanym, która umożliwia kontrolę kompletności.

enum class Mood { HAPPY, SAD }

fun emoji(m: Mood) = when (m) {
    Mood.HAPPY -> ":)"
    Mood.SAD -> ":("
}

fun main() {
    println(emoji(Mood.HAPPY))
}

Efekty uboczne w gałęziach

Gałęzie mogą wykonywać instrukcje, a nie tylko zwracać wartości.

enum class Cmd { START, STOP }

fun run(c: Cmd) {
    when (c) {
        Cmd.START -> println("Starting...")
        Cmd.STOP -> println("Stopping...")
    }
}

fun main() {
    run(Cmd.START)
}

Należy unikać else, gdy to możliwe

Użycie else uniemożliwia kontrolę kompletności: nowa stała trafiłaby po cichu do else. W przypadku enumów lepiej stosować jawne gałęzie.

enum class State { ON, OFF }

fun text(s: State) = when (s) {
    State.ON -> "on"
    State.OFF -> "off"
}

fun main() {
    println(text(State.OFF))
}

Realistyczny router

Przypisywanie ról użytkowników do uprawnień jest dobrym zastosowaniem kompletnego wyrażenia when.

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))
}

Łączenie z właściwościami

Można rozgałęziać logikę na podstawie enum i jednocześnie używać jego właściwości wewnątrz gałęzi.

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))
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat enumów i when.

Podsumowanie

Nauczyli się Państwo łączyć enumy z when:

when dla enum może być kompletne bez else.
Kompilator wymaga uwzględnienia wszystkich stałych.
Stałe można grupować za pomocą przecinków; każda gałąź zwraca wartość.
Należy unikać else, aby zachować bezpieczeństwo wynikające z kontroli kompletności.

enum class Light { RED, GREEN }

fun go(l: Light) = when (l) {
    Light.RED -> false
    Light.GREEN -> true
}

fun main() {
    println(go(Light.GREEN))
}

Często zadawane pytania

Czy lekcja „Enumy z when” jest bezpłatna?

Tak — pełny tekst „Enumy z when” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Enumy z when”?

Obsługa wszystkich przypadków Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Enumy z when”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Kotlin Academy