Kotlin 函数机制深度剖析

在 Kotlin 中，函数是一等公民，其设计不仅涵盖了传统面向对象语言的方法特性，还融入了大量函数式编程的优雅语法。以下将从基础定义到高级特性，全面梳理函数的运作机制。

基础定义与参数传递

使用 fun 关键字声明函数。Kotlin 支持丰富的参数配置，包括默认值、命名参数以及可变参数，极大地提升了 API 的灵活性和调用端的可读性。

// 基础函数定义与调用
fun calculateDiscount(price: Double, rate: Double = 0.15): Double {
    return price * (1 - rate)
}
val finalPrice = calculateDiscount(100.0)

// 默认参数在子类重写时的限制
open class BaseWorker {
    open fun execute(retries: Int = 3) { /* 基础实现 */ }
}
class NetworkWorker : BaseWorker() {
    // 重写时不允许再次指定默认值
    override fun execute(retries: Int) { /* 网络实现 */ }
}

// 命名参数提升多参数函数的可读性
fun configureRequest(
    url: String,
    method: String = "GET",
    useCache: Boolean = true,
    timeoutMs: Long = 5000
) { /*...*/ }

configureRequest(
    url = "https://api.example.com",
    useCache = false,
    timeoutMs = 10000
)

// 默认参数后跟随无默认值参数时，必须使用命名参数调用
fun processPayload(data: ByteArray, offset: Int = 0, length: Int) { /*...*/ }
processPayload(data = rawData, length = 1024)

可变参数与展开运算符

通过 vararg 修饰符，函数可以接收任意数量的同类型参数。在内部，这些参数会被编译为数组。若需要将现有数组传递给此类函数，可使用展开运算符 *。

fun mergeTags(vararg tags: String): List<String> {
    return tags.toMutableList().apply { add("default") }
}

val baseTags = arrayOf("kotlin", "jvm")
// 使用 * 展开数组，并混合普通参数
val allTags = mergeTags("android", *baseTags, "multiplatform")

// 对于基本类型数组，需要先转换为包装类型数组
val numbers = intArrayOf(1, 2, 3)
val mergedNumbers = mergeTags("start", *numbers.toTypedArray(), "end")

返回值与单表达式函数

当函数不返回任何有意义的值时，其返回类型为 Unit，且该声明可以省略。对于仅包含单个表达式的函数，可以省略花括号和 return 关键字，直接使用 = 连接表达式，此时返回类型通常可由编译器自动推断。

// Unit 返回类型可省略
fun logMessage(message: String?) {
    if (message != null) println("Log: $message")
}

// 单表达式函数，自动推断返回类型为 Int
fun getSquare(x: Int) = x * x

中缀表示法与局部函数

中缀函数允许以类似自然语言的方式调用，适用于构建领域特定语言（DSL）。局部函数则有助于封装复杂逻辑，避免类命名空间污染，并能作为闭包捕获外部变量。

// 中缀函数定义与调用
infix fun String.shouldStartWith(prefix: String): Boolean = this.startsWith(prefix)
val isValid = "KotlinLang" shouldStartWith "Kotlin"

// 局部函数与闭包
fun scanDirectory(root: File) {
    val visitedPaths = mutableSetOf<String>()
    
    // 局部函数，自动捕获外部的 visitedPaths
    fun traverse(current: File) {
        if (!visitedPaths.add(current.absolutePath)) return
        current.listFiles()?.forEach { traverse(it) }
    }
    
    traverse(root)
}

尾递归优化

使用 tailrec 修饰符可以指示编译器将尾递归调用优化为循环，从而避免栈溢出（StackOverflowError），同时保持递归代码的简洁性。

// 尾递归计算阶乘
tailrec fun computeFactorial(n: Int, accumulator: Long = 1): Long =
    if (n <= 1) accumulator else computeFactorial(n - 1, accumulator * n)

// 编译器会将其优化为等效的 while 循环结构

高阶编程：高阶函数与 Lambda 表达式

高阶函数是指接收函数作为参数，或者将函数作为返回值的函数。结合 Lambda 表达式，Kotlin 提供了极其强大的集合处理和异步编程能力。

Lambda 表达式与匿名函数

Lambda 表达式是封装在花括号中的代码块，具有隐式返回最后一个表达式值的特性。匿名函数则在语法上更接近普通函数，允许显式声明返回类型，且 return 语句仅从匿名函数本身返回，而非外部调用函数。

// 自定义高阶函数
fun <T, R> Iterable<T>.accumulate(initial: R, operation: (R, T) -> R): R {
    var result = initial
    for (item in this) {
        result = operation(result, item)
    }
    return result
}

val numbers = listOf(10, 20, 30, 40)

// 使用 Lambda 表达式（最后参数可移出括号）
val totalSum = numbers.accumulate(0) { acc, next -> acc + next }

// 单参数 Lambda 可使用隐式名称 it
val doubled = numbers.map { it * 2 }

// 使用匿名函数，显式指定返回类型
val filtered = numbers.filter(fun(item): Boolean = item > 15)

// 函数引用作为参数传递
val product = numbers.accumulate(1, Int::times)

带接收者的 Lambda (Lambdas with Receivers)

带接收者的 Lambda 允许在代码块内部直接调用接收者对象的方法和属性，而无需显式使用 this 或对象名。这是 Kotlin 构建类型安全 DSL 的核心基石。

class EmailBuilder {
    var subject: String = ""
    var body: String = ""
    fun addAttachment(name: String) { /*...*/ }
}

// 定义带接收者的高阶函数
fun buildEmail(block: EmailBuilder.() -> Unit): EmailBuilder {
    val builder = EmailBuilder()
    builder.block() // 将 builder 作为接收者传递给 Lambda
    return builder
}

// 调用时，Lambda 内部上下文即为 EmailBuilder
val email = buildEmail {
    subject = "Weekly Report"
    body = "Please find the attached metrics."
    addAttachment("metrics.csv")
}

// 接收者类型与普通函数类型在特定场景下可相互转换
val configure: EmailBuilder.(String) -> Unit = { title -> subject = title }
val standardConfig: (EmailBuilder, String) -> Unit = configure