流程控制

分支结构

if表达式

在 Kotlin 中，if是一个表达式，即它会返回一个值。因此就不需要三元运算符（条件 ? 然后 : 否则），因为普通的 if 就能胜任这个角色。

// 传统用法
var max = a 
if (a < b) max = b

// With else 
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}
 
// 作为表达式
val max = if (a > b) a else b

val max = if (a > b) {
    print("Choose a")
    a
} else {
    print("Choose b")
    b
}

when 表达式

when 表达式取代了类 C 语言的 switch 语句。when 将它的参数与所有的分支条件顺序比较，直到某个分支满足条件。其最简单的形式如下：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // when和if类似有一个可选的else块
        print("x is neither 1 nor 2")
    }
}

when和switch不同，他不会贯穿所有条件，也就是说，上述代码如果x==1时，输出的打印结果为x == 1。
如果when语句中，有多个值的处理逻辑相同，可以将多个相同处理逻辑的选项放在一起，并使用逗号隔开：
```
when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}
```

when的分支条件比Java的switch更加强大，可以是任何表达式，不一定是常量：

when (x) {
    parseInt(s) -> print("s encodes x")
    else -> print("s does not encode x")
}

when示例，判断值是否属于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")
}

when示例，加判断值是否是某个类型is、是否不是某个类型!is：

fun hasPrefix(x: Any) = when(x) {
    // 如果x是String类型
    is String -> x.startsWith("prefix")
    else -> false
}

自Kotlin 1.3 起，可以使用以下语法将 when 的主语（subject，译注：指 when 所判断的表达式）捕获到变量中：

fun Request.getBody() =
        when (val response = executeRequest()) {
            is Success -> response.body
            is HttpError -> throw HttpException(response.status)
        }

循环结构

for 循环

foreach循环

for (item in collection) {
    print(item)
}

跟java中的foreach基本一致，在java中，目标类需要实现Iterator接口，而在Kotlin中，目标要想使用foreach，必须要有一个operator方法，方法返回kotlin.collections.Iterator类型实例。比如，Array类中就含有该方法，故数组可以使用foreach循环。

for区间循环

// 从1到3，每次递进1
for (i in 1..3) {
    println(i)
}

// 从6到2，每次递减2
for (i in 6 downTo 0 step 2) {
    println(i)
}

for通过索引循环数组或list

for (i in array.indices) {
    println(array[i])
}

或者使用withIndex函数：

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

while循环

同java相同，提供了while与dowhile循环:

while (x > 0) {
    x--
}

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

流程控制语句

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

return。默认从最直接包围它的函数或者匿名函数返回。
break。终止最直接包围它的循环。
continue。继续下一次最直接包围它的循环。

break/continue lable

在 Kotlin 中任何表达式都可以用标签（label）来标记。标签的格式为标识符后跟 @ 符号，例如：abc@、fooBar@都是有效的标签（参见语法）。要为一个表达式加标签，我们只要在其前加标签即可。

表达式是一种可计算或可求值的代码片段，它返回一个值。简单来说，表达式就是一个操作符、操作数和函数调用的组合，它会在计算后返回一个结果。在Kotlin中，几乎所有的语句都是表达式，包括赋值语句、if语句、for循环等。Kotlin中的表达式可以用来定义函数体、lambda表达式、类的属性等。

fun main(args: Array<String>) {
    // 当 i == 20 && j == 20时 跳转到被目标标签修饰的循环，也就是跳出最外层的循环
    loop@ for (i in 1..100) {
        for (j in 1..100) {
            println("$i : $j")
            if (i == 20 && j == 20) break@loop
        }
    }
}

return lable

Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。标签限制的 return 允许我们从外层函数返回。

有如下代码：

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return
        print(it)
    }
    println("this point is unreachable")
}
// 输出结果为， 12

当我想如果 it == 3时，不做任何操作，可以使用如下方式：

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // 让return返回到该 lambda 表达式的调用者，即 forEach 循环
        print(it)
    }
    print(" done with implicit label")
}
// 输出结果，1245 done with implicit label

当然，也可以使用匿名函数代替lambda，这样就只会退出匿名函数：

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
        if (value == 3) return  // 局部返回到匿名函数的调用者，即 forEach 循环
        print(value)
    })
    print(" done with anonymous function")
}
// 1245 done with anonymous function

最后更新于1年前

这有帮助吗？