Correspondance de modèles Scala

Scala fournit un puissant mécanisme de correspondance de modèles et est largement utilisé.

Une correspondance de modèle consiste en une séquence d'alternatives, chacune commençant par le mot-clé case. Chaque alternative contient un modèle et une ou plusieurs expressions. Le symbole de flèche => sépare les motifs et les expressions.

Ce qui suit est un exemple simple de correspondance de modèle de valeur entière :

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écutez le code ci-dessus, le résultat de sortie est :

$ scalac Test.scala 
$ scala Test
many

match correspond au commutateur en Java, mais est écrit après l'expression du sélecteur. C'est-à-dire : Le sélecteur correspond à {alternative}.

L'expression de correspondance termine le calcul en essayant chaque modèle dans l'ordre dans lequel le code est écrit. Tant qu'un cas correspondant est trouvé, les cas restants ne continueront pas à correspondre.

Regardons ensuite une correspondance de modèles de différents types de données :

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écutez le code ci-dessus, le résultat de sortie est :

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

Le premier cas de l'instance correspond à le type entier Valeur 1, le deuxième cas correspond à la valeur de chaîne deux, le deuxième cas correspond à la valeur de chaîne deux et le troisième cas correspond au modèle de type, qui est utilisé pour déterminer si la valeur entrante est un entier comparé. en utilisant isInstanceOf pour déterminer le type, il est préférable d'utiliser la correspondance de modèles. Le quatrième cas représente l'alternative de correspondance complète par défaut, c'est-à-dire la correspondance lorsqu'aucune autre correspondance n'est trouvée, similaire à la correspondance par défaut dans switch.

Utilisation d'exemples de classes

Les définitions de classe qui utilisent le mot-clé case sont des classes de cas. Les classes de cas sont des classes spéciales optimisées pour être utilisées pour la correspondance de modèles.

Ce qui suit est un exemple simple de l'exemple de classe :

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("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)
}

Exécutez le code ci-dessus, le résultat de sortie est :

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

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

• Chaque paramètre du constructeur devient un val, à moins qu'il ne soit explicitement déclaré comme var, mais cela n'est pas recommandé

• L'application ; est fournie dans l'objet compagnon, donc l'objet peut être construit sans utiliser le nouveau mot-clé

• La méthode unapply est fournie pour que la correspondance de modèles puisse fonctionner

• Générer les méthodes toString, equals, hashCode et copy sauf si la définition de ces méthodes est explicitement donnée.