Scala pattern matching

Scala fournit un motif puissant mécanisme correspondant, est également largement utilisé.

Un motif d'adaptation comprend une série de variantes, dont chacun commence avec un mot - clécas.Chacun contient une option de sauvegarde et un motif d'une pluralité d'expressions. Flèche symbole=> sépare les motifs et les expressions.

Ce qui suit est un exemple de valeur entière motif simple correspondant:

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

Mise en œuvre du code ci-dessus, la sortie est:

$ scalac Test.scala 
$ scala Test
many

correspondre à la Java correspondant dans le commutateur, mais écrit après l'expression de sélection. Asavoir: match de sélection {alternatives}.

Par ordre d'expressions pour correspondre au code écrit pour essayer chaque mode pour effectuer le calcul, si elles trouvent il y a un cas de correspondance, correspondant au reste de l'affaire ne va pas continuer.

Ensuite, nous regardons un type de pattern matching de données différentes:

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

Mise en œuvre du code ci-dessus, la sortie est:

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

Des exemples du premier cas correspond à une valeur entière de 1, le second cas correspond à la valeur de chaîne de deux, le second cas correspond à la valeur de chaîne de deux, le troisième cas correspond au type de modèle utilisé pour déterminer si la valeur passée en totalité Type, utilisez isInstanceOf comparés pour déterminer le type, pattern matching est mieux. Le quatrième cas indique les alternatives par défaut-match complet, ce match ne se trouve pas dans l'autre match, un commutateur similaire en défaut.

Utilisez la classe Sample

Utilisez le mot-clé cas est la définition de classe est une classe d'échantillon (classes de cas), la classe de l'échantillon est une classe spéciale, optimisé pour le filtrage.

Ce qui suit est un exemple simple d'une classe de l'échantillon:

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

Mise en œuvre du code ci-dessus, la sortie est:

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

Lorsque vous déclarez un exemple de classe, la procédure suivante se produit automatiquement:

• Chaque constructeur de paramètres sont de plus en val, sauf déclaration explicite que var, mais ce n'est pas recommandé;
• Fournir appliquer les méthodes des objets associés, de sorte que vous pouvez construire des objets ne peuvent pas utiliser le nouveau mot-clé;
• méthode unapply fourni permet le filtrage peut fonctionner;
• Générer toString, est égal, hashCode et mode copie, à moins que l'écran affiche les définitions de ces méthodes.