Une brève discussion sur la correspondance de modèles dans Scala

Le contenu de cet article concerne une brève discussion sur la correspondance de modèles dans Scala. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. La correspondance de modèles scala

la correspondance de modèles peut être considérée comme une fonctionnalité de langage très puissante dans Scala. Bien sûr, cela n'est pas propre à Scala, mais cela ne l'empêche pas de le devenir. scala. Un excellent outil pour le langage.

La correspondance de modèles de Scala est similaire à ceci,

e match {
  case Pattern1 => do Something
  case Pattern2 if-clause => do others
  ...
}

où la variable e est suivie d'une correspondance et d'un bloc de code, où chaque cas correspond à un type de correspondance possible, si la correspondance est réussi, le code après => est exécuté.

Nous pouvons utiliser un exemple plus spécifique pour voir comment fonctionne la correspondance de modèles :

case class Player(name: String, score: Int)
def printMessage(player: Player) = player match {
  case Player(_, score) if score > 100000 =>
    println("Get a job, dude!")
  case Player(name, _) =>
    println("Hey, $name, nice to see you again!")
}

Cela ressemble un peu au switch dans d'autres langues, mais en fait il y a encore beaucoup de différents .

Prenons le commutateur de Java comme exemple. Le commutateur de Java effectue uniquement une correspondance de type de base, puis effectue certaines actions et n'a aucune valeur de retour.

La correspondance de modèles de Scala est beaucoup plus puissante. En plus de faire correspondre des valeurs, elle peut également faire correspondre des types.

def parseArgument(arg: String) = arg match {
    //匹配值
    case "-h" | "--help" => displayHelp
    case "-v" | "--version" => displayVerion
    case whatever => unknownArgument(whatever)
}

def f(x: Any): String = x match {
    //匹配类型
    case i:Int => "integer: " + i
    case _:Double => "a double"
    case s:String => "I want to say " + s
}

En même temps, la correspondance de modèles a une valeur de retour, comme la correspondance ci-dessus, qui renvoie une unité. Nous pouvons également modifier le code ci-dessus pour renvoyer une chaîne :

case class Player(name: String, score: Int)
def message(player: Player) = player match {
  case Player(_, score) if score > 100000 =>
    "Get a job, dude!"
  case Player(name, _) =>
    "Hey, $name, nice to see you again!"
}

Il convient de mentionner que la valeur de retour de la correspondance de modèle est déterminée par le bloc de code dans le premier modèle correspondant.

2. Pourquoi utiliser la correspondance de motifs

Vous découvrirez un problème lorsque vous verrez ceci. La correspondance de motifs n'est-elle pas similaire à if else ? Alors pourquoi utiliser la correspondance de modèles ?

Tout d'abord, nous devons comprendre que la correspondance de modèles fournit essentiellement un moyen pratique de déstructurer les structures de données. En prenant scala comme exemple, la correspondance de modèles applique en fait la fonction de l'extracteur dans scala. méthode unapply () dans la classe.

trait User {
  def name: String
}
class FreeUser(val name: String) extends User
object FreeUser {
  //提取器
  def unapply(user: FreeUser): Option[String] = Some(user.name)
}

  val user: User = new FreeUser("Daniel")
  user match {
    case FreeUser(name) => println("it match here" + name)
    case _ => println("not me")
  }

Après avoir compris l'essence de la correspondance de modèles, vous vous rendrez compte qu'en fait, if else n'est qu'une utilisation typique dans la correspondance de modèles, mais ce n'est pas tout.

En même temps, la correspondance de modèles vous permet de découpler deux choses qui n'appartiennent pas vraiment l'une à l'autre, et rend également votre code plus facile à tester. Par exemple, nous pouvons écrire le code de la partie match ci-dessus comme suit :

  val user: User = new FreeUser("Daniel")
  //将返回结果存在一个常量中
  val message = user match {
    case FreeUser(name) => "it match here" + name
    case _ => "not me"
  }
  //可以随意使用该常量，实现解耦
  println(message)

Cela donnera au code plus de flexibilité et rendra les opérations ultérieures plus pratiques.

Du point de vue de la lisibilité, utiliser beaucoup de codes if else est sans doute plus laid, mais si vous utilisez la correspondance de modèles, le code sera beaucoup plus simple et plus clair, et un code concis sera plus facile à lire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!