Scala学习（十四）模式匹配和样例类

时间 2019-11-06

标签 scala 学习十四模式匹配样例栏目 Scala 繁體版

原文原文链接

1.更好的switch

如下是Scala中C风格switch语句的等效代码：git

var sign = ...
val ch: Char = ...

ch match {
    case '+' => sign = 1
    case '-' => sign = -1
    case _ => sign = 0
}

在这里，case _ 与 C 语言的 default 相同，能够匹配任意的模式，因此要注意放在最后。有这样一个能捕获全部模式是有好处的。若是没有模式可以匹配，代码会抛出MatchError。正则表达式

C 语言的 switch中的case语句必须使用break才能推出当前的分支，不然会继续执行后面的分支，直到遇到break或者结束；而Scala的模式匹配只会匹配到一个分支，不须要使用break语句，由于它不会掉入到下一个分支。数组

match是表达式，与if同样，是有值的：安全

sign = ch match {
    case '+' => 1
    case '-' => -1
    case _ => 0
}

用|来分隔多个选项：app

prefix match{
    case "0" | "0x" | "0X" => ...
    ...
}

你能够在match表达式中使用任何类型，而不只仅是数字。函数

2.守卫

在C语言中，若是你想用switch判断字符是数字，则必须这么写：优化

switch(ch) {
    case '0':
    ...
    case '9': do something; break;
    default: ...; 
}

你要写10条case语句才能够匹配全部的数字；而在Scala中，你只须要给模式添加守卫：spa

ch match {
    case '+' => 1
    case '-' => -1
    case _ if Character.isDigit(ch) => digit = Character.digit(ch, 10)
    case _ => 0
}

模式老是自上而下进行匹配。scala

3.模式中的变量

若是case关键字后面跟着一个变量名，那么匹配的表达式会被赋值给那个变量。rest

str(i) match {
    case '+' => 1
    case '-' => -1
    case ch => digit = Character.digit(ch, 10)
}

// 在守卫中使用变量

str(i) match {
case ch if Character.isDigit(ch) => digit = Character.digit(ch, 10)
...
}

注意： Scala是如何在模式匹配中区分模式是常量仍是变量表达式：规则是变量必须是以小写字母开头的。若是你想使用小写字母开头的常量，则须要将它包在反单引号中。

4.类型模式

你能够对表达式的类型进行匹配，例如：

obj match {
    case x: Int => x
    case s: String => Integer.parseInt(s)
    case _: BigInt => Int.MaxValue
    case - => 0
}

此时obj对象的类型必须是模式匹配中全部类型公共的超类，不然报错。

在Scala中咱们更倾向于选择模式匹配而不是isInstanceOf/asInstanceOf。

注意：当你在匹配类型的时候，必须给出一个变量名，不然你将会拿对象自己来进行匹配：

obj match {
    case _: BigInt => Int.MaxValue // 匹配任何类型为BigInt的对象
    case BigInt => -1 // 匹配类型为Class的BigInt对象
}

注意：匹配发生在运行期，Java虚拟机中泛型的类型信息是被擦掉的。所以，你不能用类型来匹配特定的Map类型。

case m: Map[String, Int] => ... // error
// 能够匹配一个通用的映射
case m: Map[_, _] => ... // OK

// 可是数组做为特殊状况，它的类型信息是无缺的，能够匹配到Array[Int]
case m: Array[Int] => ... // OK

5.匹配数组、列表和元组

要匹配数组的内容，能够在模式中使用Array表达式：

arr match {
   case Array(0) => "0" // 任何包含0的数组
   case Array(x, y) => x + " " + y // 任何只有两个元素的数组，并将两个元素本别绑定到变量x 和 y
   case Array(0, _*) => "0 ..." // 任何以0开始的数组
   case _ => "Something else"
}

若是你想讲匹配到 _* 的变长度参数绑定到变量，你能够用 @ 表示法，就像这样：

case Array(x,rest @ _*) => rest.min

一样也能够应用到List。或者你也可使用::操做符

lst match {
   case 0 :: Nil => "0"
   case x :: y :: Nil => x + " " + y
   case 0 :: tail => "0 ..."
   case _ => "Something else"
}

对于元组：

pair match {
   case (0, _) => "0, ..."
   case (y, 0) => y + " 0"
   case _ => "neither is 0"
}

说明：若是模式有不一样的可选分支，你就不能使用除下划线外的其余变量命名。

pair match{
   case (_,0) | (0,_) => ... //ok 若是其中一个是0
   case (x,0) | (0,x) => ... //错误——不能对可选分支作变量绑定
}

6.提取器

在上面的模式是如何匹配数组、列表、元组的呢？Scala是使用了提取器机制----带有从对象中提取值的unapply 或 unapplySeq方法的对象。其中，unapply方法用于提取固定数量的对象；而unapplySeq提取的是一个序列，可长可短。

arr match {
    case Array(0, x) => ... // 匹配有两个元素的数组，其中第一个元素是0，第二个绑定给x
}

Array伴生对象就是一个提取器----它定义了一个unapplySeq方法。该方法执行时为：Array.unapplySeq(arr) 产出一个序列的值。第一个值于0进行比较，第二个赋值给x。

正则表达式也能够用于提取器的场景。若是正则表达式有分组，能够用模式提取器来匹配每一个分组：

val pattern = "([0-9]+) ([a-z]+)".r
    "99 bottles" match {
    case pattern(num, item) => ... // 将num设为99， item设为"bottles"
}

pattern.unapplySeq("99",bottles)交出的是一系列匹配分组的字符创。这些字符串被分别赋值给了num和item。

注意：在这里提取器并非一个伴生对象，而是一个正则表达式对象。

7.变量声明模式

在变量声明中也可使用变量的模式匹配：

val (x, y) = (1, 2) // 把x定义为1， 把y定义为2.
val (q, r) = BigInt(10) /% 3 // 匹配返回对偶的函数

// 匹配任何带有变量的模式
val Array(first, second, _*) = arr

上述代码将数组arr的第一个和第二个元素分别赋值给了first和second，并将剩余的元素做为一个Seq复制给了rest

8.for表达式中的模式

你能够在for推导式中使用带变量的模式。

import scala.collection.JavaConversions.propertiesAsScalaMap
for ((k, v) <- system.getProperties()) {
    println(k + " -> " + v)
}

对应映射每个(键，值)对偶，k被绑定到键，而v被绑定到值。

在for推导式中，失败的匹配将被安静的忽略。例如：

// 只匹配值为空的状况
for ((k, "") <- system.getProperties()) {
    println(k)
}

你也可使用守卫。注意if关键字出如今 <- 以后。

for ((k, v) <- system.getProperties() if v == "") {
    println(k)
}

9.样例类

样例类是一种特殊的类，它们通过优化以被用于模式匹配。

abstract class Amount
    case class Dollar(value; Double) extends Amount
    case class Currency(value: Double, unit: String) extends Amount

// 针对单例的样例对象
case object Nothing extends Amount

// 将Amount类型的对象用模式匹配来匹配到它的类型，并将属性值绑定到变量：
amt match {
    case Dollar(v) => "$" + v
    case Currency(_, u) => "Oh noes, I got " + u
    case Nothing => ""
}

当你声明样例类时，以下事情会自动发生：

构造器中每个参数都成为val----除非它被显示的声明为var（不建议这样作）
在伴生对象中提供apply方法让你不用new关键字就可以构造出相应的对象，例如Dollar(2)或Currency(34, "EUR")
提供unapply方法让模式匹配能够工做
将生成toString、equals、hashCode和copy方法----除非你显示的给出这些方法的定义。

除了上述节点外，样例类和其余类彻底同样。你能够添加方法和字段，扩展他们，等等。

10.copy方法和带名参数

样例类的copy方法建立一个与现有对象值相同的新对象。例如：

val amt = Currency(29.95, "EUR")
val price = amy.copy() // 生成了一个新的Currency(29.95, "EUR")对象
val price2 = amt.copy(value = 19.95) //至关于执行了 Currency(19.95, "EUR")
val price3 = amt.copy(unit = "CHF") //至关于执行了 Currency(29.95, "CHF")

11.case语句中的中置表示法

若是unapply方法产出一个对偶，则能够在case语句中使用中置表示法。尤为是对于两个参数的样例类，你可使用中置表示法来表示它。

amt match { case a Currency u => ... } // 等同于 case Currency(a, u)

这个特性的本意是要匹配序列。例如：每一个List对象要么是Nil，要么是样例类::，定义以下：

case class ::[E](head: E, tail: List[E]) extends List[E]
// 所以你能够这么写
lst match {
    case h :: t => ... // 等同于 case ::(h, t)， 将调用::.unapply(lst)
}

说明：中置表示法用于任何返回对偶的unapply方法。如下是一个示例：

case object +: {

    def unapply[T](input: List[T]) = 

        if (input.isEmpty) None else Some((input.head, input.tail))

}

这样一来你就能够用+:来构析列表了

1 +: 7 +: 2 +: 9 +: Nil match{

    case first +: second +: rest => first + second + rest.length

}

12.嵌套匹配

样例类常常被用于嵌套结构。例如，某个商店收买的物品。有时，咱们会将物品捆绑在一块儿打折出售。

abstract class Item
    //物品样例类参数为 描述、物品价格
    case class Article(description: String, price: Double) extends Item
    //减价出售物品样例类参数为 描述、折扣、物品变长参数
    case class Bundle(description: String, discount: Double, items: Item*) extends Item

// 产生嵌套对象
Bundle("Father's day special", 20.0, 
    Article("Scala for the Impatient", 39.95), 
    Bundle("Anchor Distillery Sampler", 10.0,
        Article("Old Potrero Straight Rye Whisky", 79.95),
        Article("Junipero Gin", 32.95)
    )
)

// 模式匹配到特定的嵌套，好比：
case Bundle(_, _, Article(descr, _), _*) => ...

上述代码将descr绑定到Bundle的第一个Article的描述。你也能够 @ 表示法将嵌套的值绑定到变量

case Bundle(_, _, art @ Article(_, _), rest @ _*) => ...

这样，art就是Bundle中的第一个Article，而rest则是剩余Item的序列。 _*表明剩余的Item。

该特性实际应用，如下是一个计算某Item价格的函数

def price(it: Item): Double = it match {
    case Article(_, p) => p
    case Bundle(_, disc, its @ _*) => its.map(price _).sum - disc
}

13.样例类是邪恶的吗

样例类适用于那种标记了不会改变的结构。例如Scala的List就是用样例类实现的。

abstract class List
    case object Nil extends List
    case class ::(head: Any, tail: List) extends List

当用在合适的地方时，样例类是十分便捷的，缘由以下：

模式匹配一般比继承更容易把咱们引向更精简的代码。
构造时不须要用new的符合对象更加易读
你将免费得到toString、equals、hashCode和copy方法。

对于样例类：

case class Currency(value: Double, unit: String)

一个Currency(10, "EUR")和任何其余Currency(10, "EUR")都是等效的，这也是equals和hashCode方法实现的依据。这样的类一般都是不可变的。对于那些带有可变字段的样例类，咱们老是从那些不会改变的字段来计算和得出其哈希值，好比用ID字段。

14.密封类

密封类是指用sealed修饰的类。密封类的全部子类都必须在与该密封类相同的文件中定义。这样作的好处是：当你用样例类来作模式匹配时，你可让编译器确保你已经列出了全部可能的选择，编译器能够检查模式语句的完整性。

sealed abstract class Amount
    case class Dollar(value: Double) extends Amount
    case class Currency(value: Double, unit: String) extends Amunt

举例来讲，若是有人想要为欧元添加另外一个样例类：

case class Euro(value: Double) extends Amount

那么，上述的样例类必须与Amount类在一个文件中。

15.Option类型

标准类库中的Option类型用样例类来表示那种可能存在也可能不存在的值。样例子类Some包装了某个值，例如：Some("Fred")。而样例对象None表示没有值。

这笔使用空字符串的意图更加清晰，比使用null来表示缺乏某值得作法更加安全。

Option支持泛型。举例来讲Some("Fred")的类型为Option[String]。

Map类的get方法返回一个Option。若是对于给定的键没有值，则get返回None。若是有值，就会将改值包装在Some中返回。

你能够用模式匹配来分析这样一个值：

val p = scores.get("Alice")

p match{
    case Some(score) => println(score)
    case None => println("No score")
}

有点麻烦，你也可使用isEmpty和get：

if(p.isEmpty) println("No score") else println(p.get)

这也很麻烦。用getOrElse更好：

println(p.getOrElse("No score")) //若是p为None，getOrElse将返回No score

处理可选值（Option）更强力的方式是将他们当作拥有0或1个元素的集合。你能够用for循环来访问这个元素：

for(score <- p) println(score)

若是p是None，则什么都不会发生。若是他是一个Some，那么循环将被执行，而sorce将会被绑上可选值内容。

你也能够用诸如map、filter或foreach方法。例如：

val b = p.map( _ + 1)  //Some(score + 1) 或 None

val a = p.filter(_ > 5) //若是score > 5，则获得Some(score )，不然获得None

p.foreach(println _) //若是存在，打印score值

提示：在从一个可能为null的值建立Option时，你可能简单地使用Option(value)。若是value为null，结果就是None；其他状况获得Some(value)。

16.偏函数

被包含在花括号内的一组case语句是一个偏函数，一个并不是对全部输入值都有定义的函数。他是PartialFunction[A, B]类的一个实例（A是参数类型、B是返回类型）该类有两个方法：apply方法从匹配到的模式计算函数值，而isDefinedAt方法在输出至少匹配其中一个模式时返回true。

例如：

val f: PartialFunction[Char, Int] = { case '+' => 1; case '-' => -1 }
f('-') // 调用 f.apply('-')， 返回-1
f.isDefinedAt('0') // fase
f('0') // 抛出MatchError

有一些方法接收PartialFunction做为参数。举例来讲，GenTraversable特质的collect方法将一个偏函数应用到全部在该偏函数有定义的元素，并返回包含这些结果的序列。

"-3+4".collect {case '+' => 1;  case '-' => -1 }  // Vector(-1, 1)

Seq[A]是一个PartialFunction[Int,A]，而Map[K,V]是一个PartialFunction[K,V]。例如，你能够将映射传入collect：

val names = Array("Alice","Bob","Carmen")

var scores = Map("Alice"->10,"Carmen"→7)

names.collects(scores )  //将交出Array(10,7)

lift方法将PartialFunction[T,R]变成一个返回类型为Option[R]的常规函数。

var f :PartialFunction[Char, Int] = {case '+' => 1;case '-' => -1}

var g = f.lift //一个类型为Char => Option[Int]的函数

这样一来，g('-')获得Some(-1)，而g('*')获得None。

相反，你也能够调用Function.unlift将Option[R]的函数变成一个偏函数。

说明：try语句的catch字句是一个偏函数。你甚至可使用一个持有函数的变量。

def tryCatch[T](b: => T, catcher: PartialFunction[Throwable, T]) = try {b} catch catcher

而后，你就能够像以下这样提供一个定制的catch子句：

val result = tryCatch(str.toInt, { case _: NumberFormatException => -1})