9：kotlin 返回和跳过（Returns and jumps）

kotlin有三种结构跳转表达式：

• return会从最近的封闭函数或匿名函数返回。

• break终止最近的封闭循环。

• continue继续最近的封闭循环的下一步。

所有这些表达式都可以作为其他表达式的一本分使用

val s = person.name ?: return

val s = person.name ?: return 这行代码的意思是尝试从person对象中获取name属性的值，并将其赋值给变量s。如果person.name存在，那么它的值就会被赋值给s。但是，如果person.name为null，那么return语句会被执行，当前函数会立即返回，不再执行后续的代码。这是Elvis操作符?:的一个常见用法。

break / continue

基本使用方法

fun main() {
    for (i in 1..5) {
        if ( i == 2){
            break   // 结束循环
        }
        println(i)
        // 1
    }
    for (i in 1..5) {
        if ( i == 2){
            continue    // 跳过本次循环,进入下次循环
        }
        println(i)
        // 1
        // 3
        // 4
        // 5
    }
}

任何表达式都可以用标签进行标记，使用@符号

fun main() {
    loop@ for (i in 1..100) {
        // ...
    }
}

我们可以快速break 或者continue一个标签

fun main() {
    loop1@ for (c in 'a'..'c') {
        for (i in 1..3) {
            if (c == 'b') {
                break@loop1   // 结束循环
            }
            println("$c $i")
//            a 1
//            a 2
//            a 3
        }
    }

    loop2@ for (c in 'a'..'c') {
        for (i in 1..3) {
            if (c == 'b') {
                continue@loop2   // 结束循环
            }
            println("$c $i")
//            a 1
//            a 2
//            a 3
//            c 1
//            c 2
//            c 3
        }
    }
}

return

fun main() {
    foo()
//        1
//        2
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return 
        println(it)
    }
    println("方法执行完了")   // 当前行未执行，上边的return直接结束了foo方法
}

给lambda加标签并return

fun main() {
    foo()
//    1
//    2
//    4
//    5
//    方法执行完了
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach foo@{
        if (it == 3) return@foo
        println(it)
    }
    println("方法执行完了")
}

使用隐式标签返回，统称隐式标签和lambda表达式具有相同的名称

fun main() {
    foo()
//    1
//    2
//    4
//    5
//    方法执行完了
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach
        println(it)
    }
    println("方法执行完了")   // 当前行未执行，上边的return直接结束了foo方法
}

将lambda表达式换成匿名函数后，使用return将结束匿名函数，不对循环起作用

fun main() {
    foo()
//    1
//    2
//    4
//    5
//    方法执行完了
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
        if (value == 3) return
        println(value)
    })
    print("方法执行完了")
}

当返回一个值时，解析器优先考虑合格的返回：

return@a 1

这意味着 “在标签 @a 处返回 1”，而不是 “返回一个带标签的表达式 @a 1”。