Kotlin let，apply

1. let 标准函数

let是一个扩展函数，它接受一个lambda表达式作为参数。这个lambda表达式接受一个类型为T的参数，并返回一个类型为R的结果。

1. let 函数主要配合 .? 操作符来辅助配合判断处理。
2. 主体中 可以使用 it 代替
3. lambda 表达式中最后一行表示返回值
4. let是一个扩展函数

    var list = listOf(1,2,3)
    var value =  list.let {
        it[1]
        it[2]
    }
    println("list[2]= $value")
    //输出：list[2]= 3

2. with 函数

with 函数接收两个参数：第一个是任意类型的对象，第二个是一个lambda 表达式

1. with 函数不需要对象可以直接调用
2. lambda 表达式中 持有 with 第一个参数的上下文
3. lambda 表达式中最后一行表示返回值
4. with 函数是一个顶层函数，

 var list = listOf(1, 2, 3)

var value2 = with(list) {
        //这里是 list 的上下文,所以可以省略 list 对象直接调用 list 的方法
        var s =size
        println("list size = $s")
        list[1]
        //最后一个作为返回值
        list[0]
    }
println("value2= $value2")
var value3 = with(StringBuffer()) {
    //这里是 StringBuffer 的上下下文,所以可以省略 StringBuffer 对象直接调用 StringBuffer 的方法
    append("遍历 list= ")
    list.forEach {
        append(" ${it} ,")
    }
    toString()//作为返回值
}
println("value3= $value3")
// 打印结果：
// list size = 3
// value2= 1
// value3= 遍历 list=  1 , 2 , 3 ,

3. run 函数

run 函数是kotlin 标准库中一个高阶函数，他接受一个lambda 表达式作为参数，并在该lambda表达式的上下文中执行操作，

1. run 函数调用需要一个对象
2. lambda表达式中 持有调用者的 上下文
3. lambda表达式中 最后一个行做为返回值返回
4. run 函数时对象的扩展函数

var runValue= list.run {
        //这里是 list 的上下文，所以可以省略 list 对象直接调用 list 的方法
        size//最后一行作为返回值
    }
println("runValue= $runValue")
var sb = StringBuffer()
var runSbValue =  sb.run {
    append("run 函数遍历 list= ")
    list.forEach {
        append(" $it ,")
    }
    toString()
}
println("runSbValue= $runSbValue")
// runValue= 3
// runSbValue= run 函数遍历 list=  1 , 2 , 3 ,

4. apply 函数

apply函数通常用于对对象进行配置或初始化操作，它会返回被操作的对象本身。在 apply 的 lambda 表达式中，可以直接访问和修改对象的属性

1. apply 函数调用需要一个对象
2. lambda表达式中 持有调用者的 上下文
3. 返回调用者对象
4. apply是一个扩展函数

var mutablist = mutableListOf(1, 2, 3)
var mutableList2 = mutablist.apply {
    //这里是 mutablist 的上下文，所以可以省略 mutablist 对象直接调用 mutablist 的方法
    size
    mutablist[2] = 5
}
println("mutablist == mutableList2  = ${mutablist == mutableList2}")
println("mutablist === mutableList2  = ${mutablist === mutableList2}")
println("mutablist  = ${mutablist}")
println("mutableList2  = ${mutableList2}")

val beans = mutableListOf(TestBean("AA"), TestBean("BB"), TestBean("CC"))
beans.apply {
    //这里是 beans 的上下文，所以可以省略 beans 对象直接调用 beans 的方法
    //最后一行不是返回值，apply 函数返回的是this ，即 调用者对象
    size
    beans[2].name = "DD"
}
println("beans  = ${beans}")
//输出结果
// mutablist == mutableList2  = true
// mutablist === mutableList2  = true
// mutablist  = [1, 2, 5]
// mutableList2  = [1, 2, 5]
// beans  = [AA, BB, DD]
// beans == beans2  = true
// beans2 === beans  = true

5. 定层函数和扩展函数

5.1 顶层函数

顶层函数是定义在Kotlin文件的顶层（即不在任何类或对象内部）的函数。这些函数是全局可访问的，可以直接调用。

// 顶层函数  
fun sayHello(name: String): String = "Hello, $name!"  
  
fun main() {  
    println(sayHello("Kotlin")) // 输出: Hello, Kotlin!  
}

5.2 扩展函数

扩展函数是Kotlin中一个非常强大的特性，它允许你为已存在的类添加新的方法,调用时需要 一个对象

// 为String类添加扩展函数  
fun String.repeatWithSeparator(separator: String, times: Int): String {  
    if (times <= 1) return this  
    return joinToString(separator, prefix = this, postfix = this, limit = times - 1)  
}  
  
fun main() { 
var obj = "Kotlin" 
    println(obj.repeatWithSeparator(", ", 3)) // 输出: Kotlin, Kotlin, Kotlin  
}