Scala

Scala-流程控制-用法详解

• Scala
• 一、分支控制
• • 1.1 单分支
  • 1.2 双分支
  • 1.3 多分支
  • 1.4 if else 返回值
  • 1.5 三元运算符
  • 1.6 大括号的省略
  • 1.7 嵌套分支
  • 1.8 `switch` 分支结构
• 二、循环控制
• • 2.1 For
  • • 2.1.1 范围数据循环 (`To`)
    • 2.1.2 范围数据循环 (`Until`)
    • 2.1.3 循环守卫
    • 2.1.4 循环步长
    • 2.1.5 嵌套循环
    • 2.1.6 引入变量
    • 2.1.7 循环返回值
    • 2.1.8 倒序打印
  • 2.2 While
  • 2.3 do..while
  • 2.4 循环中断
• 各位看客老爷万福金安，一键三连呀🤣🤣🤣 谢谢啦~

一、分支控制

在 Scala 中，if-else 不仅是控制流程的一种工具，而且它是表达式，它有返回值（后面会讲到哈😁）。

1.1 单分支

单分支结构是最简单的 if 语句，只有一个条件和一个执行的代码块。

if 语句本身是可以有返回值的，但如果没有 else 分支，返回值为 Unit（即 Java 中的 void）。

1.2 双分支

双分支结构包括一个 if 和一个 else 部分，适用于条件为 true 或 false 的两种情况。

1.3 多分支

1.4 if else 返回值

• 在 Scala 中，if-else 语句可以作为一个表达式返回值。

• if-else 的不同分支返回不同类型的值时，Scala 会尝试推断它们的共同祖先类型。
• Scala 会根据分支的返回类型推断出一个最通用的类型。

• Scala 将它们的公共父类类型 Any 作为 result 的类型。

1.5 三元运算符

Java 中有一个三元运算符 ? :，根据条件表达式返回两种可能的值。

int result = (a > 0) ? 1 : -1;

在 Scala 中，三元运算符可以用 if-else 来实现：

val result = if (a > 0) 1 else -1

1.6 大括号的省略

如果 if-else 语句中的代码块只有一行，Scala 允许省略大括号 {}。

1.7 嵌套分支

val a = 10
val b = -5

if (a > 0) {
  if (b > 0) {
    println("Both are positive")
  } else {
    println("a is positive but b is not")
  }
} else {
  println("a is not positive")
}

1.8 switch 分支结构

Scala 中没有传统的 switch 语句，而是通过 模式匹配 来代替 switch。

match 的工作原理：

• match 会依次尝试匹配每一个 case。
• 如果某个 case 匹配成功，执行相应的代码块。
• 如果没有任何 case 匹配成功，可以使用 _（通配符）作为默认值来处理。

二、循环控制

2.1 For

在 Scala 中，for 循环提供了很多特性，可以用来处理各种不同的循环需求。

2.1.1 范围数据循环 (To)

• To 是 Scala 中范围循环的一个特性，指定一个从起始值到结束值的范围，循环会包括结束值。

• 【a,b】—— 会包含b

1
2
3
4
5

2.1.2 范围数据循环 (Until)

• Until 和 To 类似，唯一的区别是 Until 创建的范围不包括结束值。即，for 循环的终止条件是 < 而不是 <=。
• 【a,b】—— 不会包含b

1
2
3
4

2.1.3 循环守卫

• 循环守卫（Guard）是通过在 for 循环中添加条件表达式来过滤某些值。
• 为每个迭代添加一个守卫，只有当守卫条件满足时，才执行循环体中的代码。

满足 i 是偶数的条件时，才会打印 i。

2
4
6
8
10

2.1.4 循环步长

• 默认情况下，for 循环是按步长为 1 来遍历范围的。
• 可以使用 by 关键字来设定步长。

1
3
5
7
9

2.1.5 嵌套循环

• for 循环也可以是嵌套的，即在一个循环中使用另一个 for 循环。嵌套循环通常用于处理二维数组或其他需要多层迭代的数据结构。

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3

2.1.6 引入变量

• 可以在 for 循环中引入新的变量，用于在每次循环时计算或处理一些值。

i = 1, j = 2
i = 2, j = 4
i = 3, j = 6

2.1.7 循环返回值

Scala 的 for 循环不仅可以执行副作用操作，还可以作为一个表达式来返回结果。返回值是一个由 yield 关键字生成的集合。

for 循环通过 yield 生成一个新的集合。yield 会将每次迭代的结果收集到一个集合中，最终返回一个 Vector 类型的结果。

2.1.8 倒序打印

1. 使用 reverse：适用于已经有一个集合或序列时，倒序遍历。

5
4
3
2
1

也可：

2. 使用 to 和 by 控制倒序：直接在 for 循环的范围中指定倒序的起始和步长。

2.2 While

while (条件表达式) {
  // 循环体代码
  // 迭代变量的更新
}

• 没有返回值：while 循环本身不返回任何值，整个 while 语句的结果是 Unit 类型，类似于 void。

0
1
2
3
4

Tips：

• 因为循环变量通常在外部声明并在循环体内进行修改，while 循环可能会影响外部变量。
• 为了避免这种情况，for 循环通常被认为是更推荐的选择，因为它的循环变量只在 for 循环的范围内有效。
• 大数据场景可能会出现并行处理的情况（还是for循环安全好用）。

2.3 do…while

do {
  // 循环体代码
  // 迭代变量的更新
} while (条件表达式)

• 至少执行一次：因为条件判断发生在循环体执行之后，即使条件一开始就为 false，do..while 循环仍然会执行一次循环体。
• 没有返回值：与 while 循环类似，do..while 语句本身也没有返回值，整个语句的结果是 Unit 类型。

2.4 循环中断

• 在 Scala 中，没有 Java 或其他语言那样直接提供 break 和 continue 语句。

1. 使用异常机制退出循环

• 抛出一个异常（如 RuntimeException）来跳出循环，模拟 break 的功能。
• 这种方式比较“激烈”，通常不推荐用于常规代码中，除非有特别的需求。

2.使用 scala.util.control.Breaks 退出循环

• Scala 提供了 Breaks 类，可以在特定条件下退出循环。
• 通过 Breaks.breakable 和 Breaks.break() 可以模拟 break 的效果。（不建议频繁使用）

3. 对 break 进行简化

• 通过在 import 中直接导入 scala.util.control.Breaks._，进一步简化语法。

4. 模拟 continue（跳过当前循环迭代）

• Scala 中没有直接的 continue 关键字，通过控制流和条件语句来模拟 continue 的行为。

各位看客老爷万福金安，一键三连呀🤣🤣🤣 谢谢啦~