Énumérations dans Scala 3
Nouvelle syntaxe des énumérations
Énumérations dans Scala 3 est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 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 Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Le nouveau mot-clé enum
Scala 3 ajoute une construction énumération de premier ordre. Elle remplace la structure verbeuse fondée sur un trait scellé et des objets de cas de Scala 2 par une syntaxe concise.
- Chaque cas devient une valeur du type énuméré.
- Le compilateur génère automatiquement des utilitaires pratiques.
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
println(Color.Red)Lister toutes les valeurs
Chaque énumération simple possède un compagnon avec values (un tableau de tous les cas) et valueOf (recherche par nom).
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
Color.values.foreach(println)
println(Color.valueOf("Green"))Numéro ordinal et nom
Chaque valeur d’énumération possède un ordinal (position commençant à zéro) et un toString généré à partir du nom de son cas.
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
println(Color.Blue.ordinal)
println(Color.Red.ordinal)Énumérations avec paramètres
Les cas d’une énumération peuvent accepter des paramètres de constructeur, ce qui associe des données à chaque valeur. C’est utile pour stocker des constantes telles que des codes RGB ou des masses planétaires.
enum Planet(val mass: Double):
case Earth extends Planet(5.97e24)
case Mars extends Planet(6.42e23)
object Main:
def main(args: Array[String]): Unit =
println(Planet.Earth.mass)
println(Planet.Mars.mass)Méthodes sur les énumérations
Vous pouvez définir des méthodes dans le corps d’une énumération. Elles sont disponibles sur chaque valeur, comme les méthodes d’une classe.
enum Direction:
case North, South, East, West
def opposite: Direction = this match
case North => South
case South => North
case East => West
case West => East
object Main:
def main(args: Array[String]): Unit =
println(Direction.North.opposite)Énumérations ADT génériques
Les énumérations peuvent être génériques et paramétrées, ce qui permet de modéliser des types de données algébriques. Voici un type Option simplifié.
enum Maybe[+A]:
case Just(value: A)
case Nothing
object Main:
def main(args: Array[String]): Unit =
val a: Maybe[Int] = Maybe.Just(42)
println(a)Énumérations ADT récursives
Les énumérations sont particulièrement adaptées aux structures récursives. Un arbre binaire ou une liste chaînée se lit clairement comme un ensemble de cas.
enum Tree[+A]:
case Leaf(value: A)
case Branch(left: Tree[A], right: Tree[A])
object Main:
def main(args: Array[String]): Unit =
val t = Tree.Branch(Tree.Leaf(1), Tree.Leaf(2))
println(t)Correspondance de motifs sur les énumérations
Comme les énumérations sont scellées, le compilateur peut vérifier l’exhaustivité d’un match. L’absence d’un cas déclenche un avertissement.
enum Light:
case Red, Yellow, Green
object Main:
def action(l: Light): String = l match
case Light.Red => "stop"
case Light.Yellow => "slow"
case Light.Green => "go"
def main(args: Array[String]): Unit =
println(action(Light.Green))Énumérations compatibles avec Java
Ajoutez le comportement de extends java.lang.Enum en dérivant automatiquement de scala.reflect.Enum ; pour une véritable interopérabilité avec Java, écrivez enum X extends Enum[X]... mais la plupart du code utilise simplement la forme standard, qui s’intègre bien à Java lorsque cela est nécessaire.
enum Suit:
case Hearts, Diamonds, Clubs, Spades
object Main:
def main(args: Array[String]): Unit =
println(Suit.values.length)
println(Suit.Spades.ordinal)Combiner champs et méthodes
Vous pouvez combiner des cas paramétrés avec des méthodes partagées pour créer des modèles de domaine riches.
enum Currency(val symbol: String):
case USD extends Currency("$")
case EUR extends Currency("\u20ac")
def format(amount: Double): String = s"$symbol$amount"
object Main:
def main(args: Array[String]): Unit =
println(Currency.USD.format(9.99))Quand utiliser enum
Utilisez enum lorsque vous avez un ensemble fermé de choix ou un type de données algébrique.
- Des cas simples pour les énumérations ordinaires.
- Des cas paramétrés pour les ADT et les types somme.
- La vérification gratuite de l’exhaustivité sécurise les remaniements.
enum Result[+E, +A]:
case Ok(value: A)
case Err(error: E)
object Main:
def main(args: Array[String]): Unit =
val r: Result[String, Int] = Result.Ok(7)
println(r)Vérification rapide
Vérifiez votre compréhension des énumérations de Scala 3.
Récapitulatif
Vous avez appris les énumérations de Scala 3.
- La construction concise
enumremplace le code répétitif des traits scellés. - Les énumérations simples obtiennent
values,valueOfetordinal. - Les cas peuvent accepter des paramètres pour stocker des données associées.
- Les énumérations génériques et récursives modélisent les ADT.
- Leur nature scellée permet une correspondance de motifs exhaustive.
enum Weekday:
case Mon, Tue, Wed, Thu, Fri
def isStart: Boolean = this == Mon
object Main:
def main(args: Array[String]): Unit =
println(Weekday.Mon.isStart)
println(Weekday.values.length)
Apprends Scala avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 143
Questions Fréquemment Posées
La leçon « Énumérations dans Scala 3 » est-elle gratuite ?
Oui — le texte complet de « Énumérations dans Scala 3 » 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 Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Énumérations dans Scala 3 » ?
Nouvelle syntaxe des énumérations Tu pratiques Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming 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 2 sur 4.
Combien de temps prend la leçon « Énumérations dans Scala 3 » ?
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 Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming 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
- Indentation significative
- Énumérations dans Scala 3
- Types opaques
- Types union et intersection