Kotlin Academy · Leçon

Énumérations avec when

Gestion exhaustive

Énumérations avec when est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Les énumérations s’associent bien à when

L’expression when est le moyen naturel de choisir un traitement selon une énumération. Chaque constante possède sa propre branche.

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

Exhaustivité

Lorsque when est utilisé comme expression sur une énumération et couvre toutes les constantes, aucune branche else n’est nécessaire. Le compilateur vérifie que le traitement est complet.

enum class Coin { HEADS, TAILS }

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

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

Le compilateur veille sur vous

Si vous ajoutez une nouvelle constante mais oubliez une branche, le compilateur signale une erreur. Les énumérations associées à when peuvent ainsi évoluer en toute sécurité.

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

Importer des constantes

Vous pouvez importer les membres d’une énumération pour supprimer le préfixe de type à l’intérieur de when, ce qui raccourcit les branches.

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

Regrouper les branches

Plusieurs constantes peuvent partager une même branche : il suffit de les séparer par des virgules.

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

Renvoyer des types différents

Chaque branche peut produire une valeur ; l’ensemble de l’expression when devient cette valeur.

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 sans argument

Vous pouvez également choisir un traitement selon des conditions, mais pour les énumérations, la forme avec sujet est la plus claire et permet de vérifier l’exhaustivité.

enum class Mood { HAPPY, SAD }

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

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

Effets secondaires dans les branches

Les branches peuvent exécuter des instructions, et pas seulement renvoyer des valeurs.

enum class Cmd { START, STOP }

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

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

Éviter else lorsque c’est possible

L’utilisation de else désactive la vérification de l’exhaustivité : une nouvelle constante tomberait silencieusement dans else. Préférez des branches explicites pour les énumérations.

enum class State { ON, OFF }

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

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

Un routeur réaliste

Associer des rôles utilisateur à des autorisations est une utilisation claire de when exhaustif.

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

Combiner avec des propriétés

Vous pouvez choisir une branche selon une énumération et utiliser également ses propriétés à l’intérieur des branches.

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

Vérification rapide

Vérifiez votre compréhension des énumérations avec when.

Récapitulatif

Vous avez appris à combiner les énumérations avec when :

Un when portant sur une énumération peut être exhaustif sans else.
Le compilateur impose que toutes les constantes soient prises en compte.
Regroupez les constantes avec des virgules ; chaque branche produit une valeur.
Évitez else pour conserver la sécurité offerte par la vérification d’exhaustivité.

enum class Light { RED, GREEN }

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

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

Questions Fréquemment Posées

La leçon « Énumérations avec when » est-elle gratuite ?

Oui — le texte complet de « Énumérations avec when » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Énumérations avec when » ?

Gestion exhaustive Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Énumérations avec when » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Kotlin Academy