Kotlin 之 let、with、run、apply、also 函数的使用
一、内联拓展函数 let
let 扩展函数的实际上是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内，let函数的是一个不错的选择；let函数另一个作用就是可以避免写一些判断null的操作。
1.1 let 函数的使用的一般结构
object.let {
it.todo() //在函数体内使用it替代object对象去访问其公有的属性和方法
...
}
//另一种用途 判断object为null的操作
object?.let { //表示object不为null的条件下，才会去执行let函数体
it.todo()
}
1.2 let函数底层的inline扩展函数+lambda结构
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}
意思就是 T 类型的对象调用 let 方法，实际调用的是传入 let 方法的 lambda 表达式的 block 块，最终返回 lambda 表达式的返回值。
lambda 表达式内部通过 it 指代该对象。
1.3 let 函数常见的适用的场景
- 场景一: 最常用的场景就是使用let函数处理需要针对一个可null的对象统一做判空处理。
- 场景二: 然后就是需要去明确一个变量所处特定的作用域范围内可以使用
obj?.funA()
obj?.funB()
obj?.funC()
obj?.let {
it.funA()
it.funB()
it.funC()
}
二、内联函数 with
2.1 with 函数使用的一般结构
with(object) {
//todo
}
2.2 with 函数底层的inline扩展函数+lambda 结构
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return receiver.block()
}
注意，这个 with 函数不是拓展函数，它接收两个参数，第一个参数是要是用的对象，第二个参数是一个 lambda 表达式，该方法实际调用的是第一个参数对象，进行 block 块的调用,
最终返回 lambda 表达式的返回值。
lambda 表达式内部通过 this 指代该对象。
2.3 with 函数的适用的场景
适用于调用同一个类的多个方法时，可以省去类名重复，直接调用类的方法即可，经常用于Android中RecyclerView中onBinderViewHolder中，数据model的属性映射到UI上。
obj.funA()
obj.funB()
obj.funC()
with(obj) {
this.funA()
funB() // this 可省略
funC)
}
三、 内联拓展函数 run
3.1 run 函数使用的一般结构
object.run {
// todo
}
3.2 run 函数的inline+lambda 结构
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
run 函数实际上可以说是let和with两个函数的结合体，run函数只接收一个lambda函数为参数，以闭包形式返回，即返回 lambda 表达式的返回值。
3.3 run 函数的适用场景
obj?.funA()
obj?.funB()
obj?.funC()
obj?.run {
this.funA()
funB() // this 可省略
funC)
}
四、内联拓展函数 apply
4.1 apply 函数使用的一般结构
object.apply {
// todo
}
4.2 apply 函数的inline+lambda结构
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
从结构上来看apply函数和run函数很像，唯一不同点就是它们各自返回的值不一样，run函数是以闭包形式返回最后一行代码的值，而apply函数的返回的是传入对象的本身。
五、内联扩展函数 also
5.1 also 函数使用的一般结构
object.also {
// todo
}
5.2 also 函数的inline+lambda结构
public inline fun <T> T.also(block: (T) -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block(this)
return this
}
also函数的结构实际上和let很像唯一的区别就是返回值的不一样，let是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身。
六、比较总结
| 函数名 | 定义inline的结构 | 函数体内使用的对象 | 返回值 | 是否是扩展函数 |
|---|---|---|---|---|
| let | fun T.let(block: (T) -> R): R = block(this) | it指代当前对象 | 闭包形式返回 | 是 |
| with | fun with(receiver: T, block: T.() -> R): R = receiver.block() | this指代当前对象或者省略 | 闭包形式返回 | 否 |
| run | fun T.run(block: T.() -> R): R = block() | this指代当前对象或者省略 | 闭包形式返回 | 是 |
| apply | fun T.apply(block: T.() -> Unit): T | this指代当前对象或者省略 | 返回this | 是 |
| also | fun T.also(block: (T) -> Unit): T | it指代当前对象 | 返回this | 是 |
七、实用例子————Kotlin 实现单例模式
Kotlin 实现单例模式相对 java 来说很简单。比如通过 object， by lazy 操作，相信大家都会。但有时候，我们想要在单例初始化的时候顺便做一下其它初始化，极有可能会还需要传入参数。
使用 java 时，我最喜欢的实现单例模式是静态内部类的方式，但在 Android 中经常在初始化的时候需要传入 context ，然后选择了双重检查锁方式。
先看 java 代码：
public class Singleton {
private Singleton() {
}
/**
* volatile is since JDK5
*/
private static volatile Singleton sSingleton;
public static Singleton getInstance() {
if (sSingleton == null) {
synchronized (Singleton.class) {
// 未初始化，则初始instance变量
if (sSingleton == null) {
sSingleton = new Singleton();
}
}
}
return sSingleton;
}
}
再看看我们用 kotlin 实现
class Singleton private constructor(){
companion object {
@Volatile
private var instance: Singleton? = null
fun getInstance(context: Context): Singleton {
return instance?: synchronized(this) {
instance?:Singleton().also {
instance = it
}
}
}
}
}
如果要做初始化操作，我们完全可以在 also 函数里面去处理。
