Scala Cookbook读书笔记 Chapter 3.Control Structures 第二部分

3.8 使用一个case语句匹配复杂条件

几个匹配条件要求执行相同的业务逻辑，而不是使用多个case重复业务逻辑，想要使用的是匹配条件的业务逻辑的复制。

3.8.1 解决方案

使用 | 分隔符将相同的业务逻辑的匹配条件放置到同一行上

val i = 5
i match {
case 1 | 3 | 5 | 7 | 9 => println("odd")
case 2 | 4 | 6 | 8 | 10 => println("even")
}

其他类型也适用：

val cmd = "stop"
cmd match {
case "start" | "go" => println("starting")
case "stop" | "quit" | "exit" => println("stopping")
case _ => println("doing nothing")
}

匹配多个case对象：

trait Command
case object Start extends Command
case object Go extends Command
case object Stop extends Command
case object Whoa extends Command

def executeCommand(cmd: Command) = cmd match {
case Start | Go => start()
case Stop | Whoa => stop()
}

3.9 分配匹配表达式结果给变量

问题：从匹配表达式返回值然后分配给一个变量，或者使用匹配表达式作为一个方法的内容。

3.9.1 解决方案

在匹配表达式前插入变量：

val evenOrOdd = someNumber match {
case 1 | 3 | 5 | 7 | 9 => println("odd")
case 2 | 4 | 6 | 8 | 10 => println("even")
}

这种方式一般用来创建短方法和函数

def isTrue(a: Any) = a match {
case 0 | "" => false
case _ => true
}

查看更多

Expression-oriented programming language

3.10 获取匹配表达式中默认case的值

问题：想要获取默认值，但是使用_下划线进行匹配时不能获取值。

3.10.1 解决方案

给默认case分配一个变量名代替使用_下划线，可以在语句的右边获取变量

i match {
case 0 => println("1")
case 1 => println("2")
case default => println("You gave me: " + default)
}

3.10.2 讨论

本章关键是使用一个变量名代表默认匹配，代替使用下划线_字符

分配的名字可以是任何合法的变量名：

i match {
case 0 => println("1")
case 1 => println("2")
case whoa => println("You gave me: " + whoa)
}

必须提供一个默认匹配，不提供会产生MatchError错误：

scala> 3 match {
| case 1 => println("one")
| case 2 => println("two")
| // no default match
| }
scala.MatchError: 3 (of class java.lang.Integer)
many more lines of output ...

3.11 在匹配表达式里使用模式匹配

问题：需要在一个匹配表达式里匹配一个或者多个模式，并且模式可能是常量模式，变量模式，构造函数模式，序列模式，元组模式，或者类型模式

3.11.1 解决方案

给想要匹配的每个模式定义一个case语句：

def echoWhatYouGaveMe(x: Any): String = x match {

// constant patterns
case 0 => "zero"
case true => "true"
case "hello" => "you said 'hello'"
case Nil => "an empty List"

// sequence patterns
case List(0, _, _) => "a three-element list with 0 as the first element"
case List(1, _*) => "a list beginning with 1, having any number of elements"
case Vector(1, _*) => "a vector starting with 1, having any number of elements"

// tuples
case (a, b) => s"got $a and $b"
case (a, b, c) => s"got $a, $b, and $c"

// constructor patterns
case Person(first, "Alexander") => s"found an Alexander, first name = $first"
case Dog("Suka") => "found a dog named Suka"

// typed patterns
case s: String => s"you gave me this string: $s"
case i: Int => s"thanks for the int: $i"
case f: Float => s"thanks for the float: $f"
case a: Array[Int] => s"an array of int: ${a.mkString(",")}"
case as: Array[String] => s"an array of strings: ${as.mkString(",")}"
case d: Dog => s"dog: ${d.name}"
case list: List[_] => s"thanks for the List: $list"
case m: Map[_, _] => m.toString

// the default wildcard pattern
case _ => "Unknown"
}

测试上面的匹配表达式：

object LargeMatchTest extends App {

case class Person(firstName: String, lastName: String)
case class Dog(name: String)

// trigger the constant patterns
println(echoWhatYouGaveMe(0))
println(echoWhatYouGaveMe(true))
println(echoWhatYouGaveMe("hello"))
println(echoWhatYouGaveMe(Nil))

// trigger the sequence patterns
println(echoWhatYouGaveMe(List(0,1,2)))
println(echoWhatYouGaveMe(List(1,2)))
println(echoWhatYouGaveMe(List(1,2,3)))
println(echoWhatYouGaveMe(Vector(1,2,3)))

// trigger the tuple patterns
println(echoWhatYouGaveMe((1,2))) // two element tuple
println(echoWhatYouGaveMe((1,2,3))) // three element tuple

// trigger the constructor patterns
println(echoWhatYouGaveMe(Person("Melissa", "Alexander")))
println(echoWhatYouGaveMe(Dog("Suka")))

// trigger the typed patterns
println(echoWhatYouGaveMe("Hello, world"))
println(echoWhatYouGaveMe(42))
println(echoWhatYouGaveMe(42F))
println(echoWhatYouGaveMe(Array(1,2,3)))
println(echoWhatYouGaveMe(Array("coffee", "apple pie")))
println(echoWhatYouGaveMe(Dog("Fido")))
println(echoWhatYouGaveMe(List("apple", "banana")))
println(echoWhatYouGaveMe(Map(1->"Al", 2->"Alexander")))

// trigger the wildcard pattern
println(echoWhatYouGaveMe("33d"))
}

输出如下

zero
true
you said 'hello'
an empty List

a three-element list with 0 as the first element
a list beginning with 1 and having any number of elements
a list beginning with 1 and having any number of elements
a vector beginning with 1 and having any number of elements
a list beginning with 1 and having any number of elements

got 1 and 2
got 1, 2, and 3

found an Alexander, first name = Melissa
found a dog named Suka

you gave me this string: Hello, world
thanks for the int: 42
thanks for the float: 42.0
an array of int: 1,2,3
an array of strings: coffee,apple pie
dog: Fido
thanks for the List: List(apple, banana)
Map(1 -> Al, 2 -> Alexander)

you gave me this string: 33d

在匹配表达式中，List和Map语句写成如下：

case list: List[_] => s"thanks for the List: $list"
case m: Map[_, _] => m.toString

也可以使用下面方式替代：

case list: List[x] => s"thanks for the List: $list"
case m: Map[a, b] => m.toString

更偏爱使用下划线方法，因为代码清晰不需要关心存储在List和Map中的值是什么。当然有时需要知道存储在List和Map中的值是什么，但是由于JVM中的类型擦除，那将是一个困难的问题。

如果List表达式写成如下：

case l: List[Int] => "List"

如果熟悉java平台的类型擦除，就会知道这个例子不会工作，Scala编译器会有如下警告：

Test1.scala:7: warning: non-variable type argument Int in type pattern
List[Int] is unchecked since it is eliminated by erasure
case l: List[Int] => "List[Int]"
^

如果对类型擦除不熟悉，请移步查看更多

3.11.2 讨论

通常使用这种技术时，你的方法将期待一个继承基类或者特性的实例,然后case语句将调用那个基类的子类。如echoWhatYouGaveMe方法中，每个Scala的类型都是Any的子类。

在 Blue Parrot application，以随机间隔播放音乐文件或者朗读文档，有以下方法：

import java.io.File

sealed trait RandomThing

case class RandomFile(f: File) extends RandomThing
case class RandomString(s: String) extends RandomThing

class RandomNoiseMaker {

def makeRandomNoise(t: RandomThing) = t match {
case RandomFile(f) => playSoundFile(f)
case RandomString(s) => speak(s)
}
}

makeRandomNoise方法声明采用RandomThing类型做参数，然后匹配表达式处理两个子类，RandomFile和RandomString。

3.11.3 模式

常量模式：常量模式只能匹配自己，任何文本都可以作为常量，如果指定0作为文本，那么只有整形 0 将会匹配

case 0 => "zero"
case true => "true"

变量模式：上面例子中没有展示变量模式，在3.10中进行了讨论，变量模式如下划线字符一样匹配任何对象。Scala绑定变量为任何对象，在case语句的右边可以使用这个变量。

case _ => s"Hmm, you gave me something ..."

//使用变量模式代替上面
case foo => s"Hmm, you gave me a $foo"

构造函数模式：可以在case语句中匹配构造函数，可以根据构造函数需要指定常量和变量模式：

case Person(first, "Alexander") => s"found an Alexander, first name = $first"
case Dog("Suka") => "found a dog named Suka"

序列模式：可以匹配List,Array,Vector等序列。使用下划线 _ 字符代表序列的一个元素，使用 _* 代表 “0或多个字符”：

case List(0, _, _) => "a three-element list with 0 as the first element"
case List(1, _*) => "a list beginning with 1, having any number of elements"
case Vector(1, _*) => "a vector beginning with 1 and having any number …"

元组模式：匹配元祖模式并且获取元祖中每个元素的值，如果不关心一个元素的值可以使用下划线 _ 代替：

case (a, b, c) => s"3-elem tuple, with values $a, $b, and $c"
case (a, b, c, _) => s"4-elem tuple: got $a, $b, and $c"

类型模式：下面的例子中str: String是一个类型模式，str是一个模式变量，可以在声明之后在表达式右边获取模式变量：

case str: String => s"you gave me this string: $str"

3.11.4 给模式添加变量

通过以下语法给模式添加变量

variableName @ pattern

如 Programming in Scala 这本书描述，“这个提供了一个变量绑定模式。这样一个模式的意义是正常执行模式匹配，如果模式成功，就像一个简单变量模式设置变量给匹配对象”。

下面通过演示问题解决来说明用处，假设有一个List模式：

case List(1, _*) => "a list beginning with 1, having any number of elements"

上面例子无法再表达式右侧获取list。想要获取list时，可以用下面方法：

case list: List[_] => s"thanks for the List: $list"

所以看上去应该尝试用一个序列模式：

case list: List(1, _*) => s"thanks for the List: $list"

//编译错误
Test2.scala:22: error: '=>' expected but '(' found.
case list: List(1, _*) => s"thanks for the List: $list"
^
one error found

解决方案是在序列模式添加一个绑定变量模式

case list @ List(1, _*) => s"$list"

下面更多演示：

case class Person(firstName: String, lastName: String)

object Test2 extends App {

def matchType(x: Any): String = x match {

//case x: List(1, _*) => s"$x" // doesn't compile
case x @ List(1, _*) => s"$x" // works; prints the list

//case Some(_) => "got a Some" // works, but can't access the Some
//case Some(x) => s"$x" // works, returns "foo"
case x @ Some(_) => s"$x" // works, returns "Some(foo)"

case p @ Person(first, "Doe") => s"$p" // works, returns "Person(John,Doe)"
}

println(matchType(List(1,2,3))) // prints "List(1, 2, 3)"
println(matchType(Some("foo"))) // prints "Some(foo)"
println(matchType(Person("John", "Doe"))) // prints "Person(John,Doe)"
}

3.11.5 匹配表达式中使用Some和None

可能会经常在匹配表达式中使用Some和None。假定有一个toInt方法定义：

def toInt(s: String): Option[Int] = {
try {
Some(Integer.parseInt(s.trim))
} catch {
case e: Exception => None
}
}

使用方法：

toInt("42") match {
case Some(i) => println(i)
case None => println("That wasn't an Int.")
}

查看更多

How do I get around type erasure on Scala? Or, why can’t I get the type parameter of my collections?

My Blue Parrot application

The “Type Erasure” documentation

3.12 在匹配表达式中使用Case类

问题：想要在匹配表达式中匹配不同的case类或case对象，比如在actor里接收信息时。

3.12.1 解决方案

使用不同的模式匹配case类和对象

trait Animal
case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal
case object Woodpecker extends Animal

object CaseClassTest extends App {

def determineType(x: Animal): String = x match {
case Dog(moniker) => "Got a Dog, name = " + moniker
case _:Cat => "Got a Cat (ignoring the name)"
case Woodpecker => "That was a Woodpecker"
case _ => "That was something else"
}

println(determineType(new Dog("Rocky")))
println(determineType(new Cat("Rusty the Cat")))
println(determineType(Woodpecker))
}

//输出
Got a Dog, name = Rocky
Got a Cat (ignoring the name)
That was a Woodpecker

3.13 Case语句中添加if表达式

问题：match表达式中给case语句添加限定逻辑，比如数字范围或者匹配模式，只要模式匹配一些额外的标准

3.13.1 解决方案

case语句中添加if判断

//匹配数字范围
i match {
case a if 0 to 9 contains a => println("0-9 range: " + a)
case b if 10 to 19 contains b => println("10-19 range: " + b)
case c if 20 to 29 contains c => println("20-29 range: " + c)
case _ => println("Hmmm...")
}

//匹配一个对象的不同值
num match {
case x if x == 1 => println("one, a lonely number")
case x if (x == 2 || x == 3) => println(x)
case _ => println("some other value")
}

可以在if判断里引用类字段，假设如下x是Stock类的实例，并且有symbol和price字段

stock match {
case x if (x.symbol == "XYZ" && x.price < 20) => buy(x)
case x if (x.symbol == "XYZ" && x.price > 50) => sell(x)
case _ => // do nothing
}

可以从case类里提取字段并应用在if判断里

def speak(p: Person) = p match {
case Person(name) if name == "Fred" => println("Yubba dubba doo")
case Person(name) if name == "Bam Bam" => println("Bam bam!")
case _ => println("Watch the Flintstones!")
}

3.13.2 讨论

注意所有的例子都可以如下把if判断放在表达式的右侧：

case Person(name) =>
if (name == "Fred") println("Yubba dubba doo")
else if (name == "Bam Bam") println("Bam bam!")

但是在很多情况下，为了代码更简洁易读会直接在case语句中加入if判断，而不是右边

3.14 使用一个match表达式代替isInstanceOf

问题：需要匹配一个类型或者多个不同的类型

3.14.1 解决方案

可以使用isInstanceOf方法测试一个对象的类型

if (x.isInstanceOf[Foo]) { do something ...

然后一些编程开发人员并不鼓励使用这种方法，并且在其他情况下会更加复杂。下面的例子中可以在一个match表达式中处理不同的类型

//确定对象是否是Person的实例
def isPerson(x: Any): Boolean = x match {
case p: Person => true
case _ => false
}

//处理不同的子类
trait SentientBeing
trait Animal extends SentientBeing
case class Dog(name: String) extends Animal
case class Person(name: String, age: Int) extends SentientBeing

// later in the code ...
def printInfo(x: SentientBeing) = x match {
case Person(name, age) => // handle the Person
case Dog(name) => // handle the Dog
}

3.14.2 讨论

匹配多个类型时使用match表达式替代isInstanceOf是自然而然的事

简单例子中，isInstanceOf方法匹配一个对象更简单点：

if (o.isInstanceOf[Person]) { // handle this ...

但是伴随更多需求，match表达式比if/else语句可读性更高

3.15 在match表达式中使用List

问题：List数据结构和其他集合数据结构有所不同，它从Cons单元（Cons cells）创建，结束于一个Nil元素。match表达式中使用这个会更好，比如写一个递归函数时。

3.15.1 解决方案

创建一个List

val x = List(1, 2, 3)

使用cons单元和一个Nil元素创建List

val y = 1 :: 2 :: 3 :: Nil

写一个递归算法时，可以利用List的最后一个元素是一个Nil对象：

def listToString(list: List[String]): String = list match {
case s :: rest => s + " " + listToString(rest)
case Nil => ""
}

REPL中运行：

scala> val fruits = "Apples" :: "Bananas" :: "Oranges" :: Nil
fruits: List[java.lang.String] = List(Apples, Bananas, Oranges)

scala> listToString(fruits)
res0: String = "Apples Bananas Oranges "

这种一个case处理Nil，一个case处理List其他部分的方法也可以用在List的其他类型上：

def sum(list: List[Int]): Int = list match {
case Nil => 1
case n :: rest => n + sum(rest)
}

def multiply(list: List[Int]): Int = list match {
case Nil => 1
case n :: rest => n * multiply(rest)
}

REPL中运行

scala> val nums = List(1,2,3,4,5)
nums: List[Int] = List(1, 2, 3, 4, 5)

scala> sum(nums)
res0: Int = 16

scala> multiply(nums)
res1: Int = 120

3.15.2 讨论

记住必须处理Nil这个case，不然会报错：

REPL中：

warning: match is not exhaustive! （完整）

正式项目中：

Exception in thread "main" scala.MatchError: List()
(of class scala.collection.immutable.Nil$)

3.16 在try/catch中匹配一个或更多异常

问题：在一个try/catch语句块中捕获一个或者更多异常

3.16.1 解决方案

Scala的try/catch/finally语法和Java很像，但是他在catch语句块中使用match表达式：

val s = "Foo"
try {
val i = s.toInt
} catch {
case e: Exception => e.printStackTrace
}

捕获更多异常：

try {
openAndReadAFile(filename)
} catch {
case e: FileNotFoundException => println("Couldn't find that file.")
case e: IOException => println("Had an IOException trying to read that file")
}

3.16.2 讨论

如果不关心具体异常，想要捕获所有异常并进行处理：

try {
openAndReadAFile("foo")
} catch {
case t: Throwable => t.printStackTrace()
}

捕获所有并且忽略不进行信息处理：

try {
val i = s.toInt
} catch {
case _: Throwable => println("exception ignored")
}

在Java中，可以从一个catch语句抛出一个异常。但是因为Scala没有已检查的异常，不需要指定一个方法抛出异常。下面演示方法不使用注解：

// nothing required here
def toInt(s: String): Option[Int] =
try {
Some(s.toInt)
} catch {
case e: Exception => throw e
}

如果喜欢声明方法抛出的异常或者需要和Java进行交互，添加@throws注解

@throws(classOf[NumberFormatException])
def toInt(s: String): Option[Int] =
try {
Some(s.toInt)
} catch {
case e: NumberFormatException => throw e
}

3.17 在try/catch/finally语句块里使用变量之前先声明它

问题：想要在try语句里使用一个对象，然后在finally部分获取这个对象，例如需要在一个对象上调用一个关闭的方法。

3.17.1 解决方案

在try/catch语句块之前声明字段为Option类型，然后在try语句内创建一个Some：

import java.io._

object CopyBytes extends App {

var in = None: Option[FileInputStream]
var out = None: Option[FileOutputStream]

try {
in = Some(new FileInputStream("/tmp/Test.class"))
out = Some(new FileOutputStream("/tmp/Test.class.copy"))
var c = 0
while ({c = in.get.read; c != −1}) {
out.get.write(c)
}
} catch {
case e: IOException => e.printStackTrace
} finally {
println("entered finally ...")
if (in.isDefined) in.get.close
if (out.isDefined) out.get.close
}

}

通常会告诉别人不要使用Option的get和isDefined方法，但是这是为数不多的一次认为这种使用是可以接受的，并且代码更可读

另一种方法是使用foreach方法：

try {
in = Some(new FileInputStream("/tmp/Test.class"))
out = Some(new FileOutputStream("/tmp/Test.class.copy"))
in.foreach { inputStream =>
out.foreach { outputStream =>
var c = 0
while ({c = inputStream.read; c != −1}) {
outputStream.write(c)
}
}
}
} // ...

上面方法两个变量时仍然可读，并且避免了get方法的调用。但是更多变量时并不实用。

3.17.2 讨论

声明Option字段的关键点在于没有初始化赋值：

var in = None: Option[FileInputStream]
var out = None: Option[FileOutputStream]

可以通过以下方式理解：

var x has No Option[yeT]
var x = None: Option[Type]

下面演示声明变量为null的处理，但是Scala中完全不需要考虑null值，所以下面的方法并不推荐：

// (1) declare the null variables
var store: Store = null
var inbox: Folder = null

try {
// (2) use the variables/fields in the try block
store = session.getStore("imaps")
inbox = getFolder(store, "INBOX")
// rest of the code here ...
} catch {
case e: NoSuchProviderException => e.printStackTrace
case me: MessagingException => me.printStackTrace
} finally {
// (3) call close() on the objects in the finally clause
if (inbox != null) inbox.close
if (store != null) store.close
}

查看更多

this Oracle “Byte Streams” example

3.18 创建自己的控制结构体

问题：自定义控制结构体改善Scala语言，简化代码，或者创建DSL给其他人使用

3.18.1 解决方案

Scala语言创建者有意不实现一些关键词，反而通过Scala库实现功能。比如3.5章节的“Implementing break and continue”，尽管Scala语言没有break和continue关键词，同样可以通过库里的方法实现同样的功能。

下面例子演示，假设不喜欢while循环，创建自己的whilst循环，可以像下面方法使用：

package foo

import com.alvinalexander.controls.Whilst._

object WhilstDemo extends App {

var i = 0
whilst (i < 5) {
println(i)
i += 1
}

}

创建whilst控制结构体，定义一个叫做whilst的函数并且需要两个参数，第一个参数处理测试条件（i < 5），第二个参数运行用户代码块。

可以通过包裹while操作来实现方法：

// 1st attempt
def whilst(testCondition: => Boolean)(codeBlock: => Unit) {
while (testCondition) {
codeBlock
}
}

更好的方法是不调用while：

package com.alvinalexander.controls

import scala.annotation.tailrec

object Whilst {

// 2nd attempt
@tailrec
def whilst(testCondition: => Boolean)(codeBlock: => Unit) {
if (testCondition) {
codeBlock
whilst(testCondition)(codeBlock)
}
}

}

3.18.2 讨论

第二个例子中使用了递归调用，但是在其他简单例子中不需要递归。假设需要一个执行两个条件判断的控制结构体。如果两个都为true，则运行代码块。表达式可能如下方法调用：

doubleif(age > 18)(numAccidents == 0) { println("Discount!") }

定义一个三个参数的函数：

// two 'if' condition tests
def doubleif(test1: => Boolean)(test2: => Boolean)(codeBlock: => Unit) {
if (test1 && test2) {
codeBlock
}
}

查看更多

The ‘using’ control structure in Beginning Scala (by David Pollak)