在程序中，程序运行的流程控制决定程序是如何执行的，主要有三大流程控制语句

  1. 顺序控制
  2. 分支控制
  3. 循环控制

    3.4.1 顺序控制

    程序从上到下逐行执行，中间没有任何判断和跳转
    Scala 中定义变量时采用合法的前向引用
    1. var n1 = n2 + 3    // error: not found: value n2
    2. var n2 = 2

    3.4.2 分支控制

    程序可以有选择地执行，分支控制有三种，分别是单分支、双分支和多分支
    👉 流程图

    👉 代码实例 ```scala // 单分支：if val age = 22 if (age > 18) { println(“you are not a boy!”) }

// 双分支：if-else val score = 66 if (score > 60) { println(“及格”) } else { println(“不及格”) }

// 多分支：if-else if-else if (score > 90) { println(“Great”) } else if (score > 60) { println(“Ok”) } else { println(“Not Good!”) }

  1. **👉 注意事项**
  3. - 如果大括号内的代码只有一行，大括号可以省略
  4. - Scala 中任意表达式都有返回值，所以 if-else 也有返回值，返回内容取决于满足条件的代码体的最后一行内容，默认返回的是 Unit（即** () **）
  5. <a name="yB1NT"></a>
  6. # 3.4.3 循环控制
  7. 循环控制可以使用三种方式：
  9. 1. for推导式/for表达式
  10. 1. while
  11. 1. do-while
  12. <a name="qdvmy"></a>
  13. ## 🔄 for
  14. ⬛**（1）基本用法**<br />可以对**一个范围的内容或集合**进行遍历，**to** 前后闭合，**until** 前闭后开
  15. ```scala
  16. // 遍历范围，结果：1 2 3 
  17. for (i <- 1 to 3) {
  18.   print(i + " ")
  19. }
  20. // 遍历范围，结果：1 2 
  21. for (i <- 1 until 3) {
  22.   print(i + " ")
  23. }
  24. // 遍历集合，结果：hi-23-
  25. val list = List("hi", 23)
  26. for (item <- list) {
  27.   print(item + "-")
  28. }

⬛（2）循环守卫
所谓的循环守卫，即循环保护式，也称条件判断式或守卫；保护式为 true 才进入循环体内容

  1. // 结果：1 3 5 
  2. for (i <- 1 to 5 if i % 2 == 1) {
  3.   print(i + " ")
  4. }

⬛（3）引入变量&嵌套循环
引入变量：可以在循环体上或循环条件上定义变量
嵌套循环：循环中可以再嵌套循环，可以使用简写方式

  1. // 在循环条件上定义变量，结果：5 4 3  
  2. for (i <- 1 to 3; j = 6 - i) {
  3.   print(j + " ")
  4. }
  6. // 嵌套循环简写方式
  7. /* 结果：
  8. i=1, j=1
  9. i=2, j=1
  10. */
  11. for (i <- 1 to 2; j <- 1 until 2) {
  12.   println(s"i=${i}, j=${j}")
  13. }

⬛（4）循环返回值
使用 yield 关键字，将遍历过程中处理数据的结果返回到一个新的 Vector 集合中

  1. // 结果：Vector(3, 4, 6, 8)
  2. val res = for (i <- 1 to 2; j <- 3 to 4) yield {
  3.   val num = i * j
  4.   if (i % 2 == 0) i * j else j
  5. }
  6. println(res)

⬛（5）替换圆括号

  • 对于 for 表达式来说，()/{} 是一样的
  • 不成文约定：当仅有一个表达式时，使用圆括号，否则使用大括号
  • 当使用大括号且换行写表达式时，分号可以不用写

⬛（5）控制步长

  • 方式一：使用循环守卫

  • 方式二：使用 **Range(start, end, step)**，范围是前闭后开

    🔄 while/do-while

  • while 循环先判断再执行

  • do-while 循环会先执行后判断
  • while 语句本身没有值，即整个 while 语句的结果是 Unit 类型的
  • Scala 不推荐使用 while/do-while 循环，推荐使用 for 循环

    📤 循环中断

    Scala 内置控制结构去掉了 continue 和 break 关键字，是为了更好地适应函数式编程，推荐使用函数式风格解决循环中断
    （1）break：见下面代码
    （2）continue：通过循环守卫解决跳过下面需要执行的代码 ```scala import scala.util.control.Breaks

object ForBreak { def main(args: Array[String]): Unit = { var sum = 0 Breaks.breakable { for (i <- 1 to 10 if i % 2 == 0) { if (i % 3 == 0) { // def break(): Nothing = { throw breakException } Breaks.break() } sum += i } } println(“sum=” + sum) } } // 结果：sum=6 ```