scala中的match详解

Scala中提供了比java，c更加强大的switch语句——match，而且不用担心因为忘记写break语句而发生case穿透
1.更好的switch
与if，类似match也是表达式，如下一个用于匹配字符的函数

def charMatch(c: Char) = c match {        case '+' => 1        case '-' => -1        case _ => 0    }

你可以使用任何类型，而不仅仅是数字匹配

def colorMatch(c:Color) = c match {        case Color.RED => 0xff0000        case Color.BLACK => 0x000000        case Color.YELLOW => 0xffff00        case _ => 0    }

2.守卫
我们修改一下例一,可以添加if这样的守卫，来匹配所有数字，守卫可以是任何Boolean条件

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

3.模式中的变量
如果case后跟着一个变量名，那么匹配的表达式会被复制给那个变量,你可以将case _
看做这个特性的一个特殊情况，变量名为_可以通配。

case **ch** if Character.isDigit(**ch**) => Character.digit(**ch**, 10)

变量模式和常量模式如果有冲突，可以用反引号“

import math._    def dMatch(d: String) = d match {        case `Pi` => 3.14        case n => Integer.parseInt(n)        case _ => 0    }

4.类型匹配
这样就不用使用isInstanceOf的操作符判断类型，在用asInstanceOf转换
但是要注意Map和其他有泛型的集合，模式匹配发生在运行期，泛型会被擦掉
Map[Int,Int] 要用Map[_ , _]代替

def anyMatch(obj: Any) = obj match {        case i: Int => i        case s: String => Integer.parseInt(s)        case _: BigInt => Int.MaxValue        case m: Map[_, _] => 1 //       模式匹配发生在运行期          case _ => 0    }

5.匹配数组列表和元组

//  匹配数组，列表和元组    def arrMatch(a: Array[Int]) = a match {        case Array(0) => "0"        case Array(x, y) => x + " " + y        case Array(0, _*) => "0 ..."        case _ => "something else"    }//  case class ::[E] (head :E,tail:List[E]) extends List[E]    def listMatch(l: List[Int]) = l match {        case 0 :: Nil => "0"//          多个中置表达式更易读        case x :: y :: Nil => x + " " + y        case h :: t => h + " " + t.mkString(" ")//      上面的一种写法,将调用：：.unapply(lst)        case ::(h,t) => h        case 0 :: tail => "0 ..."        case _ => "something else"    }    def pairMatch(p: (Int, Int)) = p match {        case (0, _) => "0 ..."        case (y, 0) => y + " 0"        case _ => "neither is 0"    }

6.提取器extractor
提取unapply或unapplySeq方法，已经在别的文章的介绍过了
这里来注意一下了一个正则表达式的场景，正则中的分组匹配，可以用提取器来获取每个分组

//  提取器extractor    val pattern = "([0-9]+) ([a-z]+)".r    def patternMatch(s: String) = s match {        //      这里的提取器不是伴生对象而是提取器对象        case pattern(num, item) => num        case _ => 0    }

7.变量声明中的模式

    val (x,y) = (1,2)//  /%获取商和余数    val (q,r) = BigInt(10) /% 3    val arr = Array(1,2,3)//  提取数组中的第一第二个元素    val Array(f,s,_*) = arr 

8.for表达式中的模式

import collection.JavaConversions._//  for((k,v) <- System.getProperties) println(k -> v)//  匹配为空的值    for((k,v) <- System.getProperties if v == "") println(k -> v)    for((k,"") <- System.getProperties) 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 //单例对象不用加括号//  样例类的实例使用()，样例对象不用使用()    def amountMatch(a:Amount) = a match{        case Dollar(v) => "$" + v//      case Currency(_,u) => "Oh noes , I got "+u//      如果两个参数是对偶，则可以写成中置表示法        case a Currency u => a+" Oh noes , I got "+u        case Nothing => ""    }

10.copy方法和带名参数
通过带名参数直接修改这些对象的属性

//  copy方法和带名参数    val amt = Currency(29.95,"EUR")    val price = amt.copy()    val price1 = amt.copy(value = 20.0)    val price2 = amt.copy(unit = "CHF")

11.case 中置表示法

//  中置表示法    case object +:{        def unapply[T](input:List[T]) = if(input.isEmpty) None else Some((input.head,input.tail))    }    1 +: 7 +: 9 +: Nil match {    //可以用+:来析构列表        case f +: s +: r => f+s+r.length        case _ => None    }

12.匹配嵌套结构
场景售卖某个商品，会将商品捆绑销售：

    abstract class Item    case class Article(description:String,price:Double) extends Item    case class Bundle(description:String,price:Double,items:Item*) extends Item    Bundle("Book1",20,Article("Book2",39),Bundle("Book3",25,Article("Book4",31),Article("Book5",11)))    def matchItem(i:Item) = i match{//  匹配到了被绑定到Bundle第一个Article的描述desc        case Bundle(_,_,Article(_,p),_*) => println(p) //      匹配到Bundle只含有一个Article的第一个Article//      @可以将变量绑定到嵌套的值上        case Bundle(_,_,art @ Article(_,_),rest) => println(art.price) //      可以匹配到Bundle含有多个Article的第一个Article        case Bundle(_,_,art @ Article(_,_),rest @ _*) => println(art.price) //              case _ => println(None)    }//  可以用于计算商品的价格    def price(it:Item):Double = it match{//      计算单本书的价格        case Article(_,p) => p//      递归计算一捆书的价格        case Bundle(_,disc,its @ _*) => its.map(price _).sum - disc    }

13.密封类sealed
当你用样例类来做匹配是，你可能想让编译器确保你已经列出了所有的可能选择。
要达到这个目的，需要将其超类声明为sealed：

    sealed abstract class Amount    case class Dollar(value:Double) extends Amount    case class Currency(value:Double,unit:String) extends Amount    case object Nothing extends Amount //单例对象不用加括号

密封类何所有子类必须在同一个源文件中定义。如果要加上一个欧元类：

case class Euro(value:Double) extends Amount

他们必须在哪个文件中完成。
14.模拟枚举

//  模拟枚举,样例类可以模拟枚举类，scala不自带枚举    sealed abstract class TrafficLightColor    case object Red extends TrafficLightColor    case object Yellow extends TrafficLightColor    case object Green extends TrafficLightColor    def trafficLightMatch(light:TrafficLightColor) = light match{        case Red  => "stop"        case Yellow  => "hurry up"        case Green  => "go"    }

15.Option类

option可能存在有可能不存在的值。其样例子类Some包装了某个值如：Some(“Fred”),而样例对象None表示没有值

//  Option支持泛型 Some("Fred") => Some[String]//  Map类的get返回一个Option，用模式匹配来获取值    val scores = Map("Bob" -> 75,"Alice" -> 90)    scores.get("Alice") match {        case Some(s) => println(s)        case None => println("no score")    }//  不过这很烦    val score = scores.get("Alice")    if(score.isEmpty) println("no score") else  println(score.get)//  这也很烦 使用getOrElse    println(score.getOrElse("no socre"))

16.偏函数
偏函数必须位于编译器可以推断返回类型的上下文中。当你把它复制个一个PartialFunction[Char,Int]有类型声明的变量，和当做参数传递是符合这个要求。
被包含在{}一组case语句是一个偏函数—不是对所有输入值都有定义的函数。他是partailFunction[A,B]类的一个实例。A是参数类型，B是返回值类型。
该类有两个方法：apply方法从匹配到的模式计算函数值，而isDefinedAt只要有一个匹配返回true。

    val func : PartialFunction[Char,Int] = {case '+' => 1;case '-' => -1}    func('-') //调用了f.apply('-'),-1    func.isDefinedAt('0')//false    func('0')//MacthError//  collect方法将偏函数作为参数    "-3+4".collect(func) //Vector(-1,1)