Scala - Correspondance de motifs

La correspondance de modèles est la deuxième fonctionnalité la plus utilisée de Scala, après les valeurs de fonction et les fermetures. Scala fournit un excellent support pour la correspondance de modèles, dans le traitement des messages.

Une correspondance de modèle comprend une séquence d'alternatives, chacune commençant par le mot-clé case. Chaque alternative comprend unpattern et un ou plusieurs expressions, qui sera évalué si le modèle correspond. Un symbole de flèche => sépare le motif des expressions.

Essayez l'exemple de programme suivant, qui montre comment faire une correspondance avec une valeur entière.

Exemple

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

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

many

Le bloc avec les instructions case définit une fonction, qui mappe des entiers sur des chaînes. Le mot-clé match fournit un moyen pratique d'appliquer une fonction (comme la fonction de correspondance de modèle ci-dessus) à un objet.

Essayez l'exemple de programme suivant, qui compare une valeur à des modèles de types différents.

Exemple

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

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

2
many
one

Correspondance à l'aide de classes de cas

le case classessont des classes spéciales utilisées dans la mise en correspondance de modèles avec des expressions de casse. Syntaxiquement, ce sont des classes standard avec un modificateur spécial:case.

Essayez ce qui suit, il s'agit d'un exemple de correspondance de modèle simple utilisant la classe case.

Exemple

object Demo {
   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("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) => println(
               "Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   case class Person(name: String, age: Int)
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?

L'ajout du mot-clé case amène le compilateur à ajouter automatiquement un certain nombre de fonctionnalités utiles. Le mot-clé suggère une association avec des expressions de cas dans la correspondance de modèle.

Tout d'abord, le compilateur convertit automatiquement les arguments du constructeur en champs immuables (vals). Le mot-clé val est facultatif. Si vous voulez des champs mutables, utilisez le mot-clé var. Ainsi, nos listes d'arguments de constructeur sont désormais plus courtes.

Deuxièmement, le compilateur implémente automatiquement equals, hashCode, et toStringméthodes à la classe, qui utilisent les champs spécifiés comme arguments du constructeur. Ainsi, nous n'avons plus besoin de nos propres méthodes toString ().

Enfin, aussi, le corps de Person La classe devient vide car il n'y a pas de méthodes à définir!