Kotlin 中的内联函数：是什么、语法和应用

Kotlin 中的内联函数是什么？

内联函数是用 inline 关键字标记的函数。Kotlin 编译器不会为其创建单独的带有调用的字节码，而是将函数体直接复制到每个调用位置。主要目标 — 优化接受 lambda 表达式的高阶函数，因为每个 lambda 在正常情况下都会创建 Function 类的匿名对象。

根据 JetBrains Tech Blog (2024)，在 Kotlin 中使用内联函数可以在密集使用 lambda 的函数中将创建的对象数量减少 40–60%。在循环和高负载操作（排序、集合过滤）中，这带来了可测量的性能提升。

没有内联，每个 lambda 都会被编译成一个匿名类（或合成函数接口的实例）。对于捕获变量的 lambda，会创建额外的包装器对象。内联函数在编译阶段消除所有这些对象，用直接访问局部变量而无包装器的代码替换它们。

只对带有 lambda 参数的函数使用 inline — Kotlin 编译器会在 inline 没有优势时自行发出警告。

内联函数的语法和工作机制

只需在函数声明前添加 inline 关键字。编译器会自动将函数体插入到调用位置。函数本身在字节码中继续存在，用于非直接调用的情况（例如，从 Java 代码调用）。

inline fun Int.repeatAction(action: (Int) -> Unit) {
    for (i in 0 until this) {
        action(i)
    }
}

// 调用 — lambda 代码被内联到函数体中
5.repeatAction { index ->
    println("Index: $index")
}

编译后，上述代码将等价于：

// 内联后发生什么（示意）：
val $this = 5
for (i in 0 until $this) {
    println("Index: $i")
}

不会为 lambda 创建任何对象 — action 代码直接执行。这就是优化的本质：不是调用 Function.invoke()，而是直接插入带有 lambda 体的代码。

通过反编译检查

要检查内联，请在 IntelliJ IDEA 中打开 Tools > Kotlin > Show Kotlin Bytecode，然后点击 Decompile。您将看到，不是使用 lambda 调用 repeatAction，而是生成了带有 for 循环的函数体的直接插入。

Lambda 开销问题及其解决方案

Kotlin 中的每个 lambda 被编译为三种变体之一。第一种 — 如果 lambda 不捕获变量，它变成声明它的类的静态方法。第二种 — 如果捕获一个变量，则创建匿名类。第三种 — 如果捕获多个变量，则创建带有每个捕获变量字段的匿名类。

根据 Android Performance Patterns (Google, 2024)，在密集使用集合的应用程序中（过滤、排序、分组），内联函数将分配数量减少 25–35%。该效果在 Jetpack Compose 中尤为明显，其中每次状态变化都会导致使用多个 lambda 重新组合。

Nonlocal return 和限制

普通函数中的 lambda 不能从外部函数执行 return — 只能从 lambda 本身执行局部 return（通过 return@label）。在内联函数中，lambda 被插入到调用函数的体中，因此nonlocal return 成为可能：lambda 内部的 return 结束外部函数。

inline fun findFirst(
    items: List<Int>,
    predicate: (Int) -> Boolean
): Int {
    for (item in items) {
        if (predicate(item)) {
            return item
        }
    }
    return -1
}

fun processNumbers() {
    val numbers = listOf(1, 2, 3)
    val firstEven = findFirst(numbers) { it % 2 == 0 }
    // lambda 中的 return 将从 processNumbers() 返回 null
}

Nonlocal return 便于提前终止，但可能导致错误。如果 lambda 在非局部上下文中使用（保存在变量中），nonlocal return 将导致 RuntimeException。Kotlin 编译器会在此类保存尝试时发出警告。

noinline 和 crossinline：管理内联

当一个函数有多个 lambda 参数时，有时只需要内联其中一部分。为此使用 noinline — 禁止特定 lambda 参数的内联，将其保留为普通 Function 对象。

crossinline 修饰符解决相反的问题：lambda 被内联，但禁止 nonlocal return。当 lambda 在另一个 lambda 内部或在不允许 return 的上下文中使用时（例如，传递给 Runnable），这是必需的。

inline fun processWithCallback(
    data: String,
    crossinline onSuccess: (String) -> Unit,
    noinline onError: (Exception) -> Unit
) {
    try {
        val result = process(data)
        onSuccess(result)
    } catch (e: Exception) {
        onError(e)
    }
}

// noinline：onError 可以存储在变量中或传递到其他地方
val errorHandler = { e: Exception -> log(e.message) }
processWithCallback("input", { println(it) }, errorHandler)

在示例中，onSuccess 被标记为 crossinline — 将被内联，但内部不能使用 return。onError 被标记为 noinline — 不被内联，可以作为对象传递、保存在类字段中或用作 listener。

内联函数的限制和建议

内联函数有限制。递归内联函数被禁止 — 编译器将报错。如果内联函数在另一个模块中声明，则不能具有 private 或 internal 可见性，但这个限制与访问有关，与内联机制本身无关。

字节码大小随着每次内联函数调用而增长，因为函数体被复制。根据 Kotlin Coding Conventions (JetBrains, 2025)，建议仅对大小为 10–15 行的函数使用 inline。对于大型函数，lambda 内联带来的好处可能被 APK 大小的增加所抵消（在 Android 中这很关键 — 存在 64K 方法限制）。

// 推荐做法
inline fun withLock(lock: Lock, action: () -> T): T {
    lock.lock()
    try {
        return action()
    } finally {
        lock.unlock()
    }
}

// 不建议用于大型函数
inline fun largeComputation(...) { // 不好 — 函数体 >50 行
    // 超过 50 行 — 最好提取到普通函数中
}

库中的公共内联函数需要谨慎：如果内联函数体发生变化，所有客户端都必须重新编译。JetBrains 建议对从内联函数调用的成员使用 @PublishedApi internal，以保持模块内的兼容性。