Kotlin 中 let、apply、run、with及 also 的差别

let

public inline fun  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 = 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.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.run(block: T.() -> R): R

2、第二个 run 的声明方式则不同，它不是扩展函数，并且块中也没有输入值，因此，它不是用于传递对象并更改属性的类型，而是可以使你在需要表达式的地方就可以执行一个语句

public inline fun  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  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.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

总结