诗与远方
0%

Kotlin Syntactic Sugar

发表于 更新于
本文字数： 2.9k 阅读时长 ≈ 3 分钟

前言

Kotlin 语法糖的总结和原理分析。

Kotlin 有很多实用的语法糖，比如扩展函数、Object 单例、apply/run/with 等内置函数，对于开发者来说非常的友好的方便。简单梳理和总结包括但不限于上述这些语法糖的内容。

[TOC]

Enjoy Syntactic Sugar

内置函数

kotlin-stdlib 内的 Standard.kt 文件内定义了几个比较实用的顶层函数
比如 apply/with/run/let/also 等，这几个函数的功能比较相似，但又略微有些差异，在此梳理一下。

实例 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

fun main() {
    val sugar = Sugar("mike", 21, true)
    printInfo(sugar)

    val letResult = sugar.let {
        it.name = "let"
        it.age = 9
    }
    printInfo(letResult)

    val alsoResult = sugar.also {
        it.name = "also"
        it.age = 13
    }
    printInfo(alsoResult)

    val withResult = with(sugar) {
        name = "with"
        age = 10
    }
    printInfo(withResult)

    val runResult = sugar.run {
        name = "run"
        age = 11
    }
    printInfo(runResult)

    val applyResult = sugar.apply {
        name = "apply"
        age = 12
    }
    printInfo(applyResult)
}

output 

1
2
3
4
5
6
7
8
9
10
11
Sugar(name=mike, age=21, happy=true) : com.ext.Sugar

kotlin.Unit : kotlin.Unit  // let

Sugar(name=also, age=13, happy=true) : com.ext.Sugar // also

kotlin.Unit : kotlin.Unit  // with

kotlin.Unit : kotlin.Unit // run 

Sugar(name=apply, age=12, happy=true) : com.ext.Sugar // apply

首先从返回结果，可以看到，默认情况下 apply 和 also 返回的都是当前对象，let/with/run 返回的 Unit ，也就是在 Lamdba 表达式中如果没有显示的在最后一行写返回值，那么 kotlin.Unit 就是返回值，可以理解为 Java 中的 Void。

其次从 lambda 表达式的参数可以看出，it 和 also 都是 it ,剩下的 run/with/apply 都是 this 。其实 run 和 with 是的表现是完全一致的，只是调用方式不同而已，run 只需要一个参数，而 with 需要把接受者和 lambda 同时传入。

类型 参数 返回值
let it lambda 表达式最后一行，默认为 kotlin.Unit
also it 接受者，即调用方法的对象
apply this 接受者，即调用方法的对象
with this lambda 表达式最后一行，默认为 kotlin.Unit
run this lambda 表达式最后一行，默认为 kotlin.Unit
原理剖析

总的来说，这几个内置函数的实现是高度相似的，都是使用了 Kotlin 高阶函数的特性。但是他又是如何实现这些微妙的差异的那？我们可以对比一下 let 和 also

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}
  • 可以看到 block: (T) -> R block 函数的参数类型就是 T，也就是调用者。因此 lambda 表达式的参数名称就是 it
  • 再看返回值 let 直接返回了 block 函数的运行结果，而这个 block 函数就是我们调用时传入的 lambda 表达式，因此其执行结果就是整个函数的结果。而 also block 函数时返回值就是 Unit ，也就是说 lambda 表达式的结果是被忽略的。这里可以认为调用 block 真是为了执行一项操作，而实际返回是 this

再来看看为什么有时候参数是 it ，有时候又是 this 呢？ 可以对比一下 also 和 apply

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}

public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}
  • 这里的关键就是 block 函数的定义。 注意到 apply 中 block T.() -> Unit 的写法，可以看到这里明确了当前函数执行的类型，同时参数为空；可以试一下，这种情况下，定义参数是没有意义的。
1
2
3
4
public fun <T> T.apply1(block: T.(Int) -> Unit): T {
    block(1)
    return this
}

比如这里，虽然定义了 block 的参数为 Int 类型，但是因为应明确定义了 block 函数是在 T 类型执行，因此实际调用时也无法传递这个参数，因此这里实现时也无法获取到具体的参数值 。

可以看到，内置函数这几个非常使用的顶层函数的实现还是很有参考价值，我们在平时自己创建顶层函数的时候，可以参考这些实现。 Standard.kt 中还包括 takeIf() takeUnless repeat 这几个函数，实现和含义较为简单，就不展开说了。

tobe continued …

  • 扩展函数
  • object 单例
  • 高阶函数
  • 协程（mabye?)
加个鸡腿呗.