重学Kotlin（一） 控制流：if、when、for、while

If 表达式

用if替代Java中的三元运算符

// 作为表达式
val max = if (a > b) a else b

if 的分支可以是代码块，最后的表达式作为该块的值：

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

When 表达式

简单使用(多条件用逗号分割)

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

表达式（而不只是常量）作为分支条件

when (x) {
    parseInt(s) -> print("s encodes x")
    in 1..10 -> print("x is in the range")
    is String -> x.startsWith("prefix")
    else -> print("s does not encode x")
}

如果不提供参数,when 也可以用来取代 if-else if链。

when {
    x.isOdd() -> print("x is odd")
    y.isEven() -> print("y is even")
    else -> print("x+y is odd.")
}

在 when 主语中引入的变量的作用域仅限于 when 主体。

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

For 循环

简单用法

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

索引遍历

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

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

while 与 do…while 照常使用

while (x > 0) {
    x--
}

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

返回和跳转

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

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

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

我们可以用标签限制 break 或者continue：

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (……) break@loop
    }
}

非局部返回：

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return // 非局部直接返回到 foo() 的调用者
        print(it)
    }
    println("this point is unreachable")
}

局部返回：

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        if (it == 3) return@lit // 局部返回到该 lambda 表达式的调用者，即 forEach 循环
        print(it)
    }
    print(" done with explicit label")
}

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

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

或者，我们用一个匿名函数替代

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