Kotlin学习系列——控制流程

灰太狼 2023-06-25 10:23 6阅读 0赞

官方文档: [http://kotlinlang.org/docs/reference/control-flow.html][http_kotlinlang.org_docs_reference_control-flow.html]

## 1.if语句/if表达式 ##

在 Kotlin 中，if可作为表达式，即可返回一个值！
    因此 Kotlin 没有三元运算符( a>b ? a : b )，因为if表达式就能胜任( if (a > b) a else b )
    
    // 1.传统用法,作为if语句
        var max: Int
        if (a > b) {
            max = a
        } else {
            max = b
        }
    
    // 2.作为if表达式
        注意：如果if作为表达式，显然必需要有else分支，因为表达式在任何情况下都应有返回值！
        val max = if (a > b) a else b
    
        if分支还可以是代码块，最后一行的表达式作为代码块的返回值：
        val max = if (a > b) {
                        print("Choose a")
                        a
                    } else {
                        print("Choose b")
                        b
                    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23

## 2.when语句/when表达式 ##

when将参数和分支条件进行顺序比较，直到某个分支满足条件！
    像if一样, when即可作为语句，也可作为表达式！
    如果when作为表达式, 则符合条件的分支值就是整个表达式值, 如果都不满足则会求值else分支;    
    如果when作为表达式，显然必需要有else分支, 除非编译器检测出已覆盖所有可能分支!
    
    when语句取代了类C语言/java的switch语句:
        when (x) {
            1 -> print("x == 1")
            2 -> print("x == 2")
            else -> { // 注意这个块
                print("x is neither 1 nor 2")
            }
        }
    
    1.多个分支代码相同,可放在一起,用逗号分隔:
        when (x) {
            0, 1 -> print("x == 0 or x == 1")
            else -> print("otherwise")
        }
    
    2.可用任意表达式(不只是常量)作为分支条件:
        when (x) {
            parseInt(s) -> print("s encodes x")
            else -> print("s does not encode x")
        }
    
    3.可检测一个值在(in)或者不在(!in)一个区间或集合：
        when (x) {
            in 1..10 -> print("x is in the range")
            in validNumbers -> print("x is valid")
            !in 10..20 -> print("x is outside the range")
            else -> print("none of the above")
        }
    
    4.可检测一个值是(is)或不是(!is)某种类型:
        fun hasPrefix(x: Any) = when(x) {
            is String -> x.startsWith("prefix")
            else -> false
        }
    
    
    5.取代 if-else if 链 
    如果没有参数，则分支条件结果是 Boolean 类型
        when {
            x.isOdd() -> print("x is odd")
            x.isEven() -> print("x is even")
            else -> print("x is funny")
        }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48

## 3.循环 ##

在循环中 Kotlin 支持传统的 break 和 continue

### 1.for循环 ###

for 可循环遍历提供了迭代器的对象:
        有一个成员函数或者扩展函数 iterator()，
        它的返回类型:
            有一个成员函数或者扩展函数 next(),
            并且有一个成员函数或者扩展函数 hasNext(), 返回 Boolean
        这三个函数都需要标记为 operator
    
        for (item in collection) {
            print(item)
        }
    
    也可以通过索引遍历数组或者list:
        for (i in array.indices) {
            print(array[i])
        }
    
    还可以用库函数 withIndex:
        for ((index, value) in array.withIndex()) {
            println("the element at $index is $value")
        }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20

实例  
对集合进行迭代：

fun main(args: Array<String>) { 
        val items = listOf("apple", "banana", "kiwi")
        for (item in items) { 
            println(item)
        }
    
        for (index in items.indices) { 
            println("item at $index is ${ items[index]}")
        }
    }

输出结果：

apple
    banana
    kiwi
    item at 0 is apple
    item at 1 is banana
    item at 2 is kiwi

### 2.while循环 ###

while 和 do..while 和java一样:
        while (x > 0) {
            x--
        }
    
        do {
            val y = retrieveData()
        } while (y != null) // y 在此处可见
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8

实例：

fun main(args: Array<String>) { 
        println("----while 使用-----")
        var x = 5
        while (x > 0) { 
            println( x--)
        }
        println("----do...while 使用-----")
        var y = 5
        do { 
            println(y--)
        } while(y>0)
    }

输出结果：

5
    4
    3
    2
    1
    ----do...while 使用-----
    5
    4
    3
    2
    1

官方文档: [http://kotlinlang.org/docs/reference/returns.html][http_kotlinlang.org_docs_reference_returns.html]

### 3. 返回和跳转 ###

Kotlin 有三种结构化跳转表达式：

return。默认从最直接包围它的函数或者匿名函数返回。  
break。终止最直接包围它的循环。  
continue。继续下一次最直接包围它的循环。  
在循环中 Kotlin 支持传统的 break 和 continue 操作符。

fun main(args: Array<String>) { 
        for (i in 1..10) { 
            if (i==3) continue  // i 为 3 时跳过当前循环，继续下一次循环
            println(i)
            if (i>5) break   // i 为 6 时 跳出循环
        }
    }

输出结果：

1
    2
    4
    5
    6

和Java不同的是，这些表达式都可作为更大表达式的一部分:

val s = person.name ?: return

## 4. break和continue @标签 ##

和Java不同的是，在 Kotlin 中任何表达式都可以用 标签@ 来标记:
        loop@ for (i in 1..100) {
            for (j in 1..100) {
                if (……) break@loop // 终止loop标记的循环
                if (……) continue@loop // 跳出loop标记的循环，继续下一次loop标记的循环
            }
        }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7

## 5. return @标签 ##

Kotlin 有局部函数，因此Kotlin函数可被嵌套

Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。 标签限制的 return 允许我们从外层函数返回。 最重要的一个用途就是从 lambda 表达式中返回。回想一下我们这么写的时候：

fun foo() { 
        ints.forEach { 
            if (it == 0) return
            print(it)
        }
    }

这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。） 如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。

fun foo() { 
        ints.forEach lit@ { 
            if (it == 0) return@lit
            print(it)
        }
    }

现在，它只会从 lambda 表达式中返回。通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。

fun foo() { 
        ints.forEach { 
            if (it == 0) return@forEach
            print(it)
        }
    }

或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回

fun foo() { 
        ints.forEach(fun(value: Int) { 
            if (value == 0) return
            print(value)
        })
    }

当要返一个回值的时候，解析器优先选用标签限制的 return，即

return@a 1  // 从@a标记的函数返回1，不是返回标记的表达式(@a 1)”。

[http_kotlinlang.org_docs_reference_control-flow.html]: http://kotlinlang.org/docs/reference/control-flow.html
[http_kotlinlang.org_docs_reference_returns.html]: http://kotlinlang.org/docs/reference/returns.html