Scala模式匹配&样例类&偏函数

模式匹配

match不是语句，而是一个表达式，拥有返回值。在match表达式中可以使用任何类型

val sign = ch match {
  case '+' => 1
  case '*' => 2
  case _ => 0
}

// 给模式添加守卫，只匹配数字
val sign = ch match {
  case _ if Character.isDigit(ch) => Character.digit(ch, 10)
}

// 匹配数组
val arr = Array(1, 2, 3, 4, 5, 6)
val result = arr match {
  case Array(1, 2, 3, 4, 5, _) => 1
  case Array(1, 2, _*) => 2
  case _ => 0
}
注： _ 表示任意一个元素，_* 表示任意长度的元素

// 类型匹配
def getType(obj: Any): Unit = {
  obj match {
    case _: Array[String] => println("Array[String]")
    case _: String => println("String")
    case _: Int => println("Int")
    case _: BigInt => println("BigInt")
    case _ => println("unkown")
  }
}

// 匹配列表
val result = list match {
  case a :: b :: tail => a + " " + b
  case a :: tail => a
  case _ => "none"
}

// 匹配元组
val result = tuple match {
  case (a, _) => a
  case _ => "none"
}
注：匹配元组是无法使用 _*

注意：泛型的类型匹配要注意如List[String]、Map[Char,Int]等不会成功匹配，如List[Int]等亦可匹配，因而往往使用通配符List[ _ ]进行匹配，但Array[Int]是可行的

样例类

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

abstract class Solution
case class Add(a: Int, b: Int) extends Solution
case class Mul(a: Int, b: Int) extends Solution
// 还可以有单例的样例对象
case object Nothing extends Solution

def getType(obj: Solution): Any = {
  obj match {
    case Add(a, b) => a + b
    case Mul(a, b) => a * b
    case Nothing => "Nothing"
    case _ => "Null"
  }
}

// 用法
val add = Add(1, 1)
val mul = Mul(10, 10)
val result = getType(add)  // 2
val result1 = getType(mul) // 100

// 可以把模式匹配直接放到公共超类中
abstract class Solution{
  def getType: Any = {
    this match {
      case Add(a, b) => a + b
      case Mul(a, b) => a * b
      case Nothing => "Nothing"
      case _ => "none"
    }
  }
}

// 用法
add.getType
mul.getType

注意：样例类的实例使用(), 样例对象不使用()。

当声明一个样例类时会自动发生下面几件事：

构造器中的么一个参数都会成为val字段，除非显式的设为var
在伴生对象中提供apply方法，可以不用关键字new就能构造相应对象
提供unapply方法让模式匹配可以工作
生成toString，equals， hashCode，copy方法

密封类

模式匹配完成后需要确保所有的情况都被考虑，要达到这个目的，需要将样例类的公共超类声明为sealed

sealed abstract class Solution
case class Add(a: Int, b: Int) extends Solution
case class Mul(a: Int, b: Int) extends Solution

密封类的所有子类必须都在该密封类所在的文件中定义。
如果一个类是密封的，那么在编译期所有的子类就是可知的，因而编译器可以检查模式语句的完整性。

模拟枚举

在Scala中，样例类可以模拟枚举类型

sealed abstract class Color
// 使用单例样例对象
case object Red extends Color
case object Blue extends Color
case object Green extends Color

def getColor(obj: Color): String = {
  obj match {
    case Red => "Red"
    case Blue => "Blue"
    case Green => "Green"
  }
}

// 用法
getColor(Red)
或
val color = Red
getColor(color)

偏函数

被包在花括号内的一组case语句是一个偏函数——一个并非对所有输入值都有定义的函数。它是PartialFunction[A, B]类的一个实例。(A是参数类型， B是返回类型)。
PartialFunction[A, B] 类有两个方法：apply方法从匹配到的模式计算函数值，而isDefinedAt方法在输入至少匹配其中一个模式时返回true
如果把函数用到其不支持的值时会报错

// 定义
val fun: PartialFunction[Int, String] = { case 1 => "yes"; case 0 => "no" }

// 用法
fun(1)          // yes
fun(0)          // no
fun.isDefineAt(1)   // true
fun.isDefineAt(3)   // false
fun(3)          // 报错

GenTraversable特质的collect方法将一个偏函数应用到所有在该偏函数有定义的元素，并返回包含这些结果的序列

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

Actor中的例子

react {
  case (name: String, actor: Actor) => {
    actor ! getip(name)
    act()
  }
  case msg => {
    println("UnHandler message" + msg)
    act()
  }
}

注意：偏函数表达式必须位于编译器可以推断出返回类型的上下文中。把它赋值给一个带有类型声明的变量，或者将它作为参数传递都是可以的。

Scala模式匹配&样例类&偏函数

模式匹配

样例类

当声明一个样例类时会自动发生下面几件事：

密封类

模拟枚举

偏函数

推荐阅读更多精彩内容