kotlin内置函数的总结

内置函数的总结：

apply

info.apply

1. apply 函数返回类型，永远都是info本身
2. apply 函数的 匿名函数里面持有的是this == info本身 此条和 run 一模一样

let

name.let

1. let 函数返回类型，是根据匿名函数最后一行的变化而变化 此条和 run 一模一样
2. let 函数的 匿名函数里面持有的是it == name本身

run: str.run

1. run 函数返回类型，是根据匿名函数最后一行的变化而变化 此条和 let 一模一样
2. run 函数的 匿名函数里面持有的是this == str本身 此条和 apply 一模一样

with

with(str) with和run基本上一样，只不过就是使用的时候不同

1. with 函数返回类型，是根据匿名函数最后一行的变化而变化 此条和 let 一模一样
2. with 函数的 匿名函数里面持有的是this == str本身 此条和 apply 一模一样

also

str.also

1. also 函数返回类型，永远都是str本身 此条和 apply 一模一样
2. also 函数的匿名函数里面持有的是it == str 此条和 let 一模一样

takeIf

takeIf一般与空合并操作符（?:）搭配使用
name.takeIf{true/false}
true:直接返回name本身
false:直接返回null

takeUnless

takeUnless + it.isNullOrBlank() 一起使用，可以验证字符串有没有初始化等功能
name.takeUnless{true/false}
false:直接返回name本身
true:直接返回null

let内部源码原理分析

//1. let的返回类型是 根据匿名函数lambda的变化而变化
//2. 匿名函数里面持有的是it == I
inline fun<I, O> I.let(lambda : (I) -> O) : O = lambda(this)

重写let匿名函数

//参数说明
//private：私有化
//inline：因为函数是高价函数，需要使用内联对lambda进行优化处理，提供性能
//fun<I, O>：在函数中，申明两个泛型，函数泛型 I表示输入参数，O表示输出结果
//I.mLet：对I输入进行函数扩展，扩展函数的名称是mLet，所有的类型都可以用***.mLet
//lambda : (I) -> O：（I输入参数）->O输出
//O：会根据用户的返回类型变化而变化
//lambda(this)：I进行函数扩展，在整个扩展函数里面，this==I
private inline fun<I, O> I.mLet(lambda : (I) -> O) : O = lambda(this)

apply内部源码原理分析

//1. apply的返回类型是 永远都是I（所以可以链式调用）（lambda的返回类型 无法改变，写的是Unit，并且 没有和lambda关联返回类型）
//2. 匿名函数里面持有的是 this == I
inline fun<I> I.apply(lambda: I.() -> Unit) : I {
    lambda()
    return this
}

重写apply匿名函数

//参数说明
//private：私有
//inline：因为函数是高价函数，需要使用内联对lambda进行优化处理，提供性能
//fun<INPUT>：函数中声明一个泛型
//INPUT.mApply：让所有的类型，都可以 ***.mApply  泛型扩展
//INPUT>()->Unit：让匿名函数里面持有this，在lambda里面不需要返回值，，因为永远都是返回INPUT本身
//lambda(this)：默认就有this
//返回this 的目的是可以链式调用
private inline fun<INPUT> INPUT.mApply(lambda : INPUT.() -> Util) : INPUT {
    lambda() //或者lambda(this)
    return this
}