1.更好的switch
以下是Scala中C风格switch语句的等效代码:
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
}
用|来分隔多个选项:
prefix match{
case "0" | "0x" | "0X" => ...
...
}
你可以在match表达式中使用任何类型,而不仅仅是数字。
2.守卫
在C语言中,如果你想用switch判断字符是数字,则必须这么写:
switch(ch) {
case '0':
...
case '9': do something; break;
default: ...;
}
你要写10条case语句才可以匹配所有的数字;而在Scala中,你只需要给模式添加守卫:
ch match {
case '+' => 1
case '-' => -1
case _ if Character.isDigit(ch) => digit = Character.digit(ch, 10)
case _ => 0
}
模式总是自上而下进行匹配。
3.模式中的变量
如果case关键字后面跟着一个变量名,那么匹配的表达式会被赋值给那个变量。
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})