这几个都是 Standard.kt 中的高阶函数，使用起来比较相似，容易混淆，下面就分析一下它们的区别和使用场景。
先看下不使用这些高阶函数的例子：
data class Person(val name: String, val age: Int) {
fun work(): String {
println("${name}正在工作...")
return "工作完成"
}
}
fun findPerson(): Person? {
return Person("JamFF", 18)
}
fun main() {
val person = findPerson()
println(person?.name) // 输出 JamFF
println(person?.age) // 输出 18
val result = person?.work() // 输出 JamFF正在工作...
println(result) // 输出 工作完成
}
一、let 函数
/**
* Calls the specified function [block] with `this` value as its argument and returns its result.
*
* For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#let).
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}
使用 let 简化：
fun main() {
val result = findPerson()?.let { person ->
println(person.name) // 输出 JamFF
println(person.age) // 输出 18
person.work() // 输出 JamFF正在工作...
}
println(result) // 输出 工作完成
Lambda 还可以简化，使用 it 代替：
fun main() {
val result = findPerson()?.let {
println(it.name) // 输出 JamFF
println(it.age) // 输出 18
it.work() // 输出 JamFF正在工作...
}
println(result) // 输出 工作完成
}
在作用域中使用 it 代替调用者，最后一行为返回值。
二、run 函数
/**
* Calls the specified function [block] with `this` value as its receiver and returns its result.
*
* For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#run).
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
对于 T.() -> R 类型不理解的可以看这里：带有接收者的函数字面值。
使用 run 简化：
fun main() {
val result = findPerson()?.run {
println(this.name) // 输出 JamFF
println(age) // 输出 18
work() // 输出 JamFF正在工作...
}
println(result) // 输出 工作完成
}
在作用域中使用 this 代替调用者（可以省略），最后一行为返回值。
还有一个重载 run 函数：
/**
* Calls the specified function [block] and returns its result.
*
* For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#run).
*/
@kotlin.internal.InlineOnly
public inline fun <R> run(block: () -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
该函数使用场景不多，看下面一个例子：
fun foo() {
val age = 42
val result = run {
val age = 8
println("内部运行年龄 $age")// 输出 内部运行年龄 8
"内部运行结束"// 最后一行返回值
}
println(result)// 内部运行结束
println("外部运行年龄 $age")// 输出 外部运行年龄 42
}
可以看到 run 函数新建了一个作用域，屏蔽了外面 age 变量， 另外 run 函数是有返回值的。
三、with 函数
/**
* Calls the specified function [block] with the given [receiver] as its receiver and returns its result.
*
* For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#with).
*/
@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 简化：
fun main() {
val result = with(findPerson()) {
println(this?.name) // 输出 JamFF
println(this?.age) // 输出 18
this?.work() // 输出 JamFF正在工作...
}
println(result) // 输出 工作完成
}
需要传入参数，在作用域中使用 this 代替参数（可以省略），最后一行为返回值。
四、apply 函数
/**
* Calls the specified function [block] with `this` value as its receiver and returns `this` value.
*
* For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#apply).
*/
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
使用 apply 简化：
fun main() {
val result = findPerson()?.apply {
println(this.name) // 输出 JamFF
println(age) // 输出 18
work() // 输出 JamFF正在工作...
}
println(result) // 输出 Person1(name=JamFF, age=18)
}
类似 run，区别是，返回值是调用者自己。
在作用域中使用 this 代替调用者（可以省略），调用者为返回值。
五、also 函数
/**
* Calls the specified function [block] with `this` value as its argument and returns `this` value.
*
* For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#also).
*/
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block(this)
return this
}
使用 also 简化：
fun main() {
val result = findPerson()?.also {
println(it.name) // 输出 JamFF
println(it.age) // 输出 18
it.work() // 输出 JamFF正在工作...
}
println(result) // 输出 Person1(name=JamFF, age=18)
}
类似 let，区别是，返回值是调用者自己。
在作用域中使用 it 代替调用者，调用者为返回值。
六、 总结
上面五个函数，不论用哪个，都可以完成类似功能，只不过使用恰当的函数，可以进一步减少代码量，选择标准可以参考下面图片：
let、run、with、apply、also 如何选择
最后再看下老外整理的两张图加深记忆：
Kotlin 标准方法流程图
Kotlin 标准方法表格
