原文链接 Kotlin Controls and Expressions

分支表达式

Kotlin中没有三元条件符（a > b ? a : b)，但它的条件分支都是表达式，可以直接放在赋值符的右边，或者用在return语句中。

if表达式

val maxV = if (a > b) a else b

var max: Int
if (a > b) {max = a
} else {max = b
}

when表达式

when (x) {1 -> println("it is 1")2 -> println("it is 2")else -> {println("it is neight 1 nor 2")}
}

when (x) {in 1..5 -> println("Less than 5 bigger than 1")x.isEven() -> println("it is even")else -> println("It is neither even or less than 5")
}

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

循环语句

循环是语句，与其他语言也差不多。

while loop

while (x < 10) {println(x)x++
}

屁股向后式do-while loop

do {x = poll()
} while (x < 10)

强大的for loop

for (item in collection) print(item)

for (i in 1..10) // = for (int i = 1; i <= 10; i++)
for (i in 0 until 10) // = for (int i = 0; i < 10; i++)
for (i in 9 downTo 0) // = for (int i = 9; i >= 0; i--)
for (i in 0 until 10 step 2) // = for (int i = 0; i < 10; i += 2)

for (i in array.indices) {println(array[i]) // 'i' is the index
}

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

array.forEach { println(it) }

终止语句

return终止函数执行

这个都比较熟悉，常规的用法都是一样的，可以提前退出函数：

fun plot(x: Int) {if (x < 1) {return -1}...return y
}

但当有嵌套的lambda时，如不特别指定，return会退出外层的函数，而不是像想当然的退出lambda，比如：

fun foo() {listOf(1, 2, 3, 4, 5).forEach {if (it == 3) return // non-local return directly to the caller of foo()print(it)}println("this point is unreachable")
}

这个不是终止lambda的执行，而是直接退出函数foo的执行。如果想解决呢，即也退出遍历的lambda有三种方案：

• 使用标签

fun foo() {listOf(1, 2, 3, 4, 5).forEach lit@{if (it == 3) return@lit // local return to the caller of the lambda - the forEach loopprint(it)}print(" done with explicit label")
}

• 使用隐式标签，也即遍历的方法当作标签

fun foo() {listOf(1, 2, 3, 4, 5).forEach {if (it == 3) return@forEach // local return to the caller of the lambda - the forEach loopprint(it)}print(" done with implicit label")
}

• 使用匿名函数而不是lambda，匿名函数与常规函数体效力一样，所以return只在函数体内生效

fun foo() {listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {if (value == 3) return  // local return to the caller of the anonymous function - the forEach loopprint(value)})print(" done with anonymous function")
}

这三种方式，如果非要使用，建议使用方式二，用自带的隐式label，因为比较方便，可读性也不差。

但，非常不建议如此使用return语句，这本是应该避免的问题，lambda多半是用在函数式遍历和处理，在lambda里面提加return本就是非常奇怪的事情。因为如果某些条件不满足，想不执行此lambda，应该用filter啊，而不是笨拙的非要在lambda中去终止：

fun foo() {listOf(1, 2, 3, 4, 5).filter(i -> i != 3).forEach { println(it) }print("You can do whatever you like here.")
}

循环的终止

break终止当前循环，continue则是跳过当前循环的当前步骤，直接跳到下一次迭代。这两个的常规使用与其他语言是一样的。

但对于break，一般来说有一个痛点，就是当有循环嵌套时，break只能终止一层，如果想终止所有循环时，只能再手动的加条件去判断，然后再一层一层的break，比如:

for (i in 0 until 10) {var found = falsefor (j in i until 10) {if (array[i] + array[j] == target) {found = truebreak // only break inner for loop}}if (found) {break // this break outer for loop}
}

这多少有点笨拙和丑陋，Kotlin有更优雅的解决方式，就是引入了标签label，可以给循环加上标签，在break时可以指定标签，同样是上面的情况，可以这样做：

loop@ for (i in 0 until 10) {for (j in i until 10) {if (array[i] + array[j] == target) {break @loop // break all loops easily}}
}

其实吧，这玩意儿跟当年的goto是一样的，虽然可行，但不建议多使用，标签多了以后会让程序的执行更加的混乱，试想假如在层层循环中break错了某个标签，调试的难度是相当大的。更多的时候需要仔细想想有没有更好的遍历方式，而不是靠标签来救命。

原创不易，打赏，点赞，在看，收藏，分享 总要有一个吧