let
public inline fun <T, R> T.let(block: (T) -> R): R
let 函数是参数化类型 T 的扩展函数。在 let 块内可以通过 it 指代该对象。返回值为 let 块的最后一行或指定 return 表达式。
以一个 Book 对象为例，类中包含 Book 的 name 和 price，如下：
class Book {
var name = "《数据结构》"
var price = 60
fun displayInfo() = println("Book name : $name and price : $price")
}
- let 块中的最后一条语句如果是非赋值语句，则默认情况下它是返回语句，反之，则返回的是一个 Unit 类型。
控制台输出：
This book is 《计算机网络》
对 Book 对象使用 let 作用域函数，在函数块的最后一句添加了一行字符串代码，并且对 Book 对象进行打印，我们可以看到最后控制台输出的结果为字符串 “This book is 《计算机网络》”。
在 Kotlin 中，如果 let 块中的最后一条语句是非赋值语句，则默认情况下它是返回语句。
那如果我们将 let 块中最后一条语句修改为赋值语句，会发生什么变化？
fun main() {
val book = Book().let {
it.name = "《计算机网络》"
}
println(book)
}
控制台输出：
kotlin.Unit
将 Book 对象的 name 值进行了赋值操作，同样对 Book 对象进行打印，但是最后控制台的输出结果为“kotlin.Unit”，这是因为在 let 函数块的最后一句是赋值语句，print 则将其当做是一个函数来看待。
- let 可用于空安全检查。
如需对非空对象执行操作，可对其使用安全调用操作符 ?.并调用 let 在 lambda 表达式中执行操作。如下案例：
var name: String? = null
fun main() {
val nameLength = name?.let {
it.length
} ?: "name为空时的值"
println(nameLength)
}
控制台输出：
name为空时的值
设置 name 为一个可空字符串，利用 name?.let 来进行空判断，只有当 name 不为空时，逻辑才能走进 let 函数块中。在这里，我们可能还看不出来 let 空判断的优势，但是当你有大量 name 的属性需要编写的时候，就能发现 let 的快速和简洁。
- let 可对调用链的结果进行操作。
fun main() {
val numbers = mutableListOf("One", "Two", "Three", "Four", "Five")
val resultsList: List<Int> = numbers.map {
it.length
}.filter {
it > 3
}
println(resultsList)
}
控制台输出：
[5, 4, 4]
目的是获取数组列表中长度大于 3 的值。因为我们必须打印结果，所以我们将结果存储在一个单独的变量中，然后打印它。但是使用“let”操作符，我们可以将代码修改为：
fun main() {
val numbers = mutableListOf("One", "Two", "Three", "Four", "Five")
numbers.map {
it.length
}.filter {
it > 3
}.let {
print(it)
}
}
控制台输出：
[5, 4, 4]
使用 let 后可以直接对数组列表中长度大于 3 的值进行打印，去掉了变量赋值这一步。
- let 可以将
“It”重命名为一个可读的 lambda 参数。
let 是通过使用“It”关键字来引用对象的上下文，因此，这个 “It” 可以被重命名为一个可读的 lambda 参数，如下将 it 重命名为 book：
fun main() {
val book = Book().let { book ->
book.name = "《计算机网络》"
}
print(book)
}
控制台输出：
kotlin.Unit
apply
public inline fun <T> T.apply(block: T.() -> Unit): T
apply 是 T 的扩展函数,与 run 函数有些相似，它将对象的上下文引用为 “this” 而不是 “it”，并且提供空安全检查，不同的是，apply 不接受函数块中的返回值，返回的是自己的 T 类型对象。
控制台输出：
Book@7c30a502
apply 函数返回传入的对象的本身
在 let 中，没有在函数块中返回的值，最终会成为 Unit 类型，但在 apply 中，最后返回对象本身 （T） 时，它成为 Book 类型。
apply 函数主要用于初始化或更改对象，因为它用于在不使用对象的函数的情况下返回自身。
run
run 函数以 “this”作为上下文对象。
fun main() {
val book = Book().run {
// this == Book() 本身
name = "《计算机网络》"
price = 40
displayInfo()
555 // 返回类型，根据匿名函数最后一行的变化而变化
}
// 返回值 = 函数块的最后一行 / return表达式
println(book)
}
控制台输出：
Book name : 《计算机网络》 and price : 40
555
run 函数存在两种声明方式。
1、与 let 一样，run 是作为 T 的扩展函数。
public inline fun <T, R> T.run(block: T.() -> R): R
2、第二个 run 的声明方式则不同，它不是扩展函数，并且块中也没有输入值，因此，它不是用于传递对象并更改属性的类型，而是可以使你在需要表达式的地方就可以执行一个语句
public inline fun <R> run(block: () -> R): R
如下利用 run 函数块执行方法，而不是作为一个扩展函数。
run {
val book = Book()
book.name = "《计算机网络》"
book.price = 30
book.displayInfo()
}
// 具名函数调用给 run 执行
// str.run(具名函数)
val str = "《计算机网络》"
str.run(::getStr)
fun getStr(str: String) {
println(str.length)
}
// 匿名函数调用给 run 执行
str.run {
// this == str 本身
if (length > 3) true else false
}
with
public inline fun <T, R> with(receiver: T, block: T.() -> R): R
with 属于非扩展函数，直接输入一个对象 receiver，当输入 receiver 后，便可以更改 receiver 的属性，同时，它也与 run 做着同样的事情。
fun main() {
val book = Book()
val str: String = with(book) {
name = "《计算机网络》"
price = 40
displayInfo()
"dfdggg" // 返回值 = 函数块的最后一行 / return表达式
}
print(str)
}
控制台输出：
Book name : 《计算机网络》 and price : 40
dfdggg
with（T）类型传入了一个参数 book，则可以在 with 的代码块中访问 book 的 name 和 price 属性，并做更改。
fun main() {
/*with(str){
// this == str 本身
}*/
// 具名操作
val str = "《计算机网络》"
with(str, ::println)
val len: Int = with(str, ::getStrLen)
println(len)
// 匿名操作
with(str) {
// this == str 本身
length
}
}
fun getStrLen(str: String) = str.length
with 使用的是非 null 的对象，当函数块中不需要返回值时，可以使用 with。
also
public inline fun <T> T.also(block: (T) -> Unit): T
also 是 T 的扩展函数，返回值与 apply 一致，直接返回 T。also 函数的用法类似于 let 函数，将对象的上下文引用为 “it” 而不是 “this” 以及提供空安全检查方面。
作用 & 应用场景
类似 let 函数，但区别在于返回值：
- let函数：返回值 = 最后一行 / return的表达式
- also函数：返回值 = 传入的对象的本身
fun main() {
val str = "abcdefg"
str.also {
// also 函数始终返回 str 本身
println("str的原始数据：$it")
}
}
// let函数
var result = mVar.let {
it.function1()
it.function2()
it.function3()
999
}
// 最终结果 = 返回999给变量result
// also函数
var result = mVar.also {
it.function1()
it.function2()
it.function3()
999
}
// 最终结果 = 返回一个mVar对象给变量result
总结
