深入浅出scala之表达式（P27-35）

文章目录

• ​​1.表达式​​
• ​​2.条件表达式​​
• ​​3.块表达式​​
• ​​4.for 循环​​
• ​​5. while循环​​
• ​​6.if和布尔变量跳出循环​​
• ​​7.breakable实现跳出循环​​

1.表达式

表达式和语句的区别：

• 不使用return语句，最后一个表达式即返回值。

// 返回的就是string类型
scala> val res = if(true) "true result" else "false result"
res: String = true result

scala> val res = if(true) println("true result") else "false result"
true result
res: Any = ()

scala> var a = 1
a: Int = 1
// 返回的是Any
scala> val res = if(true) a+=10 else "false result"
res: Any = ()
// Scala表达式中不使用return语句
scala> val res = if(true) return "true result" else return "false result"
<console>:11: error: return outside method definition
       val res = if(true) return "true result" else return "false result"
                          ^
<console>:11: error: return outside method definition
       val res = if(true) return "true result" else return "false result"
                                                    ^

2.条件表达式

单分支

• 基本语法：if(条件表达式){执行代码块}，说明当条件表达式为true，就会执行{}的代码

scala> val x = 10
x: Int = 10
// 这里会有同学问，为什么返回的是AnyVal类型，不是Int类型
scala> val res = if(x>0) 1
res: AnyVal = 1
// 解释：上一行表达式等价于下一行的写法，else返回的是unit类型，则返回其父类，所以结果返回的就是AnyVal
scala> val res = if(x>0) 1 else ()
res: AnyVal = 1

双分支

• 基本语法：if(条件表达式){执行代码块1}else{执行代码块1}
• 说明当条件表达式成立，即执行代码块1，否则执行代码块2

scala> val res1 = if( x>0 ) 1 else -1
res1: Int = 1

多分支

• 基本语法：if(条件表达式1){执行代码块1}
  else if(条件表达式2){执行代码块2}
  else {执行代码块n}

scala> val res2 = if(x>0) 10 else if(x<0) -1 else 0
res2: Int = 10
// 混合类型，就会返回Any类型
scala> val res2 = if(x>0) 10 else if(x<0) -1 else "failure"
res2: Any = 10

3.块表达式

块表达式：{一条或者多条语句}，块表达式也是有返回值
返回值是块表达式中的最后一条语句的结果，最后一条语句是打印语句或赋值语句，返回值就是一个（）

//直接使用命令的方式不支持package
//package expr
object BlockExprDemo {
  def main(args: Array[String]): Unit = {
    var x = 0
    val res = {
      if (x < 0) -1
      else if (x >= 1) 1
      else "error"
    }
    println(res)

    val x1 = 1
    val x2 = 2
    val y1 = 1
    val y2 = 2

    val distance = {
      val dx = x2 - x1
      val dy = y2 - y1
      Math.sqrt(dx * dx + dy * dy)
    }
    println(distance)

  }
}

wangji@DESKTOP-9TAUMH9:~/code/test/scala/expr$ scalac -d ../class BlockExprDemo.scala 
wangji@DESKTOP-9TAUMH9:~/code/test/scala/expr$ scala -classpath ../class BlockExprDemo
error
1.4142135623730951

4.for 循环

Scala中有for循环和while循环，用for循环比较多
for循环语法结构：for (i <- 表达式/数组/集合)
to和until

i to j （包含i和j）
i until j （包含i，但不包含j）

object ForDemo {
  def main(args: Array[String]): Unit = {
    // 每次从集合中取一个值，赋值给循环变量
    for (i <- 1 to 10) {
      println(i)
    }
    // 循环遍历一个数组
    val arr = Array("a", "b", "c", "d")
    for (item <- arr) {
      println(item)
    }
  }
}

wangji@DESKTOP-9TAUMH9:~/code/test/scala$ scalac -d class ForDemo.scala -encoding GB18030
wangji@DESKTOP-9TAUMH9:~/code/test/scala$ scala -classpath class ForDemo
1
2
3
4
5
6
7
8
9
10
a
b
c
d

高级for循环

object HighForDemo {
  // 循环的嵌套以及带守卫的循环
  def main(args: Array[String]): Unit = {
    // 循环嵌套
    for (i <- 1 to 3; j <- 1 to 3) {
      println(10 * i + j)
    }
    // 等价于
    println("----------等价于----------")
    for (i <- 1 to 3) {
      for (j <- 1 to 3) {
        println(10 * i + j)
      }
    }
    // 带守卫的循环
    println("----------带守卫的循环----------")
    for (i <- 1 to 3; j <- 1 to 3 if i != 3) {
      println(10 * i + j)
    }
  }
}

• 测试

wangji@DESKTOP-9TAUMH9:~/code/test/scala/expr$ scalac -d ../class HighForDemo.scala 
wangji@DESKTOP-9TAUMH9:~/code/test/scala/expr$ scala -classpath ../class HighForDemo
11
12
13
21
22
23
31
32
33
----------等价于----------
11
12
13
21
22
23
31
32
33
----------带守卫的循环----------
11
12
13
21
22
23
wangji@DESKTOP-9TAUMH9:~/code/test/scala/expr$

for推导

• yield
  通过yield开始的循环，叫for推导，会构建一个新的集合，新集合中的元素是遍历for循环中的集合，每次根据yield后面的表达式生成一个新的元素

package expr

object Main extends App {
  println("Hello, World!")
}
object ForDemo3 {
  // for推导，yield
  def main(args: Array[String]): Unit = {
    // 通过yield开始的循环，叫for推导，会构建一个新的集合，新集合中的元素是遍历for循环
    // 中的集合，每次根据yield后面的表达式生成一个新的元素
    val result = for (i <- 0 until 10) yield i * 10
    println(result)
  }
}

• 测试：

Multiple main classes detected. Select one to run:
 [1] expr.ForDemo3
 [2] expr.Main

Enter number: 1
[info] running expr.ForDemo3 
Vector(0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
[success] Total time: 7 s, completed Nov 29, 2022, 10:51:17 PM

5. while循环

object WhileDoWhileDemo {
  def main(args: Array[String]): Unit = {
    // 使用while完成求和（1，2，3，。。10）
    var i = 1
    var sum = 0
    while (i <= 10) {
      sum += i
      i += 1
    }
    println(sum)
    // 使用do while完成求和（1，2，3，。。10）
    do {
      sum += i
      i += 1
    } while (i <= 10)
    println(sum)
  }
}

• 测试：

[info] running expr.WhileDoWhileDemo 
55
66
[success] Total time: 7 s, completed Nov 29, 2022, 11:02:16 PM

6.if和布尔变量跳出循环

object ContinueDemo {
  def main(args: Array[String]): Unit = {
    // 数组("aa.scala","-bb.java","cc.scala","dd.java","-ee.scala")
    // 查找以".scala"结尾但是不以"-"开始的的字符串
    val arr = Array("aa.scala", "-bb.java", "cc.scala", "dd.java", "-ee.scala")
    // 实现break功能
    var found = false
    var i = 0
    while (i < arr.length && !found) {
      if (!arr(i).startsWith("-")) {
        if (arr(i).endsWith(".scala")) {
          found = true
          println(arr(i))
        }
      }
      i += 1
    }
  }
}

• 测试：

Enter number: 1
[info] running expr.ContinueDemo 
aa.scala

7.breakable实现跳出循环

可以使用breakable关键字。在使用breakable之前要import scala.util.control.Breaks._

package BreakDemo

import scala.util.control.Breaks._
object BreakDemoTest {
  def main(args: Array[String]): Unit = {
    // 实现break的功能，如果i=5，终止循环
    breakable(for (i <- 0 until 10) {
      if (i == 5) {
        break()
      }
      println(i)
    })

    println("----------------------")
    // 实现continue的功能，如果i=5，终止本次循环
    for (i <- 0 until 10) breakable({
      if (i == 5) {
        break()
      }
      println(i)
    })
  }
}

• 测试：

Enter number: 1
[info] running BreakDemo.BreakDemoTest 
0
1
2
3
4
----------------------
0
1
2
3
4
6
7
8
9
[success] Total time: 3 s, completed Nov 29, 2022, 11:18:17 PM

• 参考：​​Scala深入学习之表达式与循环学习​​，​​深入浅出Scala编程语言入门到精通​​