Matching de modèles Scala

Scala offre un mécanisme de matching de motifs puissant et largement utilisé.

Un matching de motifs contient une série d'options, chaque débutant par le mot-clé case。Chaque option contient un motif et une à plusieurs expressions. Le symbole de flèche => Séparant les motifs et les expressions.

Voici un exemple simple de matching de motifs avec des valeurs numériques entières :

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

Exécuter le code suivant, le résultat est :

$ scalac Test.scala　
$ scala Test
many

match correspond à switch en Java, mais est écrit après l'expression du sélecteur. C'est-à-dire : Sélecteur match {options}

L'expression match essaie de terminer le calcul en essayant chaque motif dans l'ordre où il est écrit, et arrête de matcher dès qu'il trouve un cas correspondant, sans continuer à matcher les autres cas.

Ensuite, regardons un exemple de matching de motifs avec des types de données différents :

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　=> "one"
　　　　　　case "two" =>　2
　　　　　　case y: Int => "scala.Int"
　　　　　　case _ => "many"
　　　}
}

Exécuter le code suivant, le résultat est :

$ scalac Test.scala　
$ scala Test
2
many
one
scala.Int

Le premier cas de l'exemple correspond à une valeur numérique entière 1，la deuxième clé de cas correspond à la valeur de chaîne "two", la troisième clé de cas correspond à un motif de type, utilisé pour déterminer si la valeur passée en argument est un entier. Par rapport à l'utilisation de isInstanceOf pour判断类型，le matching de motifs est préférable. Le quatrième cas représente l'option de correspondance par défaut, c'est-à-dire l'élément de correspondance lorsque aucune autre correspondance n'est trouvée, similaire à la clé par défaut dans switch.

Utilisation des classes de cas

Une définition de classe utilisant la clé de cas est une classe de cas (case classes), une classe spéciale optimisée pour le matching de motifs.

Voici un exemple simple de classe de cas :

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 {　25) => println("Hi Alice!")
　　　　　　　　　　　　) => println("Hi Alice!")　32) => println("Hi Bob!")
　　　　　　　　　　　　case Person(name, age) =>
　　　　　　　　　　　　　　　println("Âge : "　+　age　+　" year, name: "　+　name　+　"?"
　　　　　　　　　}
　　　　　　}
　　　}
　　　//　Classe d'exemple
　　　case class Person(name: String, age: Int)
}

Exécuter le code suivant, le résultat est :

$ scalac Test.scala　
$ scala Test
Hi Alice!
Hi Bob!
Âge :　32　year, name: Charlie?

Lors de la déclaration d'une classe d'exemple, le processus suivant se produit automatiquement :

• Chaque paramètre du constructeur devient val, sauf s'il est explicitement déclaré comme var, mais cela n'est pas recommandé;

• Une méthode apply est fournie dans l'objet compagnon, donc il est possible de construire des objets sans utiliser le mot-clé new;

• Fournir une méthode unapply pour que le matching de modèle puisse fonctionner;

• Générer les méthodes toString, equals, hashCode et copy, sauf si une définition explicite de ces méthodes est fournie.