Filtrage par motifs Scala
Scala fournit un puissant mécanisme de correspondance de motifs, et il est également largement utilisé.
Une correspondance de motif contient une série d'alternatives, chacune commençant par le mot-clécase. Chaque alternative contient un motif et une ou plusieurs expressions. Le symbole de flèche=>sépare le motif et les expressions.
Voici un exemple simple de correspondance de motifs sur une valeur entière :
Exemple
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test many
match correspond à switch en Java, mais s'écrit après l'expression du sélecteur. C'est-à-dire :selector match { alternatives }.
L'expression match est évaluée en essayant chaque motif dans l'ordre écrit dans le code. Dès qu'un case correspondant est trouvé, les case restants ne continueront pas à être mis en correspondance.
Voyons maintenant un exemple de correspondance de motifs pour différents types de données :
Exemple
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"
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test 2 many one scala.Int
Dans l'exemple, le premier case correspond à la valeur entière 1, le deuxième case correspond à la valeur de chaîne two, et le troisième case correspond à un motif de type, utilisé pour déterminer si la valeur passée est un entier. Par rapport à l'utilisation de isInstanceOf pour déterminer le type, l'utilisation de la correspondance de motifs est préférable. Le quatrième case représente l'alternative par défaut de correspondance complète, c'est-à-dire l'élément match lorsque aucune autre correspondance n'est trouvée, similaire à default dans switch.
Utilisation des classes case
Une définition de classe qui utilise le mot-clé case est une classe case. Les classes case sont un type spécial de classe, optimisées pour la correspondance de motifs.
Voici un exemple simple de case class:
Exemple
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("Salut Alice!")
case Person("Bob", 32) => println("Salut Bob!")
case Person(name, age) =>
println("Âge: " + age + " an, nom: " + name + "?")
}
}
}
// Case class
case class Person(name: String, age: Int)
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test Hi Alice! Hi Bob! Age: 32 year, name: Charlie?
Lorsqu'une classe case est déclarée, les éléments suivants se produisent automatiquement :
- Chaque paramètre du constructeur devient un val, sauf s'il est explicitement déclaré comme var, mais ce n'est pas recommandé ;
- Une méthode apply est fournie dans l'objet compagnon, de sorte que les objets peuvent être construits sans utiliser le mot-clé new ;
- Une méthode unapply est fournie pour faire fonctionner le pattern matching ;
- Les méthodes toString, equals, hashCode et copy sont générées, sauf si ces méthodes sont explicitement définies.