scala 模式匹配

模式匹配是函数式编程的必备，也是scala广泛使用的特性，在并发编程里面用到了很多。

模式匹配的模式是：

something match {
 case ....
 case ....
 ......
}

可以进行字面量和常量的匹配：

  def activity(day:String){
    day match {
      case "monday" => println(day)
      case "saturday" => println(day)
    }
  }

可以匹配元组和列表：

  def activity(day:Any){
    day match {
      case "monday" => println(day)
      case "saturday" => println(day)
      //元组既可以是明确值的 也可是元组是变量形式的
      case ("sunday","friday")=> println(day)
      case (a,b) => println(day)
      case List("sunday","friday") =>  println(day)
      //只要开头是sunday，friday的list都可以匹配
      case List("sunday","friday",_*) =>  println(day)
      //otherday是匹配的list去除前面两个元素后的list
      case List("sunday","saturday",otherday @_*) =>  println(day)
      case _ => //匹配通配符
    }
  }

 注：case (a, b) => println(day)这种类型也叫模式变量，模式变量中的变量要以小写字母开头，常量才可以大写字母开头。

 

可以进行类型和guard匹配：

  def process(day: Any) {
    day match {
      //类型匹配
      case a: Int =>
      //类型和guard匹配 
      case a: Long if a > 10 =>
      case msg: String =>
      //元组中的一个元素也可以
      case (a: Int, b: Int) if a > 10 =>

    }

可以利用case类进行模式匹配：

  def process(day: Any) {
    day match {
      //类型匹配
      case a: Int =>
      //类型和guard匹配 
      case a: Long if a > 10 =>
      case msg: String =>
      //元组中的一个元素也可以
      case (a: Int, b: Int) if a > 10 =>

      case Apple => 
        
      case Orange =>
    }
  }
  abstract case  class Simple
   case  class Apple extends Simple
   case  class Orange extends Simple

当case类比较多的时候，可能会漏掉其中的case类，当在抽象的基类Simple前面加入sealed变成这样：

   sealed abstract case  class Simple

那么当缺少case实现类的时候，编译器会发出警告。

 

可以利用Extractor(提取器)进行匹配：

  def proccess(any: String) {
    any match {
      case Symbol() => println("abc")
      case Extractor(a) => println(a)
      case _ => println("sss")
    }
  }

object Extractor {
  def unapply(str: String): Some[String] = {
    new Some[String]("nothing")
  }
}

object Symbol {
  def unapply(str: String) = {
    str == "google"
  }
}

可以看到Extractor是一个独立对象，其中有个约定成俗的unapply()方法，与之对应的是apply()方法，apply()方法在独立对象(或者伴生对象)中可以代替new关键字，当其他类调用独立对象的时候(不带new关键字的形式)，就是调用apply()方法，这是通过scala的语法糖实现的(unapply()也是语法糖)，在apply()里面可以做一些额外的事情。

unapply()方法只能返回Boolean,Option[T],Some[T]等类型，当不是Boolean型的时候，必须传入参数，传入的参数是用来把unapply()方法的返回值提取出来的，而不是传入参数使用，

所以叫提取器，这里使用到了闭包，外面定义的变量，在提取器里面被赋值，接着返回。

 

scala里面的正则表达式也可以当做提取器使用，这里不表。