三、Scala 程序流程控制

淡淡的烟草味﹌ 2024-04-17 05:32 46阅读 0赞

**目录**

1、if -else

2、switch分支结构（后面在学）

3、for循环控制

4、while循环控制

5、do..while循环控制

6、break和continue

--------------------

## 1、if -else ##

**（1）基本语法**

if (条件表达式1) {
        执行代码块1
      }else if (条件表达式2) {
        执行代码块2
      }
      ……
      else {
        执行代码块n
     }

*  如果大括号\{\}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。
 *  Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容.

val age = 7
        val res = if (age>20){
        println("age is bigger than 20")
            "yes ok"
        }else{
             7
        }
        println( s"res = $res")

*  Scala中是没有三元运算符

// 因为 scala 的if-else 是有返回值的，因此，本身这个语言也不需要三元运算符了(如图)，并且可以写在同一行，类似 三元运算
    val result = if (flg) 1 else 0

## 2、switch分支结构（后面在学） ##

*  在scala中没有switch,而是使用模式匹配来处理。
 *  模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。
 *  match-case

## 3、for循环控制 ##

基本介绍  
Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）

object ForTest {
      def main(args: Array[String]): Unit = {
        /**
          * 1、范围数据循环方式1
          * i 表示循环的变量， <- 规定好 to 规定
          * i 将会从 1-3 循环， 前后闭合
          * */
        for(i <- 1 to 3){
          print(i + " to")
        }
        println()
        /**
          *2、范围数据循环方式2
          *这种方式和前面的区别在于 i 是从1 到 3-1
          * 前闭合后开的范围,和java的arr.length() 类似
          */
        for(i <- 1 until 3) {
          print(i + " until")
        }
        println()
        /**
          * 3、循环守卫
          * 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue
          */
        for(i <- 1 to 3 if i != 2) {
          print(i + " 循环守卫a ")
        }
        println()
        //    上面的代码等价
        for (i <- 1 to 3) {
          if (i != 2) {
            print(i+" 循环守卫b ")
          }
        }
        println()
        /**
          * 、引入变量
          *没有关键字，所以范围后一定要加；来隔断逻辑
          */
        for(i <- 1 to 3; j = 4 - i) {
          print(j + " 引入变量a ")
        }
        println()
        //    上面的代码等价
        for ( i <- 1 to 3) {
          val j = 4 - i
          print(j + " 引入变量b ")
        }
        println()
        /**
          * 5、嵌套循环
          *没有关键字，所以范围后一定要加；来隔断逻辑
          */
    
        for(i <- 1 to 3; j <- 1 to 3) {
          println("嵌套循环a i =" + i + " j = " + j)
        }
        //    上面的代码等价
        for ( i <- 1 to 3) {
          for ( j <- 1 to 3){
            println("嵌套循环b i ="+ i + " j = " + j + " ")
          }
        }
        /**
          * 6、循环返回值
          * 将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字
          */
        val res = for(i <- 1 to 10) yield i
        println(res)
        /**
          *7、使用花括号{}代替小括号()
          * {}和()对于for表达式来说都可以
          * for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号
          * 当使用{} 来换行写表达式时，分号就不用写了
          */
        for(i <- 1 to 3; j =  i * 2) {
          println("使用花括号{}代替小括号()_a i= " + i + " j= " + j)
        }
    //    可以写成
        for{
          i <- 1 to 3
          j = i * 2} {
          println("使用花括号{}代替小括号()_b i= " + i + " j= " + j)
        }
      }
    }

## 4、while循环控制 ##

**（1）基本语法**

循环变量初始化
    while (循环条件) {
         循环体(语句)
         循环变量迭代
    }

**（2）注意事项和细节说明**

*  循环条件是返回一个布尔值的表达式
 *  hile循环是先判断再执行语句
 *  与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()
 *  因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。

## 5、do..while循环控制 ##

**（1）基本语法**

循环变量初始化;
       do{
           循环体(语句)
           循环变量迭代
       } while(循环条件)

**（2）注意事项和细节说明**

*  循环条件是返回一个布尔值的表达式
 *  do..while循环是先执行，再判断
 *  和while 一样，因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在do...while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环

## 6、break和continue ##

Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数化编程，推荐使用函数式的风格解决break和contine的功能，而不是一个关键字。

**（1）Break**

object BreakTest {
      def main(args: Array[String]): Unit = {
        import util.control.Breaks._
        //    while
        var n = 10
        breakable{
          while (n <= 20){
            n += 1
            println(s"n = $n")
            if ( n == 18 ){
              break()
            }
          }
        }
        // for
        breakable{
          for (i <- 10.to(20)){
            println(s"i  = $i ")
            if ( i == 18 ){
              break()
            }
          }
        }
      }
    }

**（2）Continue**

如何实现continue的效果

**a、Scala内置控制结构特地也去掉了continue，是为了更好的适应函数化编程，可以使用if – else 或是 循环守卫实现continue的效果**

object ContinueTest {
      def main(args: Array[String]): Unit = {
        for (i <- 1 to 10 if i != 2 && i != 3) {
          println("i=" + i)
        }
      }
    }

**b、利用 breakable 实现continue**

object ContinueTest extends App{
        val list2 = List(1,2,3,4,5)
        for(j <- list2){
            breakable{
              if(j==44) break else println(j)
            }
          }
    }

**注意：break的实现和 continue的实现区别在于 breakable\{\}函数的范围**