4. 控制结构
正如名字所言，控制结构给程序员提供了一种控制程序执行流的方式。这是一个程序语言进行决策和轮询任务的基本功能。回到学习Scala的2010年，我曾认为控制结构如if/then语句，以及for和while循环，是一个相对无聊的程序功能，但那只是因为我并不知道还有其他方式。这些天我知道了控制结构一个程序语言定义性的功能（defining feature）。
Scala的控制结构包括：
for循环和for表达式
if/then/else语句和if表达式
match 表达式 （模式匹配）
try/catch/finally块
while循环
接下来我会简单介绍一下，之后会在具体的小节中展示更多的细节来描述如何使用这些功能。
for循环和for表达式
在大多数的基础用法中， for循环提供了一个针对集合的迭代操作，如下：
for i <- List(1, 2, 3) do println(i)但是这仅仅只是一个基础用法。for循环也可以包含守卫 —— 嵌入if语句：
for
i <- 1 to 10
if i > 3
if i < 6
do
println(i)通过使用yield关键字，for循环也变成了 for 表达式 —— 产生结果的循环：
val listOfInts = for
i <- 1 to 10
if i > 3
if i < 6
yield
i * 10在循环运行后，listOfInts变成了一个Vector(40, 50)。这个在循环中的守卫语句过滤掉了除了4和5的所有值，并将这些值在yield代码块中乘以10。
关于for循环和表达式的更多细节将在本章的初始章节中涉及。
if/then/else-if表达式
正如for循环和表达式给你遍历集合的能力，if/then/else 表达式则提供了分支决策的能力。在Scala 3中，首选的语法已经改变了，现在看起来是这样的：
val absValue = if a < 0 then -a else a
def compare(a: Int, b: Int): Int =
if a < b then
-1
else if a == b then
0
else
1
end compare正如两个例子中的展示，一个if表达式就是一个带返回值的表达式（表达式的讨论参阅4.5小节）。
match表达式和模式匹配
接下来，match表达式和模式匹配是Scala的基本功能，本章节的大部分内容将展示这些功能。正如if表达式，match表达式也有返回值，所以可以把他们用作方法体。
比如下面的一个例子，这个方法相似于Perl语言版的 true 或 false 判断：
def isTrue(a: Matchable): Boolean = a match
case false | 0 | "" => false
case _ => true这段代码中， 如果isTrue收到了0或者空字串，它将返回false，否者true。本章花了十个小节来描述match表达式的功能细节。
try/catch/finally代码块
Scala的try/catch/finally代码块类似于Java，但语法上有一点不同，catch代码块是由match表达式构成的：
try
// 一些异常构造代码
catch
case e1: Exception1Type => // 处理该类异常
case e2: Exception2Type => // 处理该类异常
finally
// 关闭资源和执行其他行文正如if和match，try也是一个会返回值的表达式，你可以如下进行String到Int的转换：
def toInt(s: String): Option[Int] =
try
Some(s.toInt)
catch
case e: NumberFormatException => None这些例子展现了toInt如何运行：
toInt("1") // Option[Int] = Some(1)
toInt("Yo") // Option[Int] = None关于 try/catch 代码块的更多信息请参阅4.16小节。
while循环
当来到while循环，你会发现它是真的很少有在Scala中用到。这是因为while循环几乎都是用于副作用，比如更改可变参数和用println打印，并且这些都是可以通过for循环和foreach方法对集合进行操作的。也就是说，如果你需要用到它，大体如下所示：
while
i < 10
do
println(i)
i += 14.1小节将简要介绍 while 循环。
最后，通过数个Scala功能的合并，你可以创建自己的控制结构，这些将在4.17小节进行讨论。
控制结构是编程语言的界定特征
在2020年末，我足够幸运的合写了在Scala官方文档网站（ https://docs.scala-lang.org/ ）的Scala 3 Book，包括如下三章：
给Java开发者的Scala （ https://oreil.ly/Psbc4 ）
给JS开发者的Scala （ https://oreil.ly/cDyzW ）
给Python开发者的Scala（ https://oreil.ly/6zIAX ）
当我之前说控制结构作为“编程语言的界定特征”时，我的意思之一是，在我写完这些章节后，我开始意识到该章节所述功能的威力，以及和其他语言相比Scala的一致性是如何强大。这样的一致性是保持Scala能被愉快使用的功能之一。
4.1 在数据结构上的for循环
问题
你想要用一个传统for循环的方式来遍历一个集合的所有元素。
解决方案
有很多方法可以遍历 Scala 集合，包括 for 循环、while 循环、以及如foreach、map、flatMap 等集合方法。 该解决方案重点主要在for循环上。
给定一个简单的列表：
val fruits = List("apple", "banana", "orange")你可以像这样遍历这些元素并打印它们：
scala> for f <- fruits do println(f)
apple
banana
orange同样的方法适用于所有序列，包括 List、Seq、Vector、Array、ArrayBuffer等。
当你的算法需要多行时，使用相同的 for 循环语法，并将你的处理程序放在大括号内的一个块中：
scala> for f <- fruits do
| // imagine this requires multiple lines
| val s = f.toUpperCase
| println(s)
APPLE
BANANA
ORANGEfor循环计数器
如果你需要访问 for 循环内的计数器，请使用以下方法之一。
首先，你可以使用这样的计数器访问序列中的元素：
for i <- 0 until fruits.length do
println(s"$i is ${fruits(i)}")该循环产生此输出：
0 is apple
1 is banana
2 is orange你很少需要依靠索引访问序列元素，然而当你需要时，这是一种可能的方法。Scala集合还提供了一个 zipWithIndex 方法，可用于创建循环计数器：
for (fruit, index) <- fruits.zipWithIndex do
println(s"$index is $fruit")它的输出如下：
0 is apple
1 is banana
2 is orange生成器
在相关记录中，以下示例展示了如何使用 Range 执行循环三次：
scala> for i <- 1 to 3 do println(i)
1
2
3for循环中的 1 to 3 代码部分创建了一个 Range，如REPL中所示：
scala> 1 to 3
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3)像这样使用一个 Range 对象，被称为使用一个 生成器（generator）。4.2小节展示了如何使用此技术创建带有多个计数器的for循环。
Map上的循环
当迭代 Map 中的键和值时，我发现这样的for循环最简洁易读的：
val names = Map(
"firstName" -> "Robert",
"lastName" -> "Goren"
)
for (k,v) <- names do println(s"key: $k, value: $v")REPL展示了的输出是：
scala> for (k,v) <- names do println(s"key: $k, value: $v")
key: firstName, value: Robert
key: lastName, value: Goren讨论
因为我已经切换到函数式编程风格，所以我已经好几年没有使用while循环了，但是REPL展示了它是如何工作的：
scala> var i = 0
i: Int = 0
scala> while i < 3 do
| println(i)
| i += 1
0
1
2while 循环通常用于副作用，例如，像我这样更新可变变量以及向外界输出。随着我的代码越来越接近纯函数式编程 —— 一种没有可变状态的方式 —— 我不再需要 while。
也就是说，当你以面向对象的编程风格进行编程时，仍然会经常使用while循环，该示例展示了它们的语法。 也可以像这样把一个while循环写在多行上：
while
i < 10
do
println(i)
i += 1集合方法，比如foreach
在某些方面，Scala 让我想起了 Perl 的口号，“有不止一种方法可以做它”，并且集合上的迭代提供了一些很好的例子。随着集合上可用的大量方法，这重点声明的是一个 for 循环甚至可能不是解决特定问题的最佳方法；foreach、map、flatMap、collect、reduce 等方法经常可以用来解决你的问题而不需要显式的 for 循环。
例如，当你使用集合时，你还可以通过调用集合上的foreach方法遍历每个集合元素：
scala> fruits.foreach(println)
apple
banana
orange当你有一个算法要在集合中的每个元素上运行时，只需将这个匿名函数传递给foreach：
scala> fruits.foreach(e => println(e.toUpperCase))
APPLE
BANANA
ORANGE与for循环一样，如果你的算法需要多行，请在一个代码块中执行相应的程序：
scala> fruits.foreach { e =>
| val s = e.toUpperCase
| println(s)
| }
APPLE
BANANA
ORANGE另见
有关如何使用zipWithIndex的更多示例，请参阅13.4小节“使用zipWithIndex或zip以创建循环计数器”。
有关如何迭代Map中的元素的更多示例，请参阅14.9小节“遍历Map”。
for 循环的工作原理非常有趣，了解它可以帮助你进步。我在这些文章中详细介绍了这一点：
“How to Make a Custom Sequence Work as a for Loop Generator” （ https://oreil.ly/UFVQ2 ）
“How to Enable Filtering in a for Expression” （ https://oreil.ly/3anl9 ）
“How to Enable the Use of Multiple Generators in a for Expression”（ https://oreil.ly/RZGNP ）
4.2 使用带有多个计数器的for循环
问题
你想创建一个具有多个计数器的循环，例如在迭代多维数组时。
解决方案
你可以创建如下带有两个计数器的for循环：
scala> for i <- 1 to 2; j <- 1 to 2 do println(s"i = $i, j = $j")
i = 1, j = 1
i = 1, j = 2
i = 2, j = 1
i = 2, j = 2执行如下：i 被设置为 1 时，遍历 j 中的元素，然后将 i 设置为 2 并重复该过程。
使用这种方法可以很好地处理这些简单示例，但是当你的代码变复杂时，这是首选样式：
for
i <- 1 to 3
j <- 1 to 5
k <- 1 to 10 by 2
do
println(s"i = $i, j = $j, k = $k")这种方法在循环多维数组时很有用。假设你创建并填充一个像这样的小型二维数组：
val a = Array.ofDim[Int](2,2)
a(0)(0) = 0
a(0)(1) = 1
a(1)(0) = 2
a(1)(1) = 3你可以像这样打印每一个数组元素：
scala> for
| i <- 0 to 1
| j <- 0 to 1
| do
| println(s"($i)($j) = ${a(i)(j)}")
(0)(0) = 0
(0)(1) = 1
(1)(0) = 2
(1)(1) = 3讨论
如15.2小节“创建Range”所示，1 to 5 的语法创建了一个Range：
scala> 1 to 5
val res0: scala.collection.immutable.Range.Inclusive = Range 1 to 5Range适用于许多目的，并且在for循环中使用的 <- 符号创建的Range称为生成器。同理，你也可以轻松在一个循环中使用多个生成器。
另见
关于格式化控制结构的Scala风格指南（ https://oreil.ly/3jB28 ）
4.3 使用带有嵌入式if语句的for循环（守卫语句）
问题
你希望在for循环中添加一个或多个条件子句，通常是为了过滤掉集合中的某些元素，同时处理其他元素。
解决方案
在生成器之后添加一个或多个if语句，如下所示：
for
i <- 1 to 10
if i % 2 == 0
do
print(s"$i ")
// output: 2 4 6 8 10这些if语句被称为filter，filter表达式或守卫语句，而你可以根据手头的问题使用尽可能需要的守卫语句。这个循环显示了一个打印数字4的生硬方式：
for
i <- 1 to 10
if i > 3
if i < 6
if i % 2 == 0
do
println(i)讨论
使用旧样式的if表达式编写for循环仍然是可以的。例如，给定这段代码：
import java.io.File
val dir = File(".")
val files: Array[java.io.File] = dir.listFiles()理论上，你可以像这样用这种风格编写一个 for 循环，这让人想起C和Java：
// 一个C/Java风格的'for'循环
for (file <- files) {
if (file.isFile && file.getName.endsWith(".scala")) {
println(s"Scala file: $file")
}
}然而，一旦你熟悉了Scala的for循环语法，我想你会发现它使代码更具可读性，因为它将循环和过滤的关注点从业务逻辑中分开：
for
// 循环和过滤
file <- files
if file.isFile
if file.getName.endsWith(".scala")
do
// 所需要的业务代码
println(s"Scala file: $file")请注意，由于守卫语句通常旨在过滤集合，因此你可能希望使用可用于集合的众多过滤方法中的一种（filter、take、drop等），而不是for循环，具体取决于你的需求。具体例子请参阅第11章。
4.4 通过for/yield从现有集合创建新集合
问题
你想从一个现有的集合通过应用一个算法（和可能的一个或多个守卫语句）到每个元素来创建一个新的集合。
解决方案
使用一个带有for循环的yield语句来从一个现有的集合中创建一个新的集合。例如，给定一个小写的字符串数组：
scala> val names = List("chris", "ed", "maurice")
val names: List[String] = List(chris, ed, maurice)你可以通过将带有for循环的yield和一个简单的算法结合起来新创建一个首字母大写的字符串数组：
scala> val capNames = for name <- names yield name.capitalize
val capNames: List[String] = List(Chris, Ed, Maurice)使用带有yield语句的for循环称为for 推断（for-comprehension）。
如果你的算法需要多行代码，请在块中通过yield关键字，并手动指定结果变量的类型来实现，或者不用：
// [1] 声明 `lengths` 的类型
val lengths: List[Int] = for name <- names yield
// 假设这个主体需要多行代码
name.length
// [2] 不用声明 `lengths` 的类型
val lengths = for name <- names yield
// 假设这个主体需要多行代码
name.length两种方法yield可以得到相同的结果：
List[Int] = List(5, 2, 7)for推断（也称为for表达式）的两个部分都可以变得比较复杂。下面是一个更大的例子：
val xs = List(1,2,3)
val ys = List(4,5,6)
val zs = List(7,8,9)
val a = for
x <- xs
if x > 2
y <- ys
z <- zs
if y * z < 45
yield
val b = x + y
val c = b * z
cfor推断产生以下结果：
a: List[Int] = List(49, 56, 63, 56, 64, 63)一个for推断甚至可以是完整方法体：
def between3and10(xs: List[Int]): List[Int] =
for
x <- xs
if x >= 3
if x <= 10
yield x
between3and10(List(1,3,7,11)) // List(3, 7)讨论
如果你不熟悉将yield与for循环一起使用，则可以这样考虑循环：
当它开始运行时，for/yield循环立即创建一个新的与输入集合具有相同类型的空集合。例如，如果输入类型是Vector，输出类型也将是Vector。你可以想象这个新集合就像一个空桶。
在for循环的每次迭代中，可能会从输入集合创建一个新的输出元素。输出元素被创建时，它就会被放在桶里。
当循环结束运行时，返回桶的全部内容。
这值是一种简化的描述，但我发现它在解释过程时很有帮助。
注意，写一个不带守卫的for表达式就像在一个集合上调用map方法一样。
例如，下面的for推断将fruits中的所有字符串集合转为大写：
scala> val namesUpper = for n <- names yield n.toUpperCase
val namesUpper: List[String] = List(CHRIS, ED, MAURICE)在集合上调用map方法做同样的事情：
scala> val namesUpper = names.map(_.toUpperCase)
val namesUpper: List[String] = List(CHRIS, ED, MAURICE)当我刚开始学习Scala时，我所有的代码都是用 for/yield 表达式写的，直到有一天我意识到，使用不带守卫的 for/yield ，就等于使用 map方法。
另见
13.5小节“使用map将一个集合转换为另一个集合”，更详细了展示了for推断和map方法之间的比较。
4.5 像三元运算符一样使用if结构
问题
你熟悉如下Java中特殊的 三元运算符（ternary operator或称三目运算符 ） 语法：
int absValue = (a < 0) ? -a : a;并且你想知道如何在Scala中使用等价的表达方式。
解决方案
这是一个有点棘手的问题，因为与 Java 不同的是，在 Scala 中没有特殊的三元操作符；所以只需使用 if/else/then 表达式：
val a = 1
val absValue = if a < 0 then -a else a因为 if 表达式返回一个值，所以你可以将其嵌入到 print 语句中：
println(if a == 0 then "a" else "b")你还可以在另一个表达式中使用它，例如 hashCode 方法的这一部分：
hash = hash * prime + (if name == null then 0 else name.hashCode)if/else 表达式返回值这一事实也让你可以编写简洁的方法：
// 版本 1：单行样式
def abs(x: Int) = if x >= 0 then x else -x
def max(a: Int, b: Int) = if a > b then a else b
// 版本 2：方法体在单独的一行，如果你愿意的话
def abs(x: Int) =
if x >= 0 then x else -x
def max(a: Int, b: Int) =
if a > b then a else b讨论
“等式、关系和条件运算符”的Java文档页面（ https://oreil.ly/rUDNP ）指出，Java条件运算符 ?: “被称为三元运算符，因为它使用三个操作数。”
Java 在这里需要单独的语法，因为Java的if/else构造是一个语句；它没有返回值，仅用于副作用，例如更新可变字段。相反，因为Scala的if/else/then确实是一个表达式，并不需要特殊的操作符。参阅 24.3小节“编写表达式（而不是语句）”，以获取更多的语句和表达式的细节。
Arity（操作符词量） -- TODO 鸽子栏
三元 这个词与函数的操作符数量（ Arity ）有关。维基百科的“Arity页面”（ https://oreil.ly/CJtbV ）指出，“在逻辑、数学和计算机科学中，函数或操作的操作符数量是函数采用的参数或操作数的数量。” 一元运算符采用一个操作数，二元运算符采用两个操作数，三元运算符采用三个操作数。
4.6 像switch语句一样使用match表达式
问题
你有一种情况，你想创建一个简单的基于Java整数的switch语句，例如匹配一周中的天数、一年中的月数，以及一个整数映射到某个结果的其他场景。
解决方案
需要使用Scala的match表达式，如简单的基于整数的switch语句，请使用以下方法：
import scala.annotation.switch
// `i` 是一个整数
(i: @switch) match
case 0 => println("Sunday")
case 1 => println("Monday")
case 2 => println("Tuesday")
case 3 => println("Wednesday")
case 4 => println("Thursday")
case 5 => println("Friday")
case 6 => println("Saturday")
// 使用变量捕获默认值，以便你可以打印它
case whoa => println(s"Unexpected case: ${whoa.toString}")该示例展示了如何基于match执行副作用操作（println）。一个更加函数式的方法是从match表达式返回一个值：
import scala.annotation.switch
// `i` 是一个整数
val day = (i: @switch) match
case 0 => "Sunday"
case 1 => "Monday"
case 2 => "Tuesday"
case 3 => "Wednesday"
case 4 => "Thursday"
case 5 => "Friday"
case 6 => "Saturday"
case _ => "invalid day"// 默认，包罗万象@switch 注解
在编写这样的简单match表达式时，建议使用 @switch 注解，如下所示。如果switch无法编译为tableswitch或lookupswitch，此注释会在编译时提供警告。将match表达式编译为tableswitch或lookupswitch会更好地提高性能，因为它会生成分支表而不是决策树。当给表达式一个值时，它可以直接跳转到结果，而不是通过决策树。
Scala @switch 注释文档（ https://oreil.ly/rrNBP ）指出：
如果该注解存在，编译器将验证match是否已编译为tableswitch或lookupswitch，如果它编译为一系列条件表达式，则会发出错误。
可以通过一个简单的例子来展示 @switch 注解的效果。首先，将以下代码放入名为SwitchDemo.scala的文件中：
// 版本 1 - 编译为 tableswitch
import scala.annotation.switch
class SwitchDemo:
val i = 1
val x = (i: @switch) match
case 1 => "One"
case 2 => "Two"
case 3 => "Three"
case _ => "Other"然后像往常一样编译代码：
$ scalac SwitchDemo.scala编译此类不会产生警告并创建SwitchDemo.class输出文件。接下来，使用以下 javap 命令反汇编该文件：
$ javap -c SwitchDemo这个命令行的输出给出了类似如下的tableswitch：
16: tableswitch { // 1 to 3
1: 44
2: 52
3: 60
default: 68
}这表明 Scala 能够将match表达式优化为 tableswitch。（这是一件好事。）
接下来，对代码稍作改动，将整数文字 1 替换为一个值：
class SwitchDemo:
val i = 1
val one = 1 // added
val x = (i: @switch) match
case one => "One" // replaced the '1'
case 2 => "Two"
case 3 => "Three"
case _ => "Other"同样，使用scalac编译代码，但你会立即看到一条警告消息：
$ scalac SwitchDemo.scala
SwitchDemo.scala:7: warning: could not emit switch for @switch annotated match
val x = (i: @switch) match {
^
one warning found这条警告信息意味着既不能为match生成一个tableswitch，也不能为其生成一个lookupswitch。你可以通过运行 javap 的命令在生成的SwitchDemo.class文件上来确认这一点。当你查看该输出时，会看到前面示例中显示的tableswitch现在已消失。
Joshua Suereth在他的书Scala in Depth(Manning)中指出，在Scala中使用tableswitch优化必须满足以下条件：
匹配的值必须是已知的整数。
匹配的表达式必须是“简单的”。它不能包含任何类型检查、if 语句或提取器。
表达式的值必须在编译时可用。
应该有两个以上的 case 语句。
讨论
解决方案中的示例展示了两种处理默认“catch all”情况的方法。首先，如果你不关心默认匹配的值，你可以使用 _ 通配符来捕获它：
case _ => println("Got a default match")相反，如果你对默认匹配的内容感兴趣，请为其分配一个变量名称。然后，你可以在表达式的右侧使用该变量：
case default => println(default)使用像default这样的名称通常是最有意义的，但你可以为变量使用任何合法名称：
case oops => println(oops)重要的是要知道，如果你不处理默认情况，你会得到MatchError。给定这个match表达式：
i match
case 0 => println("0 received")
case 1 => println("1 is good, too")如果i是0或1以外的值，则表达式将引发MatchError：
scala.MatchError: 42 (of class java.lang.Integer)
at .<init>(<console>:9)
at .<clinit>(<console>)
much more error output here ...因此，除非你有意编写偏函数，否则你将需要处理默认情况。
你真的需要match表达式吗？
请注意，对于这样的示例，你可能不需要match表达式。例如，任何时候你只是将一个值映射到另一个值，最好使用Map：
val days = Map(
0 -> "Sunday",
1 -> "Monday",
2 -> "Tuesday",
3 -> "Wednesday",
4 -> "Thursday",
5 -> "Friday",
6 -> "Saturday"
)
println(days(0)) // prints "Sunday"另见
有关JVM开关如何工作的更多信息，请参阅编译开关的JVM规范（ https://oreil.ly/oUcwX ）。
关于lookupswitch 和tableswitch 之间的区别，这个Stack Overflow页面（ https://oreil.ly/JvE3P ）指出，“区别在于lookupswitch 使用带有键和标签的表，而tableswitch 只使用带有标签的表。” 同样，有关更多详细信息，请参阅Java 虚拟机 (JVM) 规范的“Compiling Switches”部分（ https://oreil.ly/oUcwX ）。
有关偏函数的更多信息，请参阅10.7小节“创建偏函数”。
4.7 用一个case语句匹配多个条件
问题
你需要在match的多个匹配条件中执行相同的业务逻辑，而不是为每个case重复你的业务逻辑，你希望为匹配条件使用同一个业务逻辑代码。
解决方案
将执行相同业务逻辑的匹配条件放在一行，用 | 分隔（管道）字符：
// `i` 是一个 Int
i match
case 1 | 3 | 5 | 7 | 9 => println("odd")
case 2 | 4 | 6 | 8 | 10 => println("even")
case _ => println("too big")相同的语法适用于字符串和其他类型。下面是一个基于字符串匹配的例子：
val cmd = "stop"
cmd match
case "start" | "go" => println("starting")
case "stop" | "quit" | "exit" => println("stopping")
case _ => println("doing nothing")下面的例子展示了如何在每个case语句中匹配多个对象：
enum Command:
case Start, Go, Stop, Whoa
import Command.*
def executeCommand(cmd: Command): Unit = cmd match
case Start | Go => println("start")
case Stop | Whoa => println("stop")如上所示，为每个case语句定义多个可能匹配项的能力可以简化你的代码。
另见
相关方法请参阅4.12小节。
4.8 将match表达式的结果分配给变量
问题
你想要从match表达式返回一个值并将其分配给变量，或者使用match表达式作为方法的主体。
解决方案
要将match表达式的结果分配给变量，请在表达式之前创建变量并赋值，如下面例子中的变量evenOrOdd：
val someNumber = scala.util.Random.nextInt()
val evenOrOdd = someNumber match
case 1 | 3 | 5 | 7 | 9 => "odd"
case 2 | 4 | 6 | 8 | 10 => "even"
case _ => "other"这种方法通常用于创建短方法或函数。例如，下面的方法实现了Perl对true和false的定义：
def isTrue(a: Matchable): Boolean = a match
case false | 0 | "" => false
case _ => true讨论
你可能听说Scala是一种面向表达式的编程（expression-oriented programming（EOP））语言。EOP意味着每个构造都是一个表达式，产生一个值，并且没有副作用。与其他语言不同，在Scala中，每个构造（如if、match、for和try）都会返回一个值。有关更多详细信息，请参阅24.3小节。
4.9 在match表达式中访问默认情况的值
问题
你希望在使用match表达式时访问默认“catch all”的case表达式的值，但当前在使用 _ 通配符语法匹配时无法访问该值。
解决方案
不要使用 _ 通配符，而是为默认case分配一个变量名：
i match
case 0 => println("1")
case 1 => println("2")
case default => println(s"You gave me: $default")通过给默认匹配项指定一个变量名，你可以在表达式右侧访问该变量。
讨论
这种技巧的关键是使用一个变量名作为默认匹配，而不是通常的 _ 通配符。你分配的名称可以是任何合法的变量名称，因此你可以将其命名为其他名称，而不是default名称，例如waht：
i match
case 0 => println("1")
case 1 => println("2")
case what => println(s"You gave me: $what" )提供默认匹配很重要。不这样做可能会导致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 ...有关MatchError的更多详细信息，请参阅4.6小节的讨论。
4.10 在match表达式中使用模式匹配
问题
你需要在match表达式中匹配一个或多个模式，该模式可以是常量模式、变量模式、构造函数模式、序列模式、元组模式或类型化模式。
解决方案
为要匹配的每个模式定义一个case语句。 以下方法显示了你可以在match表达式中使用的许多不同类型的模式的示例：
def test(x: Matchable): String = x match
// 常量模式
case 0 => "zero"
case true => "true"
case "hello" => "you said 'hello'"
case Nil => "an empty List"
// 序列模式
case List(0, _, _) => "a 3-element list with 0 as the first element"
case List(1, _*) => "list, starts with 1, has any number of elements"
// 元组模式
case (a, b) => s"got $a and $b"
case (a, b, c) => s"got $a, $b, and $c"
// 构造函数模式
case Person(first, "Alexander") => s"Alexander, first name = $first"
case Dog("Zeus") => "found a dog named Zeus"
// 类型化模式
case s: String => s"got a string: $s"
case i: Int => s"got an int: $i"
case f: Float => s"got a float: $f"
case a: Array[Int] => s"array of int: ${a.mkString(",")}"
case as: Array[String] => s"string array: ${as.mkString(",")}"
case d: Dog => s"dog: ${d.name}"
case list: List[_] => s"got a List: $list"
case m: Map[_, _] => m.toString
// 默认通配符模式
case _ => "Unknown"
end test上述方法中的大match表达式显示了Programming in Scala一书中描述的不同类别的模式，包括常量模式、序列模式、元组模式、构造函数模式和类型化模式。
以下代码展示了 match 表达式中的所有情况，每个表达式的输出显示在注释中。 注意println方法是在导入时重命名使得例子更简洁：
import System.out.{println => p}
case class Person(firstName: String, lastName: String)
case class Dog(name: String)
// 触发常量模式
p(test(0)) // zero
p(test(true)) // true
p(test("hello")) // you said 'hello'
p(test(Nil)) // an empty List
// 触发序列模式
p(test(List(0,1,2))) // a 3-element list with 0 as the first element
p(test(List(1,2))) // list, starts with 1, has any number of elements
p(test(List(1,2,3))) // list, starts with 1, has any number of elements
p(test(Vector(1,2,3))) // vector, starts w/ 1, has any number of elements
// 触发元组模式
p(test((1,2))) // got 1 and 2
p(test((1,2,3))) // got 1, 2, and 3
// 触发构造函数模式
p(test(Person("Melissa", "Alexander"))) // Alexander, first name = Melissa
p(test(Dog("Zeus"))) // found a dog named Zeus
// 触发类型化的模式
p(test("Hello, world")) // got a string: Hello, world
p(test(42)) // got an int: 42
p(test(42F)) // got a float: 42.0
p(test(Array(1,2,3))) // array of int: 1,2,3
p(test(Array("coffee", "apple pie"))) // string array: coffee,apple pie
p(test(Dog("Fido"))) // dog: Fido
p(test(List("apple", "banana"))) // got a List: List(apple, banana)
p(test(Map(1->"Al", 2->"Alexander"))) // Map(1 -> Al, 2 -> Alexander)
// 触发通配符模式
p(test("33d")) // you gave me this string: 33d请注意，在 match 表达式中，List和Map表达式是这样编写的：
case m: Map[_, _] => m.toString
case list: List[_] => s"thanks for the List: $list"也可以写成如下的形式：
case m: Map[A, B] => m.toString
case list: List[X] => s"thanks for the List: $list"我更喜欢下划线语法，因为它清楚地表明我不关心List或Map中存储的内容。实际上，有时我可能对存储在List或Map中的内容感兴趣，但由于JVM中的类型擦除，这成为一个难题。
类型擦除 -- TODO 耗子栏
当我第一次写这个例子的时候，我写的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]"
^如果你不熟悉类型擦除，我在本章节的查看更多部分中包含了一个链接，该链接的网页描述了它是如何在JVM上工作的。
讨论
通常，当使用这种技术时，你的方法将期望一个从基类或特质继承的实例，然后你的case语句将引用该基类型的子类型。这是在测试方法中推断出来的，其中每个Scala类型都是 Matchable 的子类型。下面的代码展示了一个更明显的例子。
在我的Blue Parrot 应用程序（ https://alvinalexander.com/blueparrot ）中，它要么播放声音文件，要么以随机的时间间隔“说出”它给出的文本，如下方法所示：
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(thing: RandomThing) = thing match
case RandomFile(f) => playSoundFile(f)
case RandomString(s) => speakText(s)makeRandomNoise方法携带一个RandomThing类型的参数，且match表达式处理它的两个子类型RandomFile和RandomString的方法。
模式
解决方案中的大match表达式显示了在 Programming in Scala 一书中定义的各种模式（由Scala语言的创建者Martin Odersky合著）。这些模式包括：
常量模式
变量模式
构造函数模式
序列模式
元组模式
类型化模式
变量绑定模式
这些模式将在以下段落中进行简要描述。
常量模式
一个常量模式只能匹配它自己。任何文字都可以用作常量。如果将 0 指定为常量，则只会匹配为 0 的 Int 值。例如：
case 0 => "zero"
case true => "true"变量模式
这并没有在解决方案的大match示例中演示，但匹配任何对象的一个变量模式，就像 _ 通配符一样。可以被Scala绑定到任何对象，这使你可以在case语句的右侧使用变量。例如，在match表达式的末尾，你可以像这样使用 _ 通配符来捕获其他任何内容：
case _ => s"Hmm, you gave me something ..."但是使用变量模式，你可以改为：
case foo => s"Hmm, you gave me a $foo"更多信息请参阅4.9小节。
构造函数模式
构造函数模式允许你在 case 语句中匹配构造函数。如示例所示，你可以根据需要指定常量或变量模式：
case Person(first, "Alexander") => s"found an Alexander, first name = $first"
case Dog("Zeus") => "found a dog named Zeus"序列模式
你可以匹配List、Array、Vector等序列。使用 _ 字符代表序列中的一个元素，使用 _* 代表零个或多个元素，如示例中所示：
case List(0, _, _) => "a 3-element list with 0 as the first element"
case List(1, _*) => "list, starts with 1, has any number of elements"
case Vector(1, _*) => "vector, starts with 1, has any number of elements"元组模式
如示例中所示，你可以匹配元组模式并访问元组中每个元素的值。如果你对值不感兴趣，也可以使用 _ 通配符：
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"如示例所示，你可以在声明后访问表达式的模式变量。
变量绑定模式
有时你可能希望将变量添加到模式中。你可以使用以下通用语法来执行此操作：
case variableName @ pattern => ...这称为变量绑定模式。使用时，将match表达式的输入变量与模式进行比较，如果匹配，则将输入变量绑定到variableName。
通过展示它解决的问题可以最好地体现它的有用性。假设你有前面演示的 List 模式：
case List(1, _*) => "a list beginning with 1, having any number of elements"正如展示的那样，这让你可以匹配第一个元素为1的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"此代码能够完成编译并按预期工作，你也可以在语句的右侧访问该List。
以下代码展示了该示例以及该处理方式的高效：
case class Person(firstName: String, lastName: String)
def matchType(x: Matchable): String = x match
//case x: List(1, _*) => s"$x" // doesn’t compile
case x @ List(1, _*) => s"$x" // prints the list
//case Some(_) => "got a Some" // works, but can’t access the Some
//case Some(x) => s"$x" // returns "foo"
case x @ Some(_) => s"$x" // returns "Some(foo)"
case p @ Person(first, "Doe") => s"$p" // returns "Person(John,Doe)"
end matchType
@main def test2 =
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)"在match表达式内的两个List示例中，注释掉的代码行是无法编译的，但第二行展示了如何匹配所需的List对象，然后将该列表绑定到变量x。当这行代码匹配像 List(1,2,3) 这样的列表时，它会产生输出 List(1, 2, 3)，如第一个println语句的输出所示。
第一个Some示例表示你可以将Some按所示方式匹配，但你无法在右侧的表达式访问其信息。第二个示例展示了如何访问Some中的值，第三个示例更进一步，让你可以访问Some对象本身。当它与第二个println调用匹配时，它会打印Some(foo)，表明你现在可以访问Some对象。
最后，此方法用于匹配姓氏为 Doe 的 Person。此语法允许你将模式匹配的结果分配给变量p，然后在表达式的右侧访问该变量。
在match表达式中使用Some和None
为了完善这些示例，你经常将Some和None与match表达式一起使用。
例如，当你尝试使用类似toIntOption的方法从字符串创建数字时，你可以在match表达式中处理结果：
val s = "42"
// later in the code ...
s.toIntOption match
case Some(i) => println(i)
case None => println("That wasn't an Int")在match表达式中，你只需指定Some和None情况，如上所示来处理成功和失败条件。参阅24.6小节“使用 Scala 的错误处理类型（Option、Try 和 Either）”，以了解更多使用Option、Some和None的示例。
另见
Stack Overflow（ http://bit.ly/15odxST ）上的讨论，在使用match表达式时绕过类型擦除
My Blue Parrot应用程序（ https://alvinalexander.com/blueparrot ）
类型擦除文档（ http://bit.ly/139WrFj ）
4.11 在match表达式中使用枚举和样例类
问题
你想在match表达式中匹配枚举、样例类或样例对象。
解决方案
以下示例展示了如何使用模式匹配枚举的不同方式，具体取决于你在每个case语句右侧需要哪些信息。首先，这是一个名为Animal的枚举，它具有三个实例Dog、Cat和Woodpecker：
enum Animal:
case Dog(name: String)
case Cat(name: String)
case Woodpecker给定该枚举，下面getInfo方法展示了在match达式中匹配枚举类型的不同方式：
import Animal.*
def getInfo(a: Animal): String = a match
case Dog(moniker) => s"Got a Dog, name = $moniker"
case _: Cat => "Got a Cat (ignoring the name)"
case Woodpecker => "That was a Woodpecker"下面的例子展示了当给定Dog、Cat和Woodpecker时getInfo如何工作：
println(getInfo(Dog("Fido"))) // Got a Dog, name = Fido
println(getInfo(Cat("Morris"))) // Got a Cat (ignoring the name)
println(getInfo(Woodpecker)) // That was a Woodpecker在getInfo中，如果Dog类匹配，则提取其名称并用于在表达式右侧创建字符串。为了展示提取名称时使用的变量名称可以是任何合法的变量名称，我使用名称moniker。
匹配Cat时，我想忽略名称，因此我使用上述的语法来匹配任何Cat实例。因为Woodpecker不是使用参数创建的，所以它也匹配，如上所示。
讨论
在 Scala 2 中，sealed traits与case class和case object一起使用，以实现与枚举相同的效果：
sealed trait Animal
case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal
case object Woodpecker extends Animal如6.12小节“如何使用枚举创建命名值集”所述，枚举是（a）定义sealed class或trait以及（b）定义为类的伴随对象成员的值的快捷方式。这两种方法都可以在getInfo的match表达式中使用，因为case class有一个内置的unapply方法，可以让它们在match表达式中工作。我在7.8小节“使用unapply实现模式匹配”中描述了它是如何工作的。
4.12 将if表达式（守卫语句）添加到case语句中
问题
你希望将特定的逻辑添加到match表达式中的case语句，例如允许一定范围的数字或匹配模式，但前提是该模式与某些附加条件匹配。
解决方案
在你的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...")用它来匹配对象的不同值：
i 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")只要你的类有一个unapply方法，你就可以在你的if守卫语句中引用类字段。例如，因为一个样例类有一个自动生成的unapply方法，给定这个Stock类和实例：
case class Stock(symbol: String, price: BigDecimal)
val stock = Stock("AAPL", BigDecimal(132.50))你可以在类变量中使用模式匹配和守卫语句条件：
stock match
case s if s.symbol == "AAPL" && s.price < 140 => buy(s)
case s if s.symbol == "AAPL" && s.price > 160 => sell(s)
case _ => // do nothing你还可以从case class和已正确实现unapply方法的类中提取字段，并在你的守卫语句条件中使用这些字段。例如：
// 提取“case”中的“name”，然后使用该值
def speak(p: Person): Unit = p match
case Person(name) if name == "Fred" =>
println("Yabba dabba doo")
case Person(name) if name == "Bam Bam" =>
println("Bam bam!")
case _ =>
println("Watch the Flintstones!")如果将Person定义为case class，则可以正常运行：
case class Person(aName: String)或者正确实现了unapply方法的Person类：
class Person(val aName: String)
object Person:
// 'unapply' 解构 Person。它也被称为
// 提取器，Person 是一个“提取器对象”。
def unapply(p: Person): Option[String] = Some(p.aName)有关如何编写unapply方法的更多详细信息，请参阅7.8小节“使用unapply实现模式匹配”。
讨论
每当你想在case语句的左侧（即 => 符号之前）添加条件推断时，都可以使用这样的if表达式。
请注意，所有这些示例都可以通过将if推断放在表达式的右侧来编写，如下所示：
case Person(name) =>
if name == "Fred" then println("Yabba dabba doo")
else if name == "Bam Bam" then println("Bam bam!")但是，在许多情况下，通过将if守卫语句直接与case语句相结合，你的代码将更简单、更易于阅读；它有助于将守卫与后来的业务逻辑分开。
另请注意，这个Person示例有点刻意，因为Scala的模式匹配功能让你可以像这样编写案例：
def speak(p: Person): Unit = p match
case Person("Fred") => println("Yabba dabba doo")
case Person("Bam Bam") => println("Bam bam!")
case _ => println("Watch the Flintstones!")在这种情况下，当Person更复杂并且你需要做的不仅仅是匹配其参数时，确实需要一个守卫语句。
此外，如4.10小节中所示，与其使用如下的解决方案：
case x if (x == 2 || x == 3) => println(x)还有另一种可能的解决方案是使用变量绑定模式：
case x @ (2|3) => println(x)这段代码可以理解为：“如果match表达式的值 x 是 2 或 3，则将该值赋给变量x，然后使用println打印 x。”
4.13 使用match表达式代替isInstanceOf
问题
你想编写一段代码来匹配一种类型或多种不同的类型。
解决方案
你可以使用isInstanceOf方法来测试对象的类型：
if x.isInstanceOf[Foo] then ...然而，“Scala方式”更倾向于match表达式这种工作方式，因为使用match表达式通常比isInstanceOf更强大和更方便。
例如，在一个基本用例中，你可能会收到一个未知类型的对象，并希望确定该对象是否是Person的实例。这段代码展示了如何编写一个match表达式，如果类型是Person，则返回true，否则返回false：
def isPerson(m: Matchable): Boolean = m match
case p: Person => true
case _ => false更常见的场景是你将有一个这样的模型：
enum Shape:
case Circle(radius: Double)
case Square(length: Double)然后你会想写一个方法来计算Shape的面积。此问题的一种解决方案是使用模式匹配来编写area方法：
import Shape.*
def area(s: Shape): Double = s match
case Circle(r) => Math.PI * r * r
case Square(l) => l * l
// examples
area(Circle(2.0)) // 12.566370614359172
area(Square(2.0)) // 4.0这是一种常见的用法，其中area接受一个参数，其类型是你在match中解构类型的直接父级。
请注意，如果Circle和Square采用额外的构造函数参数，并且你只需要访问它们的半径和长度，则完整的解决方案如下所示：
enum Shape:
case Circle(x0: Double, y0: Double, radius: Double)
case Square(x0: Double, y0: Double, length: Double)
import Shape.*
def area(s: Shape): Double = s match
case Circle(_, _, r) => Math.PI * r * r
case Square(_, _, l) => l * l
// examples
area(Circle(0, 0, 2.0)) // 12.566370614359172
area(Square(0, 0, 2.0)) // 4.0如match表达式中的case语句所示，只需忽略不需要的参数，用 _ 字符指代它们。
讨论
如上所示，match表达式允许你匹配多种类型，因此使用它来替换isInstanceOf方法只是对match/case语法和Scala应用程序中使用的一般模式匹配方法的自然使用。
对于最基本的用例，isInstanceOf方法可以是一种更简单的方法来确定一个对象是否匹配一个类型：
if (o.isInstanceOf[Person]) { // handle this ...但是，对于比这更复杂的场景，match表达式比长if/then/else if语句更具可读性。
面向对象中的isInstanceOf -- TODO 方块中
在面向对象编程中，使用isInstanceOf可能表明你没有正确使用继承。例如，有人可能写过这样的代码：
enum Animal:
case Cat, Dog, Ostrich如果由于某种原因你发现自己正在编写这样的isInstanceOf代码，这表明你可能做错了：
if currentInstance.isInstanceOf[Ostrich] then ...相反，OOP代码看起来像这样：
val animal: Animal =
AnimalFactory.getAnimal("big flightless bird")
// some time later in your code ...
animal.walk()或者这样：
val oz: Ostrich =
AnimalFactory.getAnimal(
"big flightless bird"
).asInstanceOf[Ostrich]
// some time later in your code ...
oz.tryToFly()如果你写这样的代码来接收一个Animal，代码不应该关心是否你收到的动物是Cat、Dog或Ostrich，如果你立即强制转换该实例到Ostrich，你知道你可以调用它的任何其他方法。因此，在OOP中，你应该很少需要使用isInstanceOf测试实例。相反，在函数式编程代码中，可以一直使用match表达式的模式匹配来处理类型。
另见
4.10小节展示了更多的 match 的技术。
4.14 在match表达式中使用列表
问题
你知道List数据结构与其他顺序数据结构有点不同：它由cons单元构建，并以Nil元素结束。你想要结合match表达式时来利用这个优势， 例如在编写递归时功能。
解决方案
你可以创建一个包含整数1、2和3的列表，如下所示：
val xs = List(1, 2, 3)或像这样：
val ys = 1 :: 2 :: 3 :: Nil如第二个示例所示，List以Nil元素结尾，你可以在编写match表达式利用这个优势来处理列表，尤其是当编写递归算法。例如，在下面的listToString方法中，如果当前元素不是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 "在处理其他类型和不同算法的列表时，可以使用相同的方法。例如，虽然你可以只编写List(1,2,3).sum，但此示例展示了如何使用匹配和递归编写你自己的sum方法：
def sum(list: List[Int]): Int = list match
case Nil => 0
case n :: rest => n + sum(rest)同样，这是一个乘积算法：
def product(list: List[Int]): Int = list match
case Nil => 1
case n :: rest => n * product(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 = 15
scala> product(nums)
res1: Int = 120不要忘记reduce和fold操作 -- TODO 耗子栏
虽然递归很棒，但Scala在集合类上的各种reduce和fold方法是为了让你在遍历集合的同时应用算法，且它们通常不需要递归。
例如，你可以使用以下两种形式中的任何一种来编写求和算法：
// long form
def sum(list: List[Int]): Int = list.reduce((x,y) => x + y)
// short form
def sum(list: List[Int]): Int = list.reduce(_ + _)有关详细信息，请参阅13.10小节“使用reduce和fold方法遍历集合”。
讨论
如上所示，递归是一种方法调用自身以解决问题的技术。在函数式编程中——所有变量都是不可变的——递归提供了一种迭代List中的元素以解决问题的方法，例如计算List中所有元素的总和或乘积。特别是使用List类的一个好处是List以Nil元素结尾，因此你的递归算法通常具有以下模式：
def myTraversalMethod[A](xs: List[A]): B = xs match
case head :: tail =>
// do something with the head
// pass the tail of the list back to your method, i.e.,
// `myTraversalMethod(tail)`
case Nil =>
// end condition here (0 for sum, 1 for product, etc.)
// end the traversal函数式编程中的变量 -- TODO 耗子栏
在FP中，我们使用术语变量，但当我们只使用不可变变量时，这个词似乎没有什么意义，即我们有一个不能变化的变量。
这里发生的事情是，我们真正的意思是代数意义上的“变量”，而不是计算机编程意义上的“变量”。例如，在代数中，当我们写下这个代数方程时，我们说a、b和c是变量：
a = b * c但是，一旦它们被分配，它们就不能改变。术语变量在函数式编程中具有相同的含义。
另见
我最初发现递归是一个不必要的难以掌握的话题，所以我写了很多关于它的博客文章：
“Scala Recursion Examples (Recursive Programming)” （ https://oreil.ly/5LASz ）
“Recursive: How Recursive Function Calls Work”（ https://oreil.ly/vIfgS ）
“Tail-Recursive Algorithms in Scala”（ https://oreil.ly/wJat4 ）
“Recursion: Visualizing the Recursive sum Function”（ https://oreil.ly/wJat4 ）
在“Recursion: Thinking Recursively”（ https://oreil.ly/0grXf ）中，我写了特征（identity）元素，包括 0 是和运算的特征元素，1 是乘运算的特征元素，而""（一个空字符串）是处理字符串的特征元素。
4.15 用try/catch匹配一个或多个异常
问题
你想在try/catch块中捕获一个或多个异常。
解决方案
Scala的try/catch/finally语法类似于Java，但它在catch块中使用了match表达式：
try
doSomething()
catch
case e: SomeException => e.printStackTrace
finally
// do your cleanup work当你需要捕获和处理多个异常时，只需将异常类型添加为不同的case语句即可：
try
openAndReadAFile(filename)
catch
case e: FileNotFoundException =>
println(s"Couldn’t find $filename.")
case e: IOException =>
println(s"Had an IOException trying to read $filename.")如果你愿意，也可以像这样编写代码：
try
openAndReadAFile(filename)
catch
case e: (FileNotFoundException | IOException) =>
println(s"Had an IOException trying to read $filename")讨论
综上所述，Scala的case语法用于匹配不同的可能出现的异常。如果你不关心抛出哪些特定的异常，并且想捕获所有异常并对其进行处理（例如记录它们），请使用以下语法：
try
openAndReadAFile(filename)
catch
case t: Throwable => logger.log(t)由于某种原因，如果你不关心异常的值，你也可以像这样捕获它们并忽略它们：
try
openAndReadAFile(filename)
catch
case _: Throwable => println("Nothing to worry about, just an exception")基于try/catch的方法
如本章的介绍所示，try/catch/finally块可以返回一个值，因此可以用作方法的主体。以下方法返回一个 Option[String]。如果找到文件，它返回一个包含字符串的 Some，如果读取文件有问题，则返回None：
import scala.io.Source
import java.io.{FileNotFoundException, IOException}
def readFile(filename: String): Option[String] =
try
Some(Source.fromFile(filename).getLines.mkString)
catch
case _: (FileNotFoundException|IOException) => None这展示了一种从try表达式返回值的方式。
这些天来，我很少编写抛出异常的方法，但是像Java一样，你可以从catch子句中抛出异常。然而，因为Scala没有检查异常，你不需要指定一个方法抛出的异常。如下例子所示，该方法不包含任何注解：
// 危险：此方法不会警告你可能会抛出异常
def readFile(filename: String): String =
try
Source.fromFile(filename).getLines.mkString
catch
case t: Throwable => throw t这实际上是一种非常危险的方法 —— 不要写这样的代码！
要声明方法抛出异常，请将 @throws 注解添加到方法定义中：
// 更好：这个方法警告其他人可以抛出异常
@throws(classOf[NumberFormatException])
def readFile(filename: String): String =
try
Source.fromFile(filename).getLines.mkString
catch
case t: Throwable => throw t虽然最后一种方法比前一种方法好，但两者都不是首选的方法。 “Scala 方式”是从不抛出异常。相反，你应该使用Option，如前所示，或者当你想要返回有关失败的信息时，使用Try/Success/Failure或Either/Right/Left类。下面的例子展示了如何使用Try：
import scala.io.Source
import java.io.{FileNotFoundException, IOException}
import scala.util.{Try,Success,Failure}
def readFile(filename: String): Try[String] =
try
Success(Source.fromFile(filename).getLines.mkString)
catch
case t: Throwable => Failure(t)每当涉及异常消息时，我总是更喜欢使用Try或Either而不是Option，因为它们使你可以访问Failure或Left中的消息，其中Option仅返回None。
捕捉一切的简洁方法
捕获所有异常的另一种简洁方法是使用scala.util.control.Exception对象的allCatch方法。以下示例展示了如何使用 allCatch，先展示成功案例，再展示失败案例。每个表达式的输出放在每一行的注释之后：
import scala.util.control.Exception.allCatch
// OPTION
allCatch.opt("42".toInt) // Option[Int] = Some(42)
allCatch.opt("foo".toInt) // Option[Int] = None
// TRY
allCatch.toTry("42".toInt) // Matchable = 42
allCatch.toTry("foo".toInt)
// Matchable = Failure(NumberFormatException: For input string: "foo")
// EITHER
allCatch.either("42".toInt) // Either[Throwable, Int] = Right(42)
allCatch.either("foo".toInt)
// Either[Throwable, Int] =
// Left(NumberFormatException: For input string: "foo")另见
有关声明方法可能抛出异常的更多示例，请参阅8.7小节“声明方法可以抛出异常”。
有关使用 Option/Some/None 和 Try/Success/Failure 的更多信息，请参阅24.6小节“使用Scala的错误处理类型（Option、Try 和 Either）”。
有关 allCatch 的更多信息，请参阅 scala.util.control.Exception 的Scaladoc页面（ https://oreil.ly/6pUah ）。
4.16 在try/catch/finally块中使用变量之前先声明该变量
问题
你想在try块中使用一个对象，并且需要在finally代码中访问它，例如当你需要调用某个对象的close方法时。
解决方案
通常，在try/catch块之前将你的字段声明为Option，然后在try子句中将变量绑定到一个Some。如下所示，其中sourceOption字段声明在try/catch块之前，并在try子句中进行赋值：
import scala.io.Source
import java.io.*
var sourceOption: Option[Source] = None
try
sourceOption = Some(Source.fromFile("/etc/passwd"))
sourceOption.foreach { source =>
// do whatever you need to do with 'source' here ...
for line <- source.getLines do println(line.toUpperCase)
}
catch
case ioe: IOException => ioe.printStackTrace
case fnf: FileNotFoundException => fnf.printStackTrace
finally
sourceOption match
case None =>
println("bufferedSource == None")
case Some(s) =>
println("closing the bufferedSource ...")
s.close这是一个预先写好的例子 —— 16.1小节“读取文本文件”，展示了很多更好的读取文件的方法 —— 但它确实展示了这种方式。首先，在try块之前定义一个var字段作为Option：
var sourceOption: Option[Source] = None然后，在try子句中，将一个Some值赋值给该变量：
sourceOption = Some(Source.fromFile("/etc/passwd"))当你有一个资源要关闭时，使用像这样的技术（尽管 16.1 节“读取文本文件”也展示了一种更好的关闭资源的方法）。请注意，如果在此代码中抛出异常，则finally里面的sourceOption将为None值。如果没有抛出异常，将执行match表达式的Some分支。
讨论
本小节的一个关键点是了解声明未初始化的Option字段的语法：
var in: Option[FileInputStream] = None
var out: Option[FileOutputStream] = None也可以使用第二种形式，但首选第一种形式：
var in = None: Option[FileInputStream]
var out = None: Option[FileOutputStream]不要使用null值
当我第一次开始使用Scala时，我认为编写此代码的唯一方法是使用 null 值。以下代码展示了我在检查电子邮件帐户的应用程序中使用的方法。此代码中的store和inbox字段被声明为具有Store和Folder类型的 null 字段（来自javax.mail包）：
// (1) 声明 null 变量（不要使用 null；这只是一个例子）
var store: Store = null
var inbox: Folder = null
try
// (2) 使用 try 块中的变量/字段
store = session.getStore("imaps")
inbox = getFolder(store, "INBOX")
//这里的其余代码...
catch
case e: NoSuchProviderException => e.printStackTrace
case me: MessagingException => me.printStackTrace
finally
// (3) 在 finally 子句中的对象上调用 close()
if (inbox != null) inbox.close
if (store != null) store.close但是，在Scala工作中，甚至让你有机会忘记空值的存在，因此不推荐使用这种方法。
另见
有关 (a) 如何不使用 null 值以及 (b) 如何使用 Option、Try 和 Either 的更多详细信息，请参阅这些章节：
24.5小节，“消除代码中的null值”
24.6小节，“使用Scala的错误处理类型（Option、Try 和 Either）”
24.8小节，“使用高阶函数处理Option值”
每当你编写需要在启动时打开资源并在完成时关闭资源的代码时，使用 scala.util.Using 对象（ https://oreil.ly/N47eZ ）会很有帮助。参阅16.1小节“读取文本文件”，以了解如何使用这个对象以及更好的读取文本文件的方法。
此外，24.8小节“使用高阶函数处理Option值”，展示了除了使用match表达式之外的其他处理Option值的方法。
4.17 创建自己的控制结构
问题
你想定义自己的控制结构，简化代码或创建领域特定语言 (DSL)。
解决方案
得益于多参数列表、传名参数、扩展方法、高阶函数等功能，你可以自定义创建一个像控制结构一样的有效代码。
例如，假设 Scala 没有自己的内置 while 循环，而你想创建自己的自定义whileTrue循环，可以像这样使用它：
var i = 0
whileTrue (i < 5) {
println(i)
i += 1
}要创建此whileTrue控制结构，请定义一个名为whileTrue的方法，该方法采用两个参数列表。第一个参数处理判断条件——在该示例中，i < 5——第二个参数是用户想要运行的代码块，即大括号之间的代码。将这两个参数定义为传名参数。因为whileTrue只用于副作用，比如更新可变变量或打印到控制台，所以声明它返回Unit。方法大致的签名如下所示：
def whileTrue(testCondition: => Boolean)(codeBlock: => Unit): Unit = ???实现方法主体的一种方法是编写递归算法。此代码展示了一个完整的解决方案：
import scala.annotation.tailrec
object WhileTrue:
@tailrec
def whileTrue(testCondition: => Boolean)(codeBlock: => Unit): Unit =
if (testCondition) then
codeBlock
whileTrue(testCondition)(codeBlock)
end if
end whileTrue在这段代码中，对testCondition求值，如果条件为真，则执行codeBlock，然后递归调用whileTrue。它一直在调用自己，直到测试条件返回false。
要测试此代码，首先将其导入：
import WhileTrue.whileTrue然后运行前面显示的whileTrue循环，你会看到它的工作原理是符合预期的。
讨论
Scala语言的创建者有意识地决定不在Scala中实现某些关键字，而是通过Scala库实现功能。例如，Scala没有内置的break和continue关键字。相反，它通过一个库来实现它们，正如我在我的博客文章 “Scala：如何在 for 和 while 循环中使用 break 和 continue”（ https://oreil.ly/KOAHI )中所描述的那样。
如解决方案中所示，创建自己的控制结构的能力来自以下功能：
多个参数列表让你可以像我对whileTrue 所做的那样：创建一个参数组用于测试条件，第二组用于代码块。
传名参数还可以让你做我对whileTrue 所做的事情：接受的参数在方法内部访问它们之前是不会对其进行评估的。
类似地，中缀表示法、高阶函数、扩展方法和流式接口等其他特性允许你创建其他自定义控制结构和 DSL。
传名参数
传名参数是whileTrue控制结构的重要组成部分。在Scala中，重要的是要知道使用 => 定义方法参数的语法：
def whileTrue(testCondition: => Boolean)(codeBlock: => Unit) =
----- -----你正在创建所谓的传名调用或传名参数。仅当在你的方法内部访问时才评估计算传名参数，因此，正如我所写的博客文章“如何在Scala中使用传名参数”（ https://oreil.ly/fuWGM ）和“Scala和传名调用参数”（ https://oreil.ly/shdre ），这些参数的更准确的名称是“访问时求值”。那是因为这正是它们的工作方式：只有在方法内部访问它们时才会评估计算它们。正如我在第二篇博文中所指出的，Rob Norris进行了比较，即传名参数就像接收一个def方法。
另一个例子
在whileTrue示例中，我使用递归调用来保持循环运行，但对于更简单的控制结构，你不需要递归。例如，假设你想要一个接受两个测试条件的控制结构，如果两个测试条件都为真，就运行提供的代码块。使用该控制结构的表达式如下所示：
doubleIf(age > 18)(numAccidents == 0) { println("Discount!") }在这种情况下，将doubleIf定义为采用三个参数列表的方法，每个参数都是一个传名参数：
// 两个“if”条件测试
def doubleIf(test1: => Boolean)(test2: => Boolean)(codeBlock: => Unit) =
if test1 && test2 then codeBlock因为doubleIf只需要执行一次测试，不需要无限循环，因此不需要在其方法体中进行递归调用。它只是检查两个测试条件，如果它们都为true，则执行codeBlock。
另见
David Pollak (Apress) 所著的 Beginning Scala 一书中展示了我最喜欢使用这种技术的一个方法。虽然它已被scala.util.Using废弃对象，我在这篇博文“The using Control Structure in Beginning Scala“（ https://oreil.ly/fiLHH ）中描述了该技术的工作原理。
Scala Breaks 类用于在for循环中实现break和continue功能，我写了一篇关于它的文章：“Scala: How to Use break and continue in for and while Loops”（ https://oreil.ly/KOAHI ）。Breaks类源代码相当简单，并提供了另一个如何实现控制结构的示例。你可以在其Scaladoc页面（ https://oreil.ly/xI78S ）上以找到其源代码。
最后更新于
这有帮助吗？