Enum in Scala 3
Nuova sintassi degli enum
Enum in Scala 3 è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 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 Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
La nuova parola chiave enum
Scala 3 aggiunge una struttura enum di prima classe. Sostituisce il modello prolisso basato su sealed trait e case object di Scala 2 con una sintassi concisa.
- Ogni caso diventa un valore del tipo enum.
- Il compilatore genera automaticamente utilità importanti.
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
println(Color.Red)Elencare tutti i valori
Ogni enum semplice ha un companion con values (un array di tutti i casi) e valueOf (ricerca per nome).
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
Color.values.foreach(println)
println(Color.valueOf("Green"))Ordinale e nome
Ogni valore enum ha un ordinal (posizione a partire da zero) e un toString generato che usa il nome del caso.
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
println(Color.Blue.ordinal)
println(Color.Red.ordinal)Enum con parametri
I casi di un enum possono accettare parametri del costruttore, fornendo a ogni valore dati associati. È utile per memorizzare costanti come codici RGB o masse planetarie.
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)Metodi negli enum
È possibile definire metodi all'interno del corpo di un enum. Sono disponibili su ogni valore, come i metodi di una 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)Enum ADT generici
Gli enum possono essere generici e parametrizzati, consentendo di modellare tipi di dati algebrici. Ecco un tipo Option semplificato.
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)Enum ADT ricorsivi
Gli enum sono particolarmente adatti alle strutture ricorsive. Un albero binario o una lista concatenata si legge chiaramente come un insieme di casi.
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)Pattern matching sugli enum
Poiché gli enum sono sealed, il compilatore può verificare l'esaustività di un match. L'assenza di un caso genera un avviso.
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))Enum compatibili con Java
Aggiunga il comportamento di extends java.lang.Enum derivando automaticamente da scala.reflect.Enum; per una vera interoperabilità con Java, scriva enum X extends Enum[X]... tuttavia, nella maggior parte dei casi, si usa la forma semplice, che garantisce una buona interoperabilità con Java quando necessario.
enum Suit:
case Hearts, Diamonds, Clubs, Spades
object Main:
def main(args: Array[String]): Unit =
println(Suit.values.length)
println(Suit.Spades.ordinal)Combinare campi e metodi
È possibile combinare casi parametrizzati e metodi condivisi per creare modelli di dominio ricchi.
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))Quando usare enum
Scelga enum quando dispone di un insieme chiuso di alternative o di un tipo di dati algebrico.
- Casi semplici per enumerazioni ordinarie.
- Casi parametrizzati per ADT e tipi somma.
- I controlli gratuiti di esaustività rendono sicuri i refactoring.
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)Verifica rapida
Verifichi la sua comprensione degli enum di Scala 3.
Riepilogo
Ha imparato a usare gli enum di Scala 3.
- La sintassi concisa di
enumsostituisce il boilerplate dei sealed trait. - Gli enum semplici ottengono
values,valueOfeordinal. - I casi possono accettare parametri per contenere dati associati.
- Gli enum generici e ricorsivi modellano gli ADT.
- La natura sealed consente il pattern matching esaustivo.
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)Domande Frequenti
La lezione «Enum in Scala 3» è gratuita?
Sì — il testo completo di «Enum in Scala 3» è 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 Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Enum in Scala 3»?
Nuova sintassi degli enum Eserciti Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Enum in Scala 3»?
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 Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming 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.