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)
网友评论