Scala 基础（6）—— 控制结构

1. Scala 的内建控制结构

Scala 有几个内建的控制结构，包括：

• if 表达式
• while 循环和 do-while 循环
• for 表达式
• try 表达式
• match 表达式

Scala 的所有控制结构都返回某种值作为结果，这是函数式编程采取的策略：

程序是被用来计算出某个值，所以程序的各个组成部分也应该计算出某个值。

以上的5个控制结构中，有一个被称之为循环，而不是表达式，因为它不会返回一个有意义的值。

while 和 do-while 的返回值的类型永远都是 Unit，即单元值，写作 ()。Scala 的赋值语句的结果也是 ()。

2. if 表达式

if 表达式的使用方法，大致与 Java 相同。

有一个区别于 Java 的使用方法，就是由于 if 表达式有返回值，所以在某些场景下可以用来赋值：

  def main(args: Array[String]): Unit = {
    val fileName = if (args.isEmpty) args(0) else "default"
  }

3. while 和 do-while 循环

while 和 do-while 循环的使用方法，也大致与 Java 相同。

但是这里需要注意的是，由于循环的结果永远都是 Unit，所以从函数式编程的角度，不建议使用循环，因为这么做纯粹是为了程序的副作用。

while 循环通常用来更新一个 var 的值，所以两者很多时候都是成对出现。

4. for 表达式

for 表达式主要用于迭代。

4.1 遍历集合

for 表达式最常见的场景就是遍历一个集合（包括 List，Set，Map，Array）

  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)
    for (i <- list) println(i)

    val map = Map(1 -> "1.1", 2 -> "2.2")
    for ((k, v) <- map) println(k + "," + v)
  }

4.2 遍历区间

for 表达式还可以用来遍历区间 Range，这是一种对于 Int 类的富包装。

  def main(args: Array[String]): Unit = {
    for (i <- 1 to 3) print(i) // 输出123
    for (i <- 1 until 3) print(i) // 输出12
  }

其中 until 和 to 的区别在于：until 不包含上界，to 包含上界。

也可以使用区间来遍历集合，但这种用法在 Scala 中不推荐：

  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)
    for (i <- 0 until list.length) println(list(i)) // 不推荐
  }　

4.3 过滤

遍历集合时，可以给 for 表达式增加 filter，具体的做法是在 for 表达式的圆括号中加一个 if 子句：

  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)
    for (i <- list if i > 1) println(i)  // 输出23
  }

支持同时使用多个 filter：

  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)
    for (i <- list if i > 1 if i % 2 == 0) println(i) // 输出2
  }

4.4 嵌套迭代

for 表达式内部可以写多个 <- 子句，表示嵌套迭代。

这里写一个典型的嵌套迭代：冒泡排序

  def main(args: Array[String]): Unit = {
    val array = Array(4, 2, 5, 1, 3)
    bubble(array)
    for (i <- array) print(i)

  }

  def bubble(array: Array[Int]) = {
    for (i <- 0 until array.length - 1; // 注意，嵌套迭代之间的分号是不能省略的
         j <- 0 until array.length - i - 1 if array(j) > array(j + 1)) swap(array, j, j + 1)
  }

  def swap(array: Array[Int], i: Int, j: Int) = {
    val temp = array(i)
    array(i) = array(j)
    array(j) = temp
  }

需要注意的是：

• 如果 for 表达式使用圆括号，嵌套迭代之间的分号是不能省略的。
• 如果 for 表达式使用花括号，嵌套迭代之间的分号可以省略。
• 外循环与内循环之间除了使用过滤器，或者中途变量绑定，不能增加其他操作。

所谓中途变量绑定，就是用 = 在 for 表达式内部进行临时的变量绑定（使用这个技巧可以在循环之间增加额外的操作）

  def bubble(array: Array[Int]) = {
    for {i <- 0 until array.length - 1
         // println() 编译出错
         a = println() // 编译成功
         j <- 0 until array.length - i - 1 if array(j) > array(j + 1)} swap(array, j, j + 1)
  }

4.5 yield

for 表达式在每次迭代中，都可以生成一个可以被记住的值，具体的做法实在 for 表达式的代码体之前使用 yield 关键字。

交出的值，被统一存储在一个集合里面，这个集合的类型取决于迭代子句中处理的集合种类：

  def main(args: Array[String]): Unit = {
    val array = Array(1, 2, 3)
    val a = for (i <- array if i % 2 == 0) yield i // a是Array

    val list = List(1, 2, 3)
    val b = for (i <- array if i % 2 == 0) yield i // b是List
  }

5. try 表达式

try 表达式用来处理异常情况，与 Java 基本相同，是 try-catch-finally 结构。

try 表达式在 catch 模块与 Java 的语法不相同：

  def myDivide(a: Int, b: Int): Int = {
    try {
      if (a < 0 || b < 0) throw new Exception else a / b
    } catch {
      case ex: ArithmeticException => -1
      case ex: Exception => -2 // 这行注释掉编译也不会出现问题
    } finally {
      println("Go to finally")
　　　 -3
    }
  }

try-catch-finally 结构也会交出一个值，但是 finally 中的语句虽然始终被执行，但是却和交出值没有关系。

例如：

  def main(args: Array[String]): Unit = {
    println(myDivide(2, -1)) // 结果是 -2
  }

因此我们可以做一个初步的总结：

• try 表达式用于异常捕获。
• Scala 的受检异常（checked exception），从编译的角度上不强制要求我们 catch，这点和 Java 不一样。
• catch 子句遵循模式匹配用法。
• try 表达式可以交出一个值。
• finally 子句始终会被执行，但是不参与交出值，所以一般用来做资源回收之类的工作。

6. match 表达式

Scala 的 match 表达式，从控制结构的角度上讲，对应的是 Java 的 switch-case 结构。

当然 match 表达式的作用不仅限于此，它属于 Scala 的模式匹配的其中一种用法，此处不展开。

  def main(args: Array[String]): Unit = {
    val str = if (args.length > 0) args(0) else "default"
    val firstArg = str match {
      case "1" => "one"
      case "default" => "zero"
      case _ => "nothing" // 和 Java 中的 default 关键字起相同的作用
    }
    println(firstArg)
  }

Scala 的 match 表达式和 Java 的 switch-case 结构有三处区别：

• Scala 中的任何常量、字符串都可以作为 match 表达式匹配的样例。
• Scala 的 match 表达式每个可选象后面不需要有 break。
• Scala 的 match 表达式有返回值。

7. break & continue

Scala 语言里，没有 break 和 continue 关键字。

所以如果需要类似的语义，在使用 while 或 do-while 循环，或是 for 表达式的时候，需要对程序做一定的修改。

最简单的解决方案是：

• 用 if 换掉每一个 continue。
• 用布尔值取代 break。