函数

// 基本函数定义
fun add(a: Int, b: Int): Int {
    return a + b
}

// 单表达式函数，可以省略花括号和 return
fun add2(a: Int, b: Int) = a + b

// 无返回值的函数，返回类型是 Unit（可省略）
fun printMessage(msg: String) {
    println(msg)
}

// 默认参数
fun greet(name: String, prefix: String = "你好") {
    println("$prefix，$name")
}

// 命名参数
greet(name = "张三", prefix = "早上好")
greet(name = "李四")  // 使用默认参数

// 扩展函数
fun String.addPrefix(prefix: String) = "$prefix$this"
val result = "世界".addPrefix("你好，")  // "你好，世界"

// 中缀函数
infix fun Int.times(str: String) = str.repeat(this)
val result2 = 3 times "嗨"  // "嗨嗨嗨"

// 高阶函数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}
val sum = calculate(5, 3) { x, y -> x + y }

inline fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    val end = System.currentTimeMillis()
    println("耗时：${end - start}ms")
    return result
}

// 给 String 类添加一个扩展函数
fun String.addSuffix(suffix: String): String {
    return this + suffix  // this 指向调用对象
}

// 使用扩展函数
val result = "你好".addSuffix("，世界")
println(result)  // 输出：你好，世界

// 给 Int 添加扩展函数，判断是否为偶数
fun Int.isEven(): Boolean = this % 2 == 0

println(10.isEven())  // true
println(7.isEven())   // false

// 给 List 添加扩展函数，获取第二个元素
fun <T> List<T>.secondOrNull(): T? {
    return if (this.size >= 2) this[1] else null
}

val list = listOf("a", "b", "c")
println(list.secondOrNull())  // b

class MyClass {
    fun foo() { println("成员函数") }
}

fun MyClass.foo() { println("扩展函数") }

MyClass().foo()  // 输出：成员函数

fun String?.isNullOrEmpty2(): Boolean {
    return this == null || this.isEmpty()
}

val str: String? = null
println(str.isNullOrEmpty2())  // true，不会抛异常

// 接收函数作为参数的高阶函数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 使用高阶函数
val sum = calculate(5, 3) { x, y -> x + y }
val product = calculate(5, 3) { x, y -> x * y }
println(sum)      // 8
println(product)  // 15

// 返回函数的高阶函数
fun makeMultiplier(factor: Int): (Int) -> Int {
    return { num -> num * factor }
}

val double = makeMultiplier(2)
val triple = makeMultiplier(3)
println(double(5))  // 10
println(triple(5))  // 15

// 函数类型的变量
val sum: (Int, Int) -> Int = { a, b -> a + b }

// 无参数的函数类型
val sayHello: () -> Unit = { println("Hello") }

// 接收函数类型的函数类型（高阶的高阶函数）
val higherOrder: ((Int) -> Int) -> Int = { func -> func(10) }

// 完整写法
list.filter({ item -> item > 5 })

// Lambda 在括号外
list.filter() { item -> item > 5 }

// 省略空括号
list.filter { item -> item > 5 }

// 使用 it
list.filter { it > 5 }

inline fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    val end = System.currentTimeMillis()
    println("耗时：${end - start}ms")
    return result
}

// 调用时，代码会被内联，没有额外开销
measureTime {
    // 一些耗时操作
}

// 简化的点击监听
button.setOnClickListener { view ->
    println("点击了")
}

// 协程
launch {
    val result = async { fetchData() }
    updateUI(result.await())
}

// Compose UI
Column {
    Text("标题")
    Button(onClick = { /* 点击事件 */ }) {
        Text("按钮")
    }
}

// 定义一个复用的函数对象（仅创建一次）
private val ADD_OPERATION: (Int, Int) -> Int = { a, b -> a + b }

// 普通高阶函数（非 inline）
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 调用处（高频循环）
fun main() {
    // 循环 1000 次，复用同一个 ADD_OPERATION 对象，仅创建 1 次闭包
    repeat(1000) {
        val result = calculate(10, 20, ADD_OPERATION)
        println(result)
    }
}

class Calculator(private val base: Int) {
    // 延迟创建，且仅创建一次（捕获了 base 变量）
    private val multiplyOperation by lazy { (num: Int) -> num * base }

    fun compute(num: Int): Int {
        // 每次调用都复用同一个 multiplyOperation 对象
        return process(num, multiplyOperation)
    }

    private fun process(num: Int, op: (Int) -> Int): Int {
        return op(num)
    }
}

// 定义普通函数
fun add(a: Int, b: Int): Int {
    return a + b
}

// 高阶函数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    // 方式1：匿名 lambda（每次创建新闭包）
    repeat(1000) {
        calculate(10, 20) { a, b -> a + b }
    }

    // 方式2：函数引用（复用预定义对象，无新闭包创建）
    repeat(1000) {
        calculate(10, 20, ::add)
    }
}

// 定义函数式接口（仅一个抽象方法）
fun interface Operation {
    fun execute(a: Int, b: Int): Int
}

// 高阶函数接收函数式接口参数
fun calculate(a: Int, b: Int, operation: Operation): Int {
    return operation.execute(a, b)
}

fun main() {
    // SAM 转换：自动创建接口实现类（仅创建一次，若复用则无额外开销）
    val addOperation = Operation { a, b -> a + b }
    
    // 高频调用，复用同一个接口实例
    repeat(1000) {
        calculate(10, 20, addOperation)
    }
}

fun badExample() {
    val base = 10 // 外部变量
    // lambda 捕获 base，闭包对象会持有 base 的引用
    val operation = { num: Int -> num + base }
    repeat(1000) { calculate(it, 20, operation) }
}

// 无状态函数，不捕获任何外部变量
fun addWithBase(num: Int, base: Int): Int {
    return num + base
}

fun goodExample() {
    val base = 10
    // 把外部变量作为参数传入，而非让 lambda 捕获
    repeat(1000) { calculate(it, 20) { a, b -> addWithBase(a, base) } }
}

fun collectionExample() {
    val list = (1..10000).toList()
    // 每一步都创建新集合 + 新闭包，性能差
    val result = list.filter { it % 2 == 0 }
                     .map { it * 10 }
                     .sum()
}

fun sequenceExample() {
    val list = (1..10000).toList()
    // 仅在 sum() 时执行，全程无中间集合，闭包复用
    val result = list.asSequence()
                     .filter { it % 2 == 0 }
                     .map { it * 10 }
                     .sum()
}