常用函数

with

可以用它对同一对象执行多次操作，而不需要反复把名字写出来

1. 第一个参数为一个对象，第二个参数为一个 lambda 表达式。with 会把第一个参数传递到表达式中，在表达式中使用 this 引用第一个参数，进而调用其中的方法、属性（也可以省略 this)。

   表达式中调用函数，就像在这个对象内部一样。

   fun test() = with(StringBuilder()){
       println(this.javaClass) // class java.lang.StringBuilder
       append("xxx")
       println(this.toString()) // xxx
   }
   

   调用 append() 函数时，省略了 this；调用 toString() 时没有省略 this。

2. 当做为参数传递给表达式的类，和使用 with 函数的类有第名方法时，this 依旧表达式接收的实例，使用 [email protected] 指使用 with 的类

   fun main(args: Array<String>) {
       Demo().test() // 先输出 demo，再输出 with
   }
   
   class Demo{
       fun append() = println("demo")
       fun test() = with(StringBuilder()){
           this.append("with")
           [email protected]()
           println(toString())
       }
   }
   

   Demo 类中与 StringBuilder 类中都定义有 append()，使用 this 或省略指代 SB
   实例，而使用 [email protected] 指代 Demo 类中的方法。

---

apply

与 with 类似，除了 apply 会返回作为实参传递给它的对象。

apply 主要用于 在给定的实参上进行一系列的操作，而且它是一个扩展函数。

fun main(args: Array<String>) {
    println(create("--")) // --xxxx
}

fun create(init:String) = StringBuilder(init).apply {
    this.append("xxxx")
}.toString()

---

let

将调用它的对象变成 lambda 表达式的参数。结合安全调用语法，可以有效地避免空指针异常

调用者不为空时，执行表达式；否则不执行，并返回 null。

fun main(args:Array<String>){
    var name:String?
    name = null
    name?.let { println(it) } // 不报错，而且 lambda 不执行
    name = "xxx"
    name?.let { println(it) } // 输出 xxx
}

---

compareValuesBy

对不同的对象按不同的值依次进行比较

如：

class Test(val x: Int, val y: Int) : Comparable<Test> {
    override fun compareTo(other: Test): Int {
        return compareValuesBy(this,other,{t: Test -> t.x },Test::y)
    }
}

调用 compareTo 时，首先会按 x 属性值进行比较。如果结果不同，则直接返回；如果相等，则比较下一个 lambda 表达式的值（这里使用的是声明引用），即 y 属性的值。直到遇到返回结果不相等，或 lambda 结果。

当 lambda 结束时，整个比较结果返回 0。

---

lazy 函数

1. lazy 函数返回一个对象，该对象具有一个 getValue 且签名正确的方法。因此可以使用 lazy 函数与 by 一起创建一个委托属性。

2. lazy 参数是一个 lambda 表达式，可以调用它初始化这个值。

3. lazy{} 只能用于 val 变量，当变量第一次被访问时才使用 lambda 进行初始化。

fun main(args: Array<String>) {
    val d = Demo() // 不会输出 lazy，只有当使用 d.a 的时候才会输出
}

class Demo {
    val a: Int by lazy {
        println("lazy")
        1
    }
}