Kotlin 控制流语句

缺乏、安全感 2022-05-08 09:33 240阅读 0赞

在kotlin中我们可以使用if、when、for、while这几种控制流语句。与java不同的是，kotlin取消了传统的switch语句而改用when语句来实现。

**if表达式**

语法格式：

if (used by atomicExpression)
      : "if" "(" expression ")" controlStructureBody SEMI? ("else" controlStructureBody)?
      ;

首先我们看下传统用法：

var number = 20;
        if (number > 15) {
            print("The number is more than 15")
        }

我们同样可以使用if…else if …else这样在其他语言中存在的习惯用法：

var number = 15;
        if (number > 20) {
            print("The number is more than 20")
        } else if (number == 20) {
            print("The number is equals")
        } else {
            print("The number is less than 20")
        }

如果你的条件分支超过3条，那么kotlin会建议你采用when这种更加简洁的方式：  
![在这里插入图片描述][70]

接下来我们看一下在kotlin中if作为表达式的使用：

var stuNumber = 55;
        var stu = if (stuNumber > 50) 50 else stuNumber
        print(stu)

输出：

在这里，if作为一个表达式（例如：返回它的值或者把它赋给变量），也就是意味着它可以返回一个值，在这种情况下，else分支是必须的。如果上面的例子没有else分支，那么你会得到如下的错误提示：  
![在这里插入图片描述][70 1]

同样的，作为表达式使用的时候，if的分支可以是代码块，最后的表达式作为该块的值：

var stuNumber = 15;
        var maxStu = if (stuNumber > 50) {
            print("The students max number is 50")
            50
        }else{
            print("The students  number is $stuNumber")
            stuNumber
        }
        print("\n")
        print(maxStu)

输出：

The students  number is 15
    15

如果我们试着在if和else分支块的末尾加一句代码：

var maxStu = if (stuNumber > 50) {
            ...
            true
        }else{
            ...
            false
        }

结果输出：

false

所以有一点大家的记清楚了，if作为表达式：最后的表达式作为该块的值。

**When 表达式**

when表达式的语法在kotlin的文档中我们也可以找到：

when (used by atomicExpression)
      : "when" ("(" expression ")")? "{"
            whenEntry*
        "}"
      ;
    whenEntry (used by when)
      : whenCondition{","} "->" controlStructureBody SEMI
      : "else" "->" controlStructureBody SEMI
      ;
    whenCondition (used by whenEntry)
      : expression
      : ("in" | "!in") expression
      : ("is" | "!is") type
      ;

最简单的使用就和我们以前知道的switch是一样的：

var index = 1
        when (index) {
            1 -> {
                print("index is 1")
            }
            2 -> {
                print("index is 2")
            }
            else -> {
                print("index is 1")
            }
        }

其中如果是简单的代码块我们也可以使用kotlin官方示例的写法，不用花括号进行代码块的标识，当然了额，个人意见，使用｛｝将分支的代码包裹起来，可以让我们更容易区分代码结构。

when (x) {
        1 -> print("x == 1")
        2 -> print("x == 2")
        else -> { // 注意这个块
            print("x is neither 1 nor 2")
        }
    }

when 将它的参数与所有的分支条件顺序比较，直到某个分支满足条件。如果 when 作为一个表达式使用，则必须有 else 分支， 除非编译器能够检测出所有的可能情况都已经覆盖了［例如，对于 枚举（enum）类条目与密封（sealed）类子类型］。

也就是说任何情况下我们提供一个else分支是没有任何坏处的，这就相当于switch的default分支。

记得swicth如果有多分支需要用相同的方式处理，一般的写法应该是：

case 1:
    case 2:
    break;

这样的形式，在kotlin中是将多个分支条件放在一起，用逗号分隔：

1, 2, 3, 4 -> {
                print("index is $index")
            }

我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：

var index = 4
        when (index) {
            in 1..3 -> {
                print("index is less than 3")
            }
            !in 1..3 -> {
                print("index is more than 3")
            }
        }

还有一种就是检测一个值是（is）或者不是（!is）一个特定类型的值：

var a: Any = "100"
        when (a) {
            is Char -> print("char")
            !is Number -> print("not number")
            else -> print("unknow")
        }

这里提示大家一个小技巧，如果我们使用when表达式的时候，不能确定传入的参数a的类型，此时我们在声明变量的时候就将其声明为Any类型：

var a: Any = "100"

如果我们不指定类型：  
![在这里插入图片描述][70 2]

程序无法通过编译，提示我们冲突的类型。

另外就是和if一样作为表达式的用法了：

var results = when (a) {
            is Char -> "char"
            !is Number -> "not number"
            else -> "unknow"
        }

如果它被当做表达式， 符合条件的分支的值就是整个表达式的值，这一点大家在使用的时候的自己注意。

**循环语句**  
常见的for、while、do…while语法和我们以前接触的大同小异：

for (used by loop)
      : "for" "(" annotations (multipleVariableDeclarations | variableDeclarationEntry) "in" expression ")" controlStructureBody
      ;
    while (used by loop)
      : "while" "(" expression ")" controlStructureBody
      ;
    doWhile (used by loop)
      : "do" controlStructureBody "while" "(" expression ")"
      ;

**for 循环**  
for 可以循环遍历任何提供了迭代器的对象,这相当于像 C\# 这样的语言中的 foreach 循环.

var array: Array<Int> = Array(5) { i -> i + 1 }
        for (value in array){
            print(value)
        }

对于某些特殊场景比如我们需要索引的时候，我们可以通过下面两种方式获得索引值：

for (value in array.indices){
            print(value)
        }

如果我们打印一下array.indices的值大家就会发现 ，它返回的其实是数组的索引范围：

0..4

通过这种变相的方式为我们提供了元素的索引值。另外一种方式是：

for ((index, value) in array.withIndex()) {
            println("the element at $index is $value")
        }

![在这里插入图片描述][70 3]

for的另一种使用场景就是区间迭代：

for (i in 1..3) {
        println(i)
    }

这和我们使用array.indices的原理是一致的。

while语句的使用我们就简单的使用官方文档内容：

while (x > 0) {
        x--
    }
    
    do {
      val y = retrieveData()
    } while (y != null) // y 在此处可见

[70]: /images/20220508/20e79e97d1d14dbcaa39920004754de0.png
[70 1]: /images/20220508/0fddadc6d899422cacc7ec0ec24b7a93.png
[70 2]: /images/20220508/13ea2284c91c4568b8be9e7c281b97e2.png
[70 3]: /images/20220508/8c291a1b711740e2abb75c7bc74f084d.png