原文链接 Kotlin Controls and Expressions
有结果返回的是表达式,没有返回的称之为语句,语句最大的问题是它没有返回值,那么想要保存结果就必然会产生副作用,比如改变变量。很多时候这是不够方便的,并且在多线程条件下,这甚至是不安全的。Kotlin中,为了加强线程安全性和方便并发和异步,因此绝大多数语句都是表达式。
[图片上传失败...(image-b0f37e-1699879436422)]
分支表达式
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表达式
当超过2个分支时,if就不能用了,这时可以用when表达式,它支持多个分支,类似于其他语言中的switch:
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")
}
当然,最重要的是when是一个表达式,可以直接用在赋值符的右边,或者当参数传,或者用在return中:
fun Request.getBody() =
when (val response = executeRequest()) {
is Success -> response.body
is HttpError -> throw HttpException(response.status)
}
这里的when就是函数的返回值,可以看到when是一个表达式,它会返回一个值,这个值直接作为函数的返回值。
从这几个示例可以看出when表达式相当强大比其他语言的switch要强大许多,并且可以直接当作返回值,当需要超过2个条件分支时就可以使用when表达式。
循环语句
循环是语句,与其他语言也差不多。
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)
这里的collection可以是数组和集合(列表和Set)。严格来说只要collection类型实现了iterator()和next(),就可以在for loop中使用。
for加上range,可以非常强大:
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")
}
其实吧,Kotlin是多范式编程语言,天生支持函数式编程,多数情况下不建议直接上for loop,而是用函数式方式的forEach,数组和集合都支持forEach的:
array.forEach { println(it) }
终止语句
当想提前退出函数的执行,或者循环时,就需要用到终止语句,有三种return, break和continue。
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 loop
print(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 loop
print(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 loop
print(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 = false
for (j in i until 10) {
if (array[i] + array[j] == target) {
found = true
break // 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错了某个标签,调试的难度是相当大的。更多的时候需要仔细想想有没有更好的遍历方式,而不是靠标签来救命。