Corrispondenza dei modelli di Scala

Scala offre un potente meccanismo di matching di modelli e ha un'ampia applicazione.

Un modello di matching contiene una serie di opzioni, ciascuna inizia con la parola chiave case.Ogni opzione contiene un modello e uno o più espressioni. Il simbolo di frecce => che separano i modelli e le espressioni.

Di seguito è riportato un esempio semplice di matching di valori numerici interi:

object Test {
　　　def main(args: Array[String]) {
　　　　　　println(matchTest(3))
　　　}
　　　def matchTest(x: Int): String = x match {
　　　　　　case 1 => "uno"
　　　　　　case 2 => "two"
　　　　　　case _ => "molte"
　　　}
}

Eseguendo il codice sopra, il risultato sarà:

$ scalac Test.scala　
$ scala Test
molte

match corrisponde a switch in Java, ma scritto dopo l'espressione selettore. Vale a dire: Selettore match {opzioni}

L'espressione match esegue il calcolo tentando di abbinare ogni modello in base all'ordine di scrittura del codice, e non continua a abbinare altri modelli una volta trovato un modello corrispondente.

Ora guardiamo un esempio di matching di modelli con tipi di dati diversi:

object Test {
　　　def main(args: Array[String]) {
　　　　　　println(matchTest("two"))
　　　　　　println(matchTest("test"))
　　　　　　println(matchTest(1))
　　　　　　println(matchTest(6))
　　　}
　　　def matchTest(x: Any): Any = x match {
　　　　　　case 1 => "uno"
　　　　　　case "two" => 2
　　　　　　case y: Int => "scala.Int"
　　　　　　case _ => "molte"
　　　}
}

Eseguendo il codice sopra, il risultato sarà:

$ scalac Test.scala　
$ scala Test
2
molte
uno
scala.Int

Nel esempio, la prima case corrisponde al valore numerico intero 1, la seconda case corrisponde al valore stringa "two", la terza case corrisponde a un modello di tipo utilizzato per determinare se il valore传入 è un intero, rispetto all'uso di isInstanceOf per determinare il tipo, il matching di modello è meglio. La quarta case rappresenta l'opzione di matching di default, ossia l'opzione di matching quando non si trova alcun altro matching, simile al default di switch.

Uso delle classi di esempio

Le definizioni di classe utilizzando la parola chiave case sono classi di esempio (case classes), che sono un tipo speciale di classe ottimizzata per il matching di modelli.

Di seguito è riportato un semplice esempio di classe di esempio:

object Test {
　　　def main(args: Array[String]) {
　　　　　　　　val alice = new Person("Alice", 25)
　　　　　　　　val bob = new Person("Bob", 32)
　　　　　　　　val charlie = new Person("Charlie", 32)
　　　
　　　　for (person <- List(alice, bob, charlie)) {
　　　　　　　　person match {
　　　　　　　　　　　　case Person("Alice", 25) => println("Ciao, Alice!")
　　　　　　　　　　　　case Person("Bob", 32) => println("Ciao, Bob!")
　　　　　　　　　　　　case Person(name, age) =>
　　　　　　　　　　　　　　　println("Età: " + age + " anno, nome: " + name + "?")
　　　　　　　　　}
　　　　　　}
　　　}
　　　// Classe di esempio
　　　case class Person(name: String, age: Int)
}

Eseguendo il codice sopra, il risultato sarà:

$ scalac Test.scala　
$ scala Test
Ciao, Alice!
Ciao, Bob!
Età: 32 anni, nome: Charlie?

Quando si dichiara una classe di esempio, il seguente processo avviene automaticamente:

• Ogni parametro del costruttore diventa val, a meno che non venga dichiarato esplicitamente come var, ma non è raccomandato farlo;

• Il metodo apply è fornito nell'oggetto companion, quindi è possibile costruire oggetti senza utilizzare la parola chiave new;

• Fornisce il metodo unapply per far funzionare la corrispondenza dei modelli;

• Genera i metodi toString, equals, hashCode e copy, a meno che non venga fornita esplicitamente la definizione di questi metodi.