Kotlin-apply、also、run、let、区别

2022-04-21 1,464 阅读4分钟

apply、also介绍

两者都是T的扩展函数，也就是任何类型对象都调用apply、also；
两者的返回值都是this，也就是函数调用者；
apply的闭包使用this来访问函数调用者，also的闭包使用it来访问函数的调用者。

一看看apply、also源码

public inline fun <T> T.apply(block: T.() -> Unit): T {//1
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()//2
    return this//返回值为this，也就是apply的调用者
}

public inline fun <T> T.also(block: (T) -> Unit): T {//3
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)//4
    return this 返回值为this，也就是also的调用者
}

注释1：apply接受的闭包类型为T.() -> Unit，也就是调用者的扩展函数，例子tv.apply{}，闭包{}为tv的扩展函数，所以this可以访问到调用者；
注释2：直接调用闭包，完成apply的逻辑；
注释3：also接受的闭包类型为 (T) -> Unit，也就是任意函数，只要函数入参类型为also调用类型返回为Unit都可以；
注释3：把this作为闭包的参数传入，例子tv.also{}，闭包的入参为tv，所以it能访问到tv；
apply this可以访问调用者本身，因为闭包是扩展函数，而also用it访问调用者本身，因为调用者是作为参数传入闭包的。

apply、also适用场景

因为返回值为调用者this，所以它们非常适合对同一个对象连续操作的链式调用。以下代码以apply为例，链式调用对tv进行一系列操作。注意：例子不一定合理，只是想表达相应的意思而已。

    private fun init() {
        val tv = TextView(this)
        tv.apply {
            this.text = "name" //操作1
        }.apply {
            this.setOnClickListener { //操作2
                Log.d("MainActivity", "setOnClickListener")
            }
        }.apply {
            this.gravity = Gravity.CENTER //操作3
        }
    }

run、let介绍

两者都是T的扩展函数，也就是任何类型对象都调用run、let；
两者的返回值是：最后一行非赋值代码作为闭包的返回值，否则返回Unit；
run的闭包使用this来访问函数调用者，let的闭包使用it来访问函数的调用者。

一起看看 run、let源码

public inline fun <T, R> T.run(block: T.() -> R): R {//1
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()//2
}

public inline fun <T, R> T.let(block: (T) -> R): R {//3
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)//4
}

注释1：run接受的闭包类型为T.() -> Unit，也就是调用者的扩展函数，this可以访问到调用者，这点跟apply一样；
注释2：直接调用闭包，将闭包的返回值返回；
注释3：let接受的闭包类型为block: (T) -> Unit，也就是任意函数，只要函数入参类型为also调用者类型返回为Unit都可以；
注释4：直接调用闭包，将this作为参数传入闭包；
run this可以访问调用者本身，因为闭包是扩展函数，而let用it访问调用者本身，因为是作为参数传入闭包。

run、let适用场景

它们都可以有返回值，所以非常适合上一个操作返回值作用于下一个操作的链式调用。以下代码以let为例，操作1返回值作用于操作2，操作2返回值作用于操作3。注意：例子不一定合理，只是想表达相应的意思而已。

    private fun init(data: Int): Int {
        return data.let {
            if (data == 1) it + 1 else it + 2 //操作1
        }.let {
            if (data == 2) it + 3 else it + 4 //操作2
        }.let {
            if (data == 3) it + 5 else it + 6 //操作3
        }
    }

作用函数更重要的作用

确保操作的作用域，以下代码确保tv不为空的情况下执行，保证操作的作用域。

        val tv = TextView(this)
        tv?.apply {
            text = count.toString()
            setOnClickListener {
                Log.d("MainActivity", "setOnClickListener")
            }
            gravity = Gravity.CENTER
        }

为什么有的用this访问调用者，有的则用it?

前面分析源码的时候可以看到，

apply、run接收的闭包类型为调用者的扩展函数，既然是扩展函数，那么当然是用this来访问调用者；
also、let接受的闭包类型为任意类型的函数，只要函数入参类型为调用者类型返回为Unit都可以，既然是参数，那么就能用不能用this来访问，就得用其他字符来访问，定义it来访问也未尝不可；

总结

apply、also，闭包的返回值都是this，前者apply接受的闭包类型调用者的扩展函数，后者接受的闭包类型为入参为调用者类型的函数；
also、apply，非常适合对同一个对象连续操作的链式调用；
run、let，闭包的返回值为最后一行非赋值代码，前者run接受的闭包类型调用者的扩展函数，后者接受的闭包类型为入参为调用者类型的函数；
run、let，非常适合上一个操作返回值作用于下一个操作的调用；

以上分析有不对的地方，请指出，互相学习，谢谢哦！