Scala 3 — Book

控制结构

Info: JavaScript is currently disabled, code tabs will still work, but preferences will not be remembered.

Scala 具有您在其他编程语言中可以找到的控制结构，并且还具有强大的 for 表达式和 match 表达式：

if/else
for 循环和表达式
match 表达式
while 循环
try/catch

这些结构在以下示例中进行了说明。

`if`/`else`

Scala 的 if/else 控制结构看起来与其他语言相似：

if (x < 0) {
  println("negative")
} else if (x == 0) {
  println("zero")
} else {
  println("positive")
}

if x < 0 then
  println("negative")
else if x == 0 then
  println("zero")
else
  println("positive")

请注意，这确实是一个 表达式 —不是一个语句。这意味着它返回一个值，因此您可以将结果赋值给一个变量：

val x = if (a < b) { a } else { b }

val x = if a < b then a else b

正如您将在本书中看到的那样，所有 Scala 控制结构都可以用作表达式。

表达式返回结果，而语句不返回。语句通常用于它们的副作用，例如使用 println 打印到控制台。

`for` 循环和表达式

for 关键字用于创建 for 循环。这个例子展示了如何打印 List 中的每个元素：

val ints = List(1, 2, 3, 4, 5)

for (i <- ints) println(i)

代码 i <- ints 被称为_生成器_，在括号内的生成器后面是_循环体_。

val ints = List(1, 2, 3, 4, 5)

for i <- ints do println(i)

代码 i <- ints 被称为 生成器，紧随 do 关键字的代码是 循环体。

守卫

您还可以在 for 循环中使用一个或多个 if 表达式。这些被称为守卫。此示例打印 ints 中大于 2 的所有数字：

for (i <- ints if i > 2)
  println(i)

for
  i <- ints
  if i > 2
do
  println(i)

您可以使用多个生成器和守卫。此循环遍历数字 1 到 3，并且对于每个数字，它还遍历字符 a 到 c。然而，它也有两个守卫，所以唯一一次调用 print 语句是当 i 的值为 2 并且 j 是字符 b 时：

for {
  i <- 1 to 3
  j <- 'a' to 'c'
  if i == 2
  if j == 'b'
} {
  println(s"i = $i, j = $j")   // prints: "i = 2, j = b"
}

for
  i <- 1 to 3
  j <- 'a' to 'c'
  if i == 2
  if j == 'b'
do
  println(s"i = $i, j = $j")   // prints: "i = 2, j = b"

`for` 表达式

for 关键字更强大：当您使用 yield 关键字代替 do 时，您会创建 for _表达式_用于计算和产生结果。

几个例子演示了这一点。使用与上一个示例相同的 ints 列表，此代码创建一个新列表，其中新列表中每个元素的值是原始列表中元素值的两倍：

scala> val doubles = for (i <- ints) yield i * 2
val doubles: List[Int] = List(2, 4, 6, 8, 10)

scala> val doubles = for i <- ints yield i * 2
val doubles: List[Int] = List(2, 4, 6, 8, 10)

Scala 的控制结构语法很灵活，for 表达式可以用其他几种方式编写，具体取决于您的偏好：

val doubles = for (i <- ints) yield i * 2
val doubles = for (i <- ints) yield (i * 2)
val doubles = for { i <- ints } yield (i * 2)

val doubles = for i <- ints yield i * 2     // 如上所示的风格
val doubles = for (i <- ints) yield i * 2
val doubles = for (i <- ints) yield (i * 2)
val doubles = for { i <- ints } yield (i * 2)

此示例显示如何将列表中每个字符串的第一个字符大写：

val names = List("chris", "ed", "maurice")
val capNames = for (name <- names) yield name.capitalize

val names = List("chris", "ed", "maurice")
val capNames = for name <- names yield name.capitalize

最后，这个 for 表达式遍历一个字符串列表，并返回每个字符串的长度，但前提是该长度大于 4：

val fruits = List("apple", "banana", "lime", "orange")

val fruitLengths =
  for (f <- fruits if f.length > 4) yield f.length

// fruitLengths: List[Int] = List(5, 6, 6)

val fruits = List("apple", "banana", "lime", "orange")

val fruitLengths = for
  f <- fruits
  if f.length > 4
yield
  // 在这里你可以
  // 使用多行代码
  f.length

//fruitLengths: List[Int] = List(5, 6, 6)

for 循环和表达式更多细节在本书的控制结构部分中，和参考文档中。

`match` 表达式

Scala 有一个 match 表达式，它最基本的用途类似于 Java switch 语句：

val i = 1

// later in the code ...
i match {
  case 1 => println("one")
  case 2 => println("two")
  case _ => println("other")
}

val i = 1

// later in the code ...
i match
  case 1 => println("one")
  case 2 => println("two")
  case _ => println("other")

但是，match 确实是一个表达式，这意味着它会根据模式匹配返回一个结果，您可以将其绑定到一个变量：

val result = i match {
  case 1 => "one"
  case 2 => "two"
  case _ => "other"
}

val result = i match
  case 1 => "one"
  case 2 => "two"
  case _ => "other"

match 不仅限于使用整数值，它可以用于任何数据类型：

val p = Person("Fred")

// later in the code
p match {
  case Person(name) if name == "Fred" =>
    println(s"$name says, Yubba dubba doo")

  case Person(name) if name == "Bam Bam" =>
    println(s"$name says, Bam bam!")

  case _ => println("Watch the Flintstones!")
}

val p = Person("Fred")

// later in the code
p match
  case Person(name) if name == "Fred" =>
    println(s"$name says, Yubba dubba doo")

  case Person(name) if name == "Bam Bam" =>
    println(s"$name says, Bam bam!")

  case _ => println("Watch the Flintstones!")

事实上，match 表达式可以用许多模式的不同类型来测试变量。此示例显示 (a) 如何使用 match 表达式作为方法的主体，以及 (b) 如何匹配显示的所有不同类型：

// getClassAsString is a method that takes a single argument of any type.
def getClassAsString(x: Any): String = x match {
  case s: String => s"'$s' is a String"
  case i: Int => "Int"
  case d: Double => "Double"
  case l: List[_] => "List"
  case _ => "Unknown"
}

// examples
getClassAsString(1)               // Int
getClassAsString("hello")         // 'hello' is a String
getClassAsString(List(1, 2, 3))   // List

因为 getClassAsString 方法获取 Any 类型的参数值，所以它可以解耦任意模式类型。

// getClassAsString 是一个接受任何类型的单个参数的方法。
def getClassAsString(x: Matchable): String = x match
  case s: String => s"'$s' is a String"
  case i: Int => "Int"
  case d: Double => "Double"
  case l: List[_] => "List"
  case _ => "Unknown"

// examples
getClassAsString(1)               // Int
getClassAsString("hello")         // 'hello' is a String
getClassAsString(List(1, 2, 3))   // List

getClassAsString 方法将 Matchable 类型的值作为参数，它可以是任何支持模式匹配的类型（某些类型不支持模式匹配，因为这可能打破封装）。

Scala 中的模式匹配还有更多内容。模式可以嵌套，模式的结果可以绑定，模式匹配甚至可以是用户自定义的。有关详细信息，请参阅控制结构章节中的模式匹配示例。

`try`/`catch`/`finally`

Scala 的 try/catch/finally 控制结构让你捕获异常。它类似于 Java，但其语法与 match 表达式一致：

try {
  writeTextToFile(text)
} catch {
  case ioe: IOException => println("Got an IOException.")
  case nfe: NumberFormatException => println("Got a NumberFormatException.")
} finally {
  println("Clean up your resources here.")
}

try
  writeTextToFile(text)
catch
  case ioe: IOException => println("Got an IOException.")
  case nfe: NumberFormatException => println("Got a NumberFormatException.")
finally
  println("Clean up your resources here.")

`while` 循环

Scala 还有一个 while 循环结构。它的单行语法如下所示：

while (x >= 0) { x = f(x) }

while x >= 0 do x = f(x)

为了兼容性，Scala 3 仍然支持 Scala 2 语法。

while 循环多行语法如下所示：

var x = 1

while (x < 3) {
  println(x)
  x += 1
}

var x = 1

while
  x < 3
do
  println(x)
  x += 1

自定义控制结构

由于传名参数、中缀表示法、流畅接口、可选括号、扩展方法和高阶函数等功能，您还可以创建自己的代码，就像控制结构一样工作。您将在控制结构部分了解更多信息。

← previous next →

Contributors to this page:

Problem with this page?
Please help us fix it!

控制结构

if/else

for 循环和表达式

守卫

for 表达式

match 表达式

try/catch/finally

while 循环