本文共 2799 字，大约阅读时间需要 9 分钟。

作用域函数

Kotlin 提供了一系列的作用域函数，可以在函数形成的临时作用域中对象上下文执行代码块，这些作用域函数共有 5 个：let、with、run、apply、also，它们区别有 2 个：

• 对象上下文在作用域名中的使用（this 还是 it）
• 作用域函数的返回结果（上下文对象 还是 Lambda 表达式结果）

let

let 经常用于非空值执行代码块，通过与安全操作符 ? 组合成 ?.let 进行安全的非空代码操作：

• 对象上下文：it
• 返回值：lambda 表达式结果

fun main(args: Array
   
    ) {
       val list = listOf(1, 2, 3, 4, 5, 6)    list?.let {
    it ->        println(it[0]) // 1        it.forEach(::println) // 1 2 3 4 5 6    }    val ele1 = list.let {
    it[5] }.let {
    it * 2 }    println(ele1) // 12}
   

另外，还有一种经常使用 let 的场景，那就是懒得给变量命名，使用 it 代替。

with

with 不是一个扩展函数，所以 不能使用 对象.with 的方式来执行！！！

• 对象上下文：this
• 返回值：lambda 表达式结果

fun main(args: Array
   
    ) {
       val list = listOf(1, 2, 3, 4, 5, 6)    with(list) {
           println(this[0]) // 1        // this.forEach(::println) // this可以省略        forEach(::println) // 1 2 3 4 5 6    }    val ele1 = with(list) {
    this[5] }    println(ele1) // 6}
   

with 可以这么理解记忆：对于这个对象，进行以下操作。

run

run 其实就是 with 的扩展函数版本，除了调用方式有区别，其他的都与 with 一模一样：

• 对象上下文：this
• 返回值：lambda 表达式结果

fun main(args: Array
   
    ) {
       val list = listOf(1, 2, 3, 4, 5, 6)    list.run {
           println(this[0]) // 1        // this.forEach(::println) // this可以省略        forEach(::println) // 1 2 3 4 5 6    }    val ele1 = list.run {
    this[5] }    println(ele1) // 6}
   

不过，run 还有个非扩展函数版本，非扩展run 有点类似于一个纯粹代码块的作用，相比 扩展run 少了一个对象上下文：

fun main(args: Array
   
    ) {
       val list = listOf(1, 2, 3, 4, 5, 6)    run {
           // 没有上下文        list.forEach {
    println(it) } // 1 2 3 4 5 6    }    val ele1 = run {
    list[5] }    println(ele1) // 6}
   

apply

apply 接收对象上下文，最终也返回对象上下文，常用于对对象进行配置：

• 对象上下文：this
• 返回值：上下文对象

fun main(args: Array
   
    ) {
       val list = mutableListOf(1, 2, 3, 4, 5, 6)    list.apply {
           this.add(0, 0)    }.apply {
           add(0, -1)    }    list.forEach(::println) // -1 0 1 2 3 4 5 6}
   

apply 可以这么理解记忆：对于这个对象，进行以下配置。

also

also 对于执行一些将上下文对象作为参数的操作很有用。对于需要引用对象而不是其属性与函数的操作，或者不想屏蔽来自外部作用域的 this 引用时，请使用 also。

• 对象上下文：it
• 返回值：上下文对象

fun main(args: Array
   
    ) {
       val list = mutableListOf(1, 2, 3, 4, 5, 6)    list.also {
           it.add(0, 0)    }.also {
           it.add(0, -1)    }    list.forEach(::println) // -1 0 1 2 3 4 5 6}
   

总结

作用域函数的目的是一样的，只是彼此之间在使用上存在一些细微的区别：

• 作用：生成一个临时作用域，并在该作用域名中对对象上下文进行操作。
• 差别：对象上下文在临时作用域中的使用（this 或 it），以及作用域的返回值（对象上下文 或 Lambda 表达式结果）。

正是因为这些细微区别，才让人觉得有些混乱，引用 Kotlin 官方文档的汇总表格，可以帮助我们直观的理清这些区别：

以下是根据预期目的选择作用域函数的简短指南：

• 对一个非空（non-null）对象执行 lambda 表达式：let
• 将表达式作为变量引入为局部作用域中：let
• 对象配置：apply
• 对象配置并且计算结果：run
• 在需要表达式的地方运行语句：非扩展的 run
• 附加效果：also
• 一个对象的一组函数调用：with

文章部分引用自 Kotlin 官方文档：

转载地址：http://hshpf.baihongyu.com/