Kotlin-1.4-返回和跳转

短命女 2022-06-03 04:22 219阅读 0赞

# Kotlin-Returns and Jumps #

--------------------

标签： Kotlin

> 本文翻译自如官方文档：[Returns and Jumps][]——如有疏漏和错误，欢迎指正！  
> 此外额外增加一些知识点以及实例。

*  Kotlin-Returns and Jumps
 *  1-返回和跳转
    
     *  1-Break和Continue标签
     *  2-在标签处的Return
     *  3-实例讲解
 *  1-Returns and Jumps
    
     *  1-Break and Continue Labels
     *  2-Return at Labels

# 1-返回和跳转 #

--------------------

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

*  return. 默认从最近的封闭方法(包含该return的方法)或者匿名方法返回。
 *  break. 终止最近的封闭循环。
 *  continue. 从最近的封闭循环的下一步继续下去。

这些表达式都可以被用作更大的表达式的一部分:

val s = person.name ?: return

这些表达式的类型是`Nothing类型`  
The type of these expressions is the `Nothing type`.

## 1-Break和Continue标签 ##

在Kotlin中的任何表达式可以用`label标签`来标记。标签有一种描述符格式-尾随一个`@`标志。例如：`abc@`, `fooBar@`就是合法标签（参照`grammar`语法）。为了标记一个表达式，我们将标签放置于该表达式的前面：

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

现在，我们可以使用标签来标记一个`break`或者`continue`:

loop@ for (i in 1..100) {
        for (j in 1..100) {
            if (...) break@loop //直接结束loop@标记的for循环
        }
    }

使用标签标记的`break`跳转到拥有该标签的循环体的下一执行点去执行(该循环结束)。`continue`会从该循环的下一次开始，继续执行下去。

## 2-在标签处的Return ##

通过函数字面值、本地函数和对象表达式，函数可以在Kotlin中被嵌套起来。标记过的`returns`允许我们从外部函数返回。这最重要的使用方法是从一个`lambda`表达式返回。如下：

fun foo() {
        ints.forEach { //ints是一个int数组
            if (it == 0) return  //非本地的return，从内部的lambda直接返回到foo()的调用者
            print(it)
        }
    }

这个`return`\-表达式从最近的封闭函数返回。例如`foo`(注意：只有传递给内联函数的lambda表达式才支持这种非局部returns)。

> lambda表达式：lambda是一种函数式编程，最大特征是函数可以作为其他函数的参数。lambda本质是是匿名方法，编译器会自动将lambda表达式转换为“匿名方法”。  
> 这里的ints.forEach\{…\}就是lambda表达式：在int数组`ints`执行的forEach方法中，将\{…\}中的全部内容，作为forEach方法的参数。

如果我们想从一个lambda表达式返回，我们不得不用标签标记这个return：

fun foo() {
        ints.forEach lit@ { 
            if (it == 0) return@lit
            print(it)
        }
    }

上例，它仅从lambda表达式return。有时更方便使用隐式标签：该标签有和函数相同的名字。

fun foo() {
        ints.forEach {
            if (it == 0) return@forEach
            print(it)
        }
    }

另一方面，我们可以用`匿名函数`替换lambda表达式。在匿名函数的`return`语句将从匿名函数本身返回。

fun foo() {
        ints.forEach(fun(value: Int) {
            if (value == 0) return  // 从匿名函数的调用者局部返回，即forEach循环。
            print(value)
        })
    }

当正在返回一个值，解析器会优先考虑标签化返回：

return@a 1

意思是“return `1` 到标签`@`处”，而不是”返回一个标签表达式`(@a 1)`”

## 3-实例讲解： ##

该实例是完成打印数组内容的功能。

方法fooNoLabel没有使用标签return，是直接return到fooNoLabel调用者，因此只打印出1，2，3。

fooWithLabel使用标签`label@`，return是返回到forEach循环，因此打印出1，2，3，5,打印出所有不为0的数字。

fun main(args: Array<String>) {
        val intarray: IntArray = intArrayOf(1, 2, 3, 0, 5)
        fooNoLabel(intarray) //结果 1， 2， 3
        fooWithLabel(intarray) //结果 1， 2， 3， 5
    }
    
    fun fooNoLabel(ints: IntArray) {
        ints.forEach{
            if (it == 0) return 
            println(it)
        }
    }
    
    fun fooWithLabel(ints: IntArray) {
        ints.forEach label@{
            if (it == 0) return@label  
            println(it)
        }
    }

--------------------

如下是官方文档原文：[Returns and Jumps][]

# 1-Returns and Jumps #

Kotlin has three structural jump expressions:

*  return. By default returns from the nearest enclosing function or anonymous function.
 *  break. Terminates the nearest enclosing loop.
 *  continue. Proceeds to the next step of the nearest enclosing loop.

All of these expressions can be used as part of larger expressions:

val s = person.name ?: return

The type of these expressions is the Nothing type.

## 1-Break and Continue Labels ##

Any expression in Kotlin may be marked with a `label`. Labels have the form of an identifier followed by the `@` sign, for example: `abc@`, `fooBar@` are valid labels (see the `grammar`). To label an expression, we just put a label in front of it

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

Now, we can qualify a break or a continue with a label:

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

A `break` qualified with a label jumps to the execution point right after the loop marked with that label. A `continue` proceeds to the next iteration of that loop.

## 2-Return at Labels ##

With function literals, local functions and object expression, functions can be nested in Kotlin. Qualified `returns` allow us to return from an outer function. The most important use case is returning from a lambda expression. Recall that when we write this:

fun foo() {
        ints.forEach {
            if (it == 0) return  // nonlocal return from inside lambda directly to the caller of foo()
            print(it)
        }
    }

The `return`\-expression returns from the nearest enclosing function, i.e. `foo.` (Note that such non-local returns are supported only for lambda expressions passed to `inline functions`.) If we need to return from a lambda expression, we have to label it and qualify the `return`:

fun foo() {
        ints.forEach lit@ { 
            if (it == 0) return@lit
            print(it)
        }
    }

Now, it returns only from the lambda expression. Oftentimes it is more convenient to use implicits labels: such a label has the same name as the function to which the lambda is passed.

fun foo() {
        ints.forEach {
            if (it == 0) return@forEach
            print(it)
        }
    }

Alternatively, we can replace the lambda expression with an `anonymous function`. A `return` statement in an anonymous function will return from the anonymous function itself.

fun foo() {
        ints.forEach(fun(value: Int) {
            if (value == 0) return  // local return to the caller of the anonymous fun, i.e. the forEach loop
            print(value)
        })
    }

When returning a value, the parser gives preference to the qualified return, i.e.

return@a 1

means “return `1` at label `@a`” and not “return a labeled expression `(@a 1)`“.

[Returns and Jumps]: https://kotlinlang.org/docs/reference/returns.html