Kotlin基础语法
Kotlin说明
Kotlin是一种在Java虚拟机上运行的静态类型编程语言，被称之为Android世界的Swift，Kotlin可以编译成Java字节码，也可以编译成JavaScript，方便在没有JVM的设备上运行。在Google I/O 2017中，Google 宣布 Kotlin 成为 Android 官方开发语言，足见Kotlin将来会成为android开发的主流语言。
本文从Kotlin基础语法为入口，先了解一下Kotlin的基本数据类型，之后再阐述Kotlin中的运算符，最后在陈述一下Kotlin的条件控制及循环控制结构。本文只做Kotlin入门的参考资料，如有谬误、纰漏，望大家多多指教。
Kotlin基本数据类型
Kotlin中的基本数据类型包含：数值、字符、布尔、数组、字符串。
数值
Kotlin数值类型包含Byte、Short，Int、Long、Float、Double等。不同于Java，字符不属于数值类型，是一个独立的数据类型。
| 类型 | 位宽度 |
| Byte | 8 |
| Short | 16 |
| Int | 32 |
| Long | 64 |
| Float | 32 |
| Double | 64 |
字面常量
- 十进制：1024
- 长整型：1024L
- 16进制：0x0F
- 2进制：0b00011001
- 注意：8进制不支持
- Floats 使用 f 或者 F 后缀：134.5f
- Doubles：12.5,123.5e10
字符
和 Java 不一样，Kotlin 中的 Char 不能直接和数字操作，Char 必需是单引号 ' 包含起来的。比如普通字符 '9'，'o'。如下写法是错误的：
fun check(c: Char) {
if (c == 1) { // 错误：类型不兼容
// ……
}
}字符字面值用单引号括起来: '1'。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、\'、\"、\\ 和 \$。 编码其他字符要用 Unicode 转义序列语法：'\uFF00'。我们可以显式把字符转换为 Int 数字：
fun decimalDigitValue(c: Char): Int {
if (c !in '0'..'9')
throw IllegalArgumentException("Out of range")
return c.toInt() - '0'.toInt() // 显式转换为数字
}布尔
布尔用 Boolean 类型表示，它有两个值：true 和 false。内置的布尔运算有：
|| – 短路逻辑或 && – 短路逻辑与 ! - 逻辑非
数组
数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。如下所示：
//[1,2,3]
val a = arrayOf(1, 2, 3)
//[0,2,4]
val b = Array(3, { i -> (i * 2) })
//读取数组内容
Log.d(TAG,a[0].toString()) // 输出结果：1
Log.d(TAG,b[1].toString()) // 输出结果：2如上所述，[] 运算符代表调用成员函数 get() 和 set()。注意: 与 Java 不同的是，Kotlin 中数组是不协变的（invariant）。除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：
val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]字符串
和Java一样，String是不可变的。方括号[]语法可以很方便的获取字符串中的某个字符，也可以通过for循环来遍历：
for (c in str) {
Log.d(TAG,c.toString())
}Kotlin支持三个引号"""扩起来的字符串，支持多行字符串，比如：
val text = """
多行字符串
多行字符串
"""
Log.d(TAG,text) // 输出有一些前置空格字符串模板
字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。 模板表达式以美元符（$）开头，由一个简单的名字构成:
- $ 表示一个变量名或者变量值
- $varName 表示变量值
- ${varName.fun()} 表示变量的方法返回值
var a = 1
// 模板中的简单名称：
val s1 = "a is $a"
a = 2
// 模板中的任意表达式：
val s2 = "${s1.replace("is", "was")}, but now is $a"或者用花括号扩起来的任意表达式:
val s = "hello world"
val str = "$s.length is ${s.length}" // 求值结果为 "hello world.length is 11"原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义），你可以用下列语法：
val price = "${'$'}9.99"
Log.d(TAG,price)Kotlin基础语法
函数定义
一般函数定义格式
函数定义使用关键字fun，参数格式为：参数名: 类型，如：
fun sum(a: Int, b: Int): Int { // Int 参数，返回值 Int
return a + b
}表达式作为函数体，返回类型自动推断：
fun sum(a: Int, b: Int) = a + b
public fun sum(a: Int, b: Int): Int = a + b // public 方法则必须明确写出返回类型无返回值的函数（类似Java中的void） :
fun printSum(a: Int, b: Int): Unit {
Log.d(TAG,(a + b).toString())
}
// 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：
public fun printSum(a: Int, b: Int) {
Log.d(TAG,(a + b).toString())
}可变长参数函数
函数的变长参数可以用vararg关键字进行标识：
fun vars(vararg v:Int){
for(vt in v){
Log.d(TAG,vt.toString())
}
}lambda(匿名函数)
lambda表达式使用实例：
val sumLambda: (Int, Int) -> Int = {x,y -> x+y}定义常量与变量
变量定义
变量定义使用var关键字，定义格式如下：
var <标识符> : <类型> = <初始化值>
常量定义
变量定义使用val关键字，只能赋值一次的变量（类似Java中final修饰的变量），定义格式如下：
val <标识符> : <类型> = <初始化值>
常量与变量都可以没有初始化值，但是在引用前必须初始化，编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。
val a: Int = 1
val b = 1 // 系统自动推断变量类型为Int
val c: Int // 如果不在声明时初始化则必须提供变量类型
c = 1 // 明确赋值
var x = 5 // 系统自动推断变量类型为Int
x += 1 // 变量可修改注释
Kotlin 支持单行和多行注释，与 Java 不同的是，Kotlin 中的块注释允许嵌套。格式如下：
// 这是一个单行注释 /* 这是一个多行的 块注释。 */
NULL检查机制
Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理。
//类型后面加?表示可为空
var age: String? = "23"
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1当一个引用可能为 null 值时, 对应的类型声明必须明确地标记为可为 null。 如：当 str 中的字符串内容不是一个整数时, 返回 null:
fun parseInt(str: String): Int? {
// ...
}区间
区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:
for (i in 1..4) Log.d(TAG,i.toString()) // 输出“1234”
for (i in 4..1) Log.d(TAG,i.toString()) // 什么都不输出
if (i in 1..10) { // 等同于 1 <= i && i <= 10
Log.d(TAG,i.toString())
}
// 使用 step 指定步长
for (i in 1..4 step 2) Log.d(TAG,i.toString()) // 输出“13”
for (i in 4 downTo 1 step 2) Log.d(TAG,i.toString()) // 输出“42”
// 使用 until 函数排除结束元素
for (i in 1 until 10) { // i in [1, 10) 排除了 10
Log.d(TAG,i.toString())
}运算符
作为一门计算机语言，运算符是必不可少的，Kotlin提供了一套丰富的运算符来操作变量，我们可以把运算符分成以下几类：
- 算术运算符
- 关系运算符
- 位运算符
- 逻辑运算符
- 赋值运算符
- 其他运算符
算术运算符
算术运算符用在数学表达式中，他们的作用和数学的作用一样。下表中列出了所有的算术运算符。
| 运算符 | 描述 |
| + | 加法-运算符两侧的值相加 |
| - | 减法-左操作数减右操作数 |
| * | 乘法-运算符两侧的值相乘 |
| / | 除法-左操作数除以右操作数，如果两个操作数为正数，为取商 |
| % | 取余-做操作数除以做操作数的余数 |
| ++ | 自增-操作数的值增加1，对应方法为inc() |
| -- | 自减-操作数的值减1，对应方法为dec() |
实例代码
var a = 3
var b = 5
Log.d(TAG,"a = " + a +" b = " + b)
Log.d(TAG,"a + b = " + (a + b)) //加法
Log.d(TAG,"a - b = " + (a - b)) //减法
Log.d(TAG,"a * b = " + (a * b)) //减法
Log.d(TAG,"a / b = " + (a / b)) //减法
a++
Log.d(TAG,"a++" + a) //自增
b--
Log.d(TAG,"b--" + b) //自减运行结果
关系运算符
Kotlin中的关系运算符如下表所示：
| 运算符 | 描述 |
| == | 检查两个操作数的值是否相等，如果相等则为真。相当于Java中的equals |
| === | 检查两个操作数的引用是否相等，如果相等则条件为真。相当于Java中的==。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 |
| !== | 检查两个操作数的引用是否相等，如果不相等则条件为真。相等于Java中的!= |
| > | 检查左操作数的值是否大于右操作数，如果是则条件为真。 |
| < | 检查左操作数的值是否小于右操作数，如果是则条件为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数，如果是则为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数，如果是则为真。 |
实例代码
var a = String("5".toByteArray())
var b = String("5".toByteArray()) //a、b为两个值相等的不同对象
var c = "5"
var d = "5"
Log.d(TAG,"a == b = " + (a == b))
Log.d(TAG,"a === b = " + (a === b))
Log.d(TAG,"c == d = " + (c == d))
Log.d(TAG,"c === d = " + (c === d))
Log.d(TAG,"a != b = " + (a != b))
Log.d(TAG,"a !== b = " + (a !== b))
Log.d(TAG,"c != d = " + (c != d))
Log.d(TAG,"c !== d = " + (c !== d))
Log.d(TAG,"a > b = " + (a > b))
Log.d(TAG,"a < b = " + (a < b))
Log.d(TAG,"a >= b = " + (a >= b))
Log.d(TAG,"a <= b = " + (a <= b))运行结果
位运算符
对于Int和Long类型，还有一系列的位操作符可以使用，如下表所示：
| 符号或方法 | 说明 |
| and 、and(bits) | 按位与 |
| or 、or(bits) | 按位或 |
| inv() | 按位非 |
| xor 、xor(bits) | 按位异或 |
| shl、shl(bits) | 左移运算符 |
| shr、shr(bits) | 右移运算符 |
| ushr、ushr(bits) | 无符号右移运算符 |
注意：and、or、xor、shl、shr、ushr即可以直接使用关键字，也可以调用对象的的方法。
实例代码
var a = 0b001001
var b = 0b001001
var c = 0b001000
var d = -0b001000
Log.d(TAG,"a and b = " +a.and(b))
Log.d(TAG,"a and b = " +(a and b))
Log.d(TAG,"a and c = " +a.and(c))
Log.d(TAG,"a or c = " +a.or(c))
Log.d(TAG,"a or c = " +(a or c))
Log.d(TAG,"a inv = " +a.inv())
Log.d(TAG,"a xor c = " +a.xor(c))
Log.d(TAG,"a shl 2 = " +a.shl(2))
Log.d(TAG,"d shr 2 = " +d.shr(2))
Log.d(TAG,"d shr 2 = " +(d shr 2))
Log.d(TAG,"d ushr = " +d.ushr(2))运行结果
逻辑运算符
逻辑运算符有三种，下表列出所有的逻辑运算符：
| 操作符 | 描述 |
| && | 逻辑与。当且仅当两个操作数都为真，条件才为真。 |
| || | 逻辑或。如果两个操作数的任何一个为真，条件为真。 |
| ! | 逻辑非。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算将得到false。 |
赋值运算符
Kotlin语音支持以下赋值符：
| 操作符 | 描述 |
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 |
| += | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 |
| -= | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 |
| *= | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 |
| /= | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 |
| %= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 |
其他运算符
is
我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// 做过类型判断以后，obj会被系统自动转换为String类型
return obj.length
}
// 这里的obj仍然是Any类型的引用
return null
}或者
fun getStringLength(obj: Any): Int? {
if (obj !is String)
return null
// 在这个分支中, `obj` 的类型会被自动转换为 `String`
return obj.length
}甚至还可以
fun getStringLength(obj: Any): Int? {
// 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
if (obj is String && obj.length > 0)
return obj.length
return null
}in
和区间组合在一起，主要表示在…区间。如果要表示不再某一区间，可以使用!in。
可以用in判断数字是否在某个区间
// 检查x数值是否在1到4区间
if (x in 1..4){
}可以用in判断集合中是否存在某个元素
// 检查list中是否有某个元素
if (name in list){
}可以用in遍历整个区间或者集合
// 遍历
for(i in 1..4){
print(i) // 1234
}
// 设置步长
for(i in 1..4 step 2) {
print(i) // 13
}
// for(i in 4..1) // error
// 如果要从大到小遍历，可以使用downTo
for(i in 4 downTo 1 step 2) {
print(i) // 42
}
// until排除结束元素
for(i in 1 until 4) {
print(i) // 123
}
// 遍历list中的每个元素
for(item in list){}条件控制
IF表达式
传统用法
该用法和Java一样，格式如下：
if(布尔表达式1){
...
}else if(布尔表达式2){
...
}
...
else if(布尔表达式n){
...
}
else{
...
}
实例代码如下：
var a = 5
var b = 6
// 传统用法
var max = a
if (a < b) max = b
// 使用 else
if (a > b) {
max = a
} else {
max = b
}赋值
把要执行的IF语句块最后一句的值赋给一个变量，如果最后一条语句没有返回值，则返回为空。
var a = 5
var b = 6
val max = if (a > b) {
print("Choose a")
a
} else {
print("Choose b")
b
}使用区间
使用in运算符来检测某个数字是否在指定区间内，区间格式为x..y。实例如下：
val x = 5
val y = 9
if (x in 1..8) {
println("x 在区间内")
}When表达式
when将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。when既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值。如果当做语句使用，则忽略个别分支的值。when类似其他语言中的switch操作。其最简单的形式如下：
var a = 5
when (a) {
1 -> Log.d(TAG,"a == 1")
2 -> Log.d(TAG,"a == 2")
else -> { // 注意这个块
Log.d(TAG,"a 不是 1 ，也不是 2")
}
}在when中，else同switch的default。如果其他分支都不满足条件将会求值else分支。如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分割：
var a = 5
when (a) {
0, 1 -> Log.d(TAG,"a == 0 or a == 1")
else -> Log.d(TAG,"otherwise")
}我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：
var a = 5
when (a) {
in 1..10 -> Log.d(TAG,"x is in the range")
!in 10..20 -> Log.d(TAG,"x is outside the range")
else -> Log.d(TAG,"none of the above")
}我也可以用来检测一个值是（is）或者不是(!is)一个特定的类型的值。注意：由于智能转换，你可以访问该类型的方法和属性而无需 任何额外的检测。
fun hasPrefix(x:Any ){
when(x) {
is String -> x.startsWith("prefix")
else -> false
}
}when也可以用来取代if-else if链。如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：
var a = 5
var b = 6
when {
a>b -> Log.d(TAG,"a > b")
else -> Log.d(TAG,"a < b")
}when中也可以使用in运算符，用来判断集合内是否包含某实例：
val items = setOf("apple", "banana", "kiwi")
when {
"orange" in items -> Log.d(TAG,"juicy")
"apple" in items -> Log.d(TAG,"apple is fine too")
}循环控制
for循环
for循环可以对任何提供迭代器（iterator）的对象进行遍历，格式如下：
for(item in items) Log.d(TAG,item)
//或
for(item: Int in ints){
//...
}如果你想要通过索引遍历一个数组或者一个list，你可以这样：
for (i in items.indices) {
Log.d(TAG,items[i])
}这种“在区间上遍历”会编译成优化的实现而不会创建额外对象。或者你可以使用库函数withIndex：
for ((index, value) in items.withIndex()) {
Log.d(TAG,"the element at $index is $value")
}实例
val items = listOf("apple", "banana", "orange")
for (item in items) Log.d(TAG,item)
for (i in items.indices) {
Log.d(TAG,items[i])
}
for ((index, value) in items.withIndex()) {
Log.d(TAG,"the element at $index is $value")
}结果
while 与 do...while 循环
while是最基本的循环，它的结构为：
while( 布尔表达式 ) {
//循环内容
}对于while语句而言，如果不满足条件，则不能进入循环。但有的时候我们需要即使不满足条件，也至少执行一次，这是我们可以用 do...while。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);实例
Log.d(TAG,"----while 使用-----")
var x = 3
while (x > 0) {
Log.d(TAG, (x--).toString())
}
Log.d(TAG,"----do...while 使用-----")
var y = 5
do {
Log.d(TAG, (y--).toString())
} while(y>0)结果
返回和跳转
返回关键字
Kotlin和其他语言一样，有三个结构化跳转关键字：return、break和continue，三种关键的作用如下：
- return：默认从最直接包围他的函数或者匿名函数返回。
- break：终止最直接包围它的循环。
- continue：继续下一次最直接包围它的循环。
在循环中，kotlin支持传统的break和continue操作符。
for (i in 0..9) {
if (i==3) continue // i 为 3 时跳过当前循环，继续下一次循环
Log.d(TAG,i.toString())
if (i>5) break // i 为 6 时 跳出循环
}结果
标签跳转
在kotlin中任何表达式都可以用标签（label）来标记。标记的格式为标识符后面加@符号，如：loop@，abc@，都是有效标签。要为一个表达式加标签，我们只要在其前面加标签即可。
break和continue标签
标签限制的break跳转到刚好位于该标签指定的循环后面的执行点，而continue标签指定的是循环下一次迭代。
实例如下：
//break标签
Log.d(TAG,"break start")
loop@ for (i in 1..5) {
for (j in 1..5) {
if (i > 2 && j > 3) break@loop
Log.d(TAG,"j = "+j)
}
Log.d(TAG,"i = "+i)
}
Log.d(TAG,"break end")
//continue标签
Log.d(TAG,"continue start")
loop@ for (i in 1..5) {
for (j in 1..5) {
if (i > 2 && j > 3) continue@loop
Log.d(TAG,"j = "+j)
}
Log.d(TAG,"i = "+i)
}
Log.d(TAG,"continue end")运行结果如下：
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: break start
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 3
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 4
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 5
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: i = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 3
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 4
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 5
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: i = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: break end
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: continue start
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 3
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 4
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 5
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: i = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 3
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 4
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 5
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: i = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 3
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 3
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 1
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 2
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: j = 3
2021-12-09 16:47:37.152 5040-5040/com.panda.kotlintest D/MainActivity: continue end
非局部返回
Kotlin有函数字面量、局部函数和对象表达式，因此Kotlin的函数可以被嵌套。标签限制的return允许我们返回到外层函数。最重要的一个用途就是从lambda表达式中返回。回想一下我们这么写的时候：
fun foo() {
Log.d(TAG,"foo start")
var ints = listOf(1,2,3,0)
ints.forEach {
if (it == 0) return
Log.d(TAG,it.toString())
}
Log.d(TAG,"foo end")
}这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。）
局部返回
如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。如下所示：
fun foo() {
Log.d(TAG,"foo start")
var ints = listOf(1,2,3,0)
ints.forEach lin@{
if (it == 0) return@lin
Log.d(TAG,it.toString())
}
Log.d(TAG,"foo end")
}现在，它只会从 lambda 表达式中返回。通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。
fun foo() {
ints.forEach {
if (it == 0) return@forEach
Log.d(TAG,it.toString())
}
}或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回。
fun foo() {
var ints = listOf(1,2,3,0)
ints.forEach(fun(value: Int) {
if (value == 0) return
Log.d(TAG,value.toString())
})
}标签返回值
当要返回一个值的时候，解析器优先选用标签限制的 return，代码如下：
var value =run loop@{
listOf(1, 2, 3, 4, 5).forEach {
if (it == 3) return@loop it //
Log.d(TAG,"value = " +it)
}
}
Log.d(TAG,"return value = " +value)意为"从标签 @loop 返回 it"，而不是"返回一个标签标注的表达式 (@a it)"。