Kotlin标准库函数

1.apply 函数

apply函数可以看做是一个配置函数。针对apply函数的调用者做一些配置，并把调用者返回。

示例：下面apply的调用者是file，调用完之后，返回的还是file，并在apply函数中，针对file做了一些配置。

    val file = File("d:\\hello.txt").apply {
        setWritable(true)
        setReadable(true)
        setExecutable(false)
    }

apply源码分析：

1）apply 用inline修饰，是一个内联函数。

2）定义了一个<T>泛型，T.apply 调用者就是T，：T apply返回的类型也是T

上面的file就相当于T

3）再看apply的参数：block: T.() -> Unit。这是一个匿名函数，T.（）->说明接收的是T的函数返回的是Unit类型。

4）在apply内部 调用了这个匿名函数block（）也就是T的

5）return this，就是apply 的返回值，返回的是当前调用apply函数的对象。

public inline fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}

2.let 函数

let函数会把调用者作为参数传到lambda表达式里，可以用it来代替它使用。函数执行完毕，lambda表达式返回的结果，就是let函数返回的结果。

    val hello = "Hello world".let {
        it.replace("world","kotlin")
    }
    //打印结果 Hello kotlin
    println(hello)

看下let函数的定义:

1)let函数也是一个内联函数。

2）定义了两个泛型<T,R> T.let()，说明T是let的调用者。

3）block: (T) -> R 说明let接收的是一个匿名函数，匿名函数的参数是T，返回值是R

4）: R 说明let函数的返回在也是R，也就是定义的匿名函数的返回值。

5）return block(this) 把当前调用者当做参数传进来，lambda执行结果返回

上面的示例，调用let后，会把调用者当做参数传递到匿名函数也就是lambda中，并把lambda的执行结果，当做是let的结果返回。

inline fun <T, R> T.let(block: (T) -> R): R {
    return block(this)
}

3.run函数

run函数和apply差不多，可以给调用者做配置。唯一的差别是apply返回的是当前调用者对象，而run返回的是lambda执行的结果。

    val text = File("d:\\hello.txt").run {
        setWritable(true)
        setReadable(true)
        setExecutable(false)
        readText()
    }
    println(text)

run函数分析：

1）run函数也是一个内联函数。

2）有两个泛型<T,R>,T是当前调用者，R是返回值

3）run接收一个lambda ：block: T.() -> R 调用T的方法，并且把执行结果返回

4）: R lambda的执行结果，就是run函数的执行结果。我们知道lambda默认会把最后一行的结果返回。

5）return block() 返回lambda的执行结果

inline fun <T, R> T.run(block: T.() -> R): R {
    return block()
}

4.with 函数

with函数是run的变体，他们的功能是一样的。唯一的不同是调用方式，调用with时，第一个参数需要传入一个值参。

    val hello = "Hello World"
    val h2 = with(hello) {
        replace("World", "Kotlin")
    }
    println(h2)

源码分析：

with接收两个参数，第一个是传入的值参，第二个是一个lambda表达式。

inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    return receiver.block()
}

5.also

also函数和let函数类似，also也是把调用者作为参数传递给lambda，不同点是let返回的是lambda的执行结果，而also返回的是当前调用者对象，这点和apply类似。

这对这个特点，可以实现调用者的链式调用。

举个简单列子。

虽然对hello做了substring，但并不会改变hello的初始值。因为最后返回的还是调用者对象本身。

    val hello = "Hello world".also {
        println(it.count())
    }.also{
        println(it.substring(0,5))
    }
    println(hello)

源码分析：

block: (T) -> Unit also接收一个lambda，这个lambda把调用者T当参数传进来了，block(this)。

return this 又把当前对象返回回去了。

inline fun <T> T.also(block: (T) -> Unit): T {
    block(this)
    return this
}

6.takeIf

takeIf需要判断lambda表达式中结果，如果true则返回调用者对象，如果是false，则返回null。

如果需要判断某个条件是否满足，再决定是否可以给变量赋值或执行某项任务时，takeIf就很好用。takeIf类似于if语句。

示例：如果flag为true，则给hello赋值“Hello world”。

如果flag为false，则返回null，但是后面又有一个?:判断，就会给hello赋值“hello null”

    var flag = false
    val hello = "Hello world".takeIf { false } ?: "hello null"
    println(hello)

源码分析：

从if (predicate(this)) this else null可以看出，如果predicate(this)为true则返回调用者this否则返回null

 inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
    return if (predicate(this)) this else null
}

通过源码分析，takeIf也会把调用者T当做参数传到lambda中，这样我们在lambda中就可以针对调用者做判断，满足某些条件则返回调用者对象，如果不满足，则返回null。

    val hello = "Hello world".takeIf {
        it.count() > 15
    } ?: "hello kotlin world"
    println(hello)

7.takeUnless

takeUnless刚好和takeIf相反，只有给定条件为false时，才会返回takeUnless调用者对象，否则返回null。

    val hello = "Hello world".takeUnless {
        it.count() > 15
    } ?: "hello kotlin world"
    println(hello)

源码：

if (!predicate(this)) 刚好和takeIf中的相反。

inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
    return if (!predicate(this)) this else null
}