Scala——模式匹配和样例类

原文发表于：http://nerd-is.in/2013-09/scala-learning-pattern-matching-and-case-classes/

Scala强大的模式匹配机制，可以应用在switch语句、类型检查以及“析构”等场合。样例类对模式匹配进行了优化。

更好的switch

 

 

 

1 2 3 4 5 6 7 8

varsign=... valch:Char=...   chmatch{   case'+'=>sign=1   case'-'=>sign=-1   case_=>sign=0 }

上面代码中，case _模式对应于switch语句中的default，能够捕获剩余的情况。如果没有模式能匹配，会抛出MatchError。而且不像常见的switch语句，在一种模式匹配之后，需要使用break来声明分支不会进入下一个分支。

match是表达式，不是语句，所以是有返回值的，故可将代码简化：

 

 

1 2 3 4 5

sign=chmatch{   case'+'=>1   case'-'=>-1   case_=>0 }

match表达式中可以使用任何类型。模式总是从上往下进行匹配。

守卫

看代码就好，与if表达式的守卫相同作用：

 

 

1 2 3 4 5 6

chmatch{   case'+'=>sign=1   case'-'=>sign=-1   case_ifCharacter.isDigit(ch)=>digit=Character.digit(ch,10)   case_=>sign=0 }

 

模式中的变量

如果在case关键字后跟着一个变量名，那么匹配的表达式会被赋值给那个变量。case _是这个特性的一个特殊情况，变量名是_。

 

 

1 2 3 4 5 6

"Hello, world"foreach{c=>println(     cmatch{       case' '=>"space"       casech=>"Char: "+ch     } )}

经过我的尝试，在如果变量名是_，那么在=>后使用_是不行的。

在模式中使用变量可能会与常量冲突。

 

 

1 2 3 4 5

importscala.math._ xmatch{   casePi=>...   ... }

在上面的代码中，要如何判断Pi这个标志符是一个用来匹配的常量还是模式中的变量？规则是：变量比需要以小写字母开始。如果有常量是小写字母开头的，那么需要用反引号将常量名包起来：

 

 

1 2 3 4 5

importjava.io.File._ strmatch{   case`pathSeparator`=>...   ... }

 

类型模式

相比使用isInstanceOf来判断类型，使用模式匹配更好。

 

 

1 2 3 4 5 6

objmatch{   casex:Int=>x   cases:String=>Integer.parseInt(s)   case_:BigInt=>Int.MaxValue   case_=>0 }

在匹配类型时，需要使用一个变量名，否则就是使用对象本身来进行匹配了。

 

 

1 2 3 4

objmatch{   case_:BigInt=>Int.MaxValue  // 匹配任何类型为BigInt的对象   caseBigInt=>-1  // 匹配类型为Class的BigInt对象 }

因为匹配是发生在运行期的，而且JVM中泛型的类型信息会被擦掉，因此不能使用类型来匹配特定的Map类型（大部分集合类型也都不可以吧）：

 

 

1 2	casem:Map[String,Int]=>...  // 不行 casem:Map[_,_]=>...  // 匹配通用的Map，OK

但对于数组来说，类型信息是完好的，所以可以在Array上匹配。

匹配数组、列表和元组

 

 

 

1 2 3 4 5 6

arrmatch{   caseArray(0)=>"0"  // 匹配包含0的数组   caseArray(x,y)=>x+" "　＋y  // 匹配任何带有两个元素的数组，并将元素绑定到x和y   caseArray(0,_*)=>"0 ..."  // 匹配任何以0开始的数组   case_=>"something else" }

下面的模式匹配，功能与上面的代码是一样的，不过将数组换成了列表。

 

 

1 2 3 4 5 6

lstmatch{   case0::Nil=>"0"   casex::y::Nil=>x+" "+y   case0::tail=>"0 ..."   case_=>"something else" }

与上面两个例子差不多，模式匹配也可以使用在元组上。

注意到变量将会被绑定到这三种数据结构的不同部分上，这种操作被称为“析构”。

提取器

在上一节中，使用模式匹配来对数组、列表和元组进行了匹配，在这个过程的背后的是提取器（extractor）机制。使用unapply来提取固定数量的对象，使用unapplySeq来提取一个序列。

在前面的代码 case Array(0, x) => ...中， Array(0, x)部分实际上是使用了伴生对象中的提取器，实际调用形式是： Array.unapplySeq(arr)。根据Doc，提取器方法接受一个Array参数，返回一个Option。

正则表达式是另一个适用提取器的场景。正则有分组时，可以用提取器来匹配分组：

 

 

1 2 3 4

valpattern="([0-9]+) ([a-z]+)".r "99 bottles"match{   casepattern(num,item)=>... }

 

变量声明中的模式

在变量声明中的模式对于返回对偶（更广一点也可以用在元组上吧？）的函数来说很有用。

 

 

1 2 3

val(x,y)=(1,2) val(q,r)=BigInt(10)/%3  // 返回商和余数的对偶 valArray(first,second,_*)=arr  // 将第一和第二个分别给first和second

 

for表达式中的模式

这一部分的内容多在介绍for表达式时提过了，不过当时并没有意识到使用的是模式。

 

 

1 2 3 4 5 6 7

importscala.collection.JavaConversions.propertiesAsScalaMap   for((k,v)<-System.getProperties())  // 这里使用了模式   println(k+" -> "+v)   for((k,"")<-System.getProperties())  // 失败的匹配会被忽略，所以只打印出值为空的键   println(k)

 

样例类

样例类是种特殊的类，经过优化以用于模式匹配。

 

 

1 2 3 4 5 6 7

abstractclassAmount // 继承了普通类的两个样例类 caseclassDollar(value:Double)extendsAmount caseclassCurrency(value:Double,unit:String)extendsAmount   // 样例对象 caseobjectNothing extendsAmount

使用：

 

 

1 2 3 4 5

amtmatch{   caseDollar(v)=>"$"+v   caseCurrency(_,u)=>"Oh noes, I got "+u   caseNothing=>""  // 样例对象没有() }

在声明样例类时，下面的过程自动发生了：

• 构造器的每个参数都成为val，除非显式被声明为var，但是并不推荐这么做；
• 在伴生对象中提供了apply方法，所以可以不使用new关键字就可构建对象；
• 提供unapply方法使模式匹配可以工作；
• 生成toString、equals、hashCode和copy方法，除非显示给出这些方法的定义。

除了上述之外，样例类和其他类型完全一样，方法字段等。

copy方法和带名参数

样例类的copy方法创建一个与现有对象相同的新对象。可以使用带名参数来修改某些属性：

 

 

1 2 3

valamt=Currency(29.95,"EUR") valprice=amt.copy(values=19.95) valprice=amt.copy(unit="CHF")

 

case语句中的中置表示法

如果unapply方法产出一个对偶，则可以在case语句中使用中置表示法。对于有两个参数的样例类，可以使用中置表示法。

 

 

1	amtmatch{caseaCurrencyu=>...}  // 等于case Currency(a, u)

这个特性的本意是要匹配序列。举例，List对象要么是Nil，要么是样例类::。所以可以：

 

 

1	lstmatch{caseh::t=>...}  // 等同于case ::(h, t)，调用::.unapply(lst)

多个中置表达式放在一起时会比普通的形式更加易读。

匹配嵌套结构

这个解释起来有点绕。

 

 

1 2 3 4 5 6 7 8 9 10 11

abstarct classItem caseclassArticle(description:String,price:Double)extendsItem caseclassBundle(description:String,price:Double,items:Item*)extendsItem   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)   ) )

模式可以匹配到特定的嵌套：

 

 

1	caseBundle(_,_,Article(descr,_),_*)=>...

上面的代码中descr这个变量被绑定到第一个Article的description。另外还可以使用@来将值绑定到变量：

 

 

1 2	// art被绑定为第一个Article，rest是剩余的Item序列 caseBundle(_,_,art@Article(_,_),rest@_*)=>...

下面是个使用了模式匹配来递归计算Item价格的函数。

实际应用

 

 

1 2 3 4

defprice(it:Item):Double=itmatch{   caseArticle(_,p)=>p   caseBundle(_,disc,its@_*)=>its.map(price_).sum-disc }

 

密封类

当使用样例类来做模式匹配时，如果要让编译器确保已经列出所有可能的选择，可以将样例类的通用超类声明为sealed。

密封类的所有子类都必须在与该密封类相同的文件中定义。

如果某个类是密封的，那么在编译期所有的子类是可知的，因而可以检查模式语句的完整性。

让所有同一组的样例类都扩展某个密封的类或特质是个好的做法。

模拟枚举

可以使用样例类来模拟枚举类型：

 

 

1 2 3 4 5 6 7 8 9 10

sealedabstractclassTrafficLightColor caseobjectRedextendsTrafficLightColor caseobjectYellowextendsTrafficLightColor caseobjectGreenextendsTrafficLightColor   colormatch{   caseRed=>"stop"   caseYellow=>"hurry up"   caseGreen=>"go" }

 

Option类型

Option类型用来表示可能存在也可能不存在的值。样例子类Some包装了某个值，而样例对象None表示没有值。Option支持泛型。

 

 

1 2 3 4

scores.get("Alice")match{   caseSome(score)=>println(score)   caseNome=>println("No score") }

 

偏函数（L2）

被包在花括号内的一组case语句是一个偏函数。

偏函数是一个并非对所有输入值都有定义的函数，是PartialFunction[A, B]类的一个实例，其中A是参数类型，B是返回类型。该类有两个方法：apply方法从匹配的模式计算函数值；isDefinedAt方法在输入至少匹配其中一个模式时返回true。

 

 

1 2 3 4

valf:PartialFunction[Char,Int]={case'+'=>1;case'-'=>-1} f('-')  // 返回-1 f.isDefinedAt('0')  // false f('0')  //抛出MatchError