Kotlin 作用域函数 let 的实现原理

发表于 更新于 分类于 ，

Kotlin 中的 let 是一个 标准库扩展函数，它广泛用于作用域函数（Scope Functions）中，尤其适用于对可空对象（nullable）做非空判断并执行代码块的场景。

示例代码

1
2
3
4
val name: String? = "123"
name?.let {
    println(it)
}

这个例子等价于：

1
2
3
4
if (name != null) {
    val it = name
    println(it)
}

也就是说，name?.let { ... } 只有当 name 非空时才执行 let 的 lambda 块。lambda 表达式中 it 就是 name 的非空值。let 返回 lambda 的返回值。

实现原理

Kotlin 的 let 函数定义在 commonMain/kotlin/util/Standard.kt 中，源码如下：

1
2
3
4
5
6
7
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

它是一个 内联（inline）函数，在编译时会被内联展开，避免 lambda 带来的性能开销。泛型 <T, R> 表示接收一个类型为 T 的对象，返回一个类型为 R 的结果。T.let 表示 let 是类型 T 的扩展函数。block: (T) -> R 是接收 T 的函数（lambda 表达式）。也就是说，它只是将当前对象 this 传入了 block(this) 中。

@kotlin.internal.InlineOnly，这是一个 注解（Annotation），用于标记某个函数 只能在被 inline（内联）时使用，否则编译器会报错。

比如下面的代码：

1
2
3
4
@InlineOnly
inline fun <T> T.let(block: (T) -> Unit): Unit {
    block(this)
}

表示这个 let 函数 不会生成实际函数调用（它只能内联展开），避免 Java 或非 Kotlin 编译器调用这个方法。

为什么要限制只能 inline？为了提高性能，避免生成函数对象和调用开销，同时 确保代码安全地被内联使用，防止其他模块通过反射或 Java 调用这个方法。

1
2
3
contract {
    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}

这是Kotlin 的 Contract DSL，用于 给编译器更多关于 lambda 执行行为的信息，提升智能分析、空安全和优化。表示block 这个 lambda 参数，在函数调用过程中会 被调用且只调用一次（Exactly once）。这使得编译器可以进行一些静态分析优化，例如在下面这种空检查中，判断 name 非空：

1
2
3
4
5
val name: String? = "abc"
name?.let {
    // 编译器知道这里 it 一定非空，不会再要求你加 !!
    println(it.length) // 安全
}

InvocationKind 类型说明：

  • EXACTLY_ONCE：block 会被调用且仅一次
  • AT_LEAST_ONCE：一定会调用一次或多次
  • AT_MOST_ONCE：最多一次，可能不调用
  • UNKNOWN：不确定

编译器依靠这个信息进行控制流分析，提升非空智能推断、性能优化、检测死代码等能力。

R 是泛型返回类型。

1
2
3
inline fun <T, R> T.let(block: (T) -> R): R {
    return block(this)
}

<T, R> 是泛型声明，T是调用 let 的对象类型（接收者），R是block 函数返回值的类型，也是 let 函数的最终返回值类型。

举例：

1
2
val name = "abc"
val length: Int = name.let { it.length } // block 返回 Int，所以 R = Int

也可以是任意类型：

1
2
val upper = "abc".let { it.uppercase() } // R = String
val printResult = "abc".let { println(it) } // R = Unit

编译后字节码

比如：

1
2
3
4
val name: String? = "123"
name?.let {
    println(it)
}

大致翻译成 Java 是：

1
2
3
4
String name = "123";
if (name != null) {
    System.out.println(name);
}

编译器把 ?.let { ... } 直接转成了 if != null 的判断。lambda 是内联展开的，不会有额外函数对象生成，所以效率非常高。

常见用途

处理 nullable 类型：

1
2
3
4
val name: String? = getName()
name?.let {
    println("非空值是：$it")
}

链式调用：

1
2
3
val result = listOf(1, 2, 3).map { it * 2 }.let {
    it.joinToString()
}

限定作用域变量（避免变量污染）：

1
2
3
4
5
6
val userInput = readLine()
userInput?.let {
    val trimmed = it.trim()
    println("你输入的是：$trimmed")
}
// trimmed 在此作用域外不可见