本文主要是介绍Kotlin作用域函数 let、run、with、apply 以及 also，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
一、区别
由于作用域函数本质上都非常相似，因此了解它们之间的区别很重要。每个作用域函数之间有两个主要区别：
–引用上下文对象的方式
–返回值
1.上下文对象：this 还是 it
(1)this
run、with 以及 apply 通过关键字 this 引用上下文对象。因此，在它们的 lambda 表达式中可以像在普通的类函数中一样访问上下文对象。在大多数场景，当你访问接收者对象时你可以省略 this，来让你的代码更简短。相对地，如果省略了 this，就很难区分接收者对象的成员及外部对象或函数。因此，对于主要对对象成员进行操作（调用其函数或赋值其属性）的 lambda 表达式，建议将上下文对象作为接收者（this）。
(2)it
反过来，let 及 also 将上下文对象作为 lambda 表达式参数。如果没有指定参数名，对象可以用隐式默认名称 it 访问。it 比 this 简短，带有 it 的表达式通常更容易阅读。然而，当调用对象函数或属性时，不能像 this 这样隐式地访问对象。因此，当上下文对象在作用域中主要用作函数调用中的参数时，使用 it 作为上下文对象会更好。若在代码块中使用多个变量，则 it 也更好。
2.返回值
根据返回结果，作用域函数可以分为以下两类：
–apply 及 also 返回上下文对象。
–let、run 及 with 返回 lambda 表达式结果.
二、几个函数
1.let
上下文对象作为 lambda 表达式的参数（it）来访问。返回值是 lambda 表达式的结果。let 可用于在调用链的结果上调用一个或多个函数。
let 经常用于仅使用非空值执行代码块。如需对非空对象执行操作，可对其使用安全调用操作符 ?. 并调用 let 在 lambda 表达式中执行操作。
fun main() {val numbers = mutableListOf("one", "two", "three", "four", "five")numbers.map { it.length }.filter { it > 3 }.let { println(it)// 如果需要可以调用更多函数}
}
[5, 4, 4]
fun processNonNullString(str: String) {}fun main() {val str: String? = "Hello" //processNonNullString(str) // 编译错误：str 可能为空val length = str?.let { println("let() called on $it")processNonNullString(it) // 编译通过：'it' 在 '?.let { }' 中必不为空it.length}
}
let() called on Hello
2.with
一个非扩展函数：上下文对象作为参数传递，但是在 lambda 表达式内部，它可以作为接收者（this）使用。 返回值是 lambda 表达式结果。
我们建议使用 with 来调用上下文对象上的函数，而不使用 lambda 表达式结果。 在代码中，with 可以理解为“对于这个对象，执行以下操作。”
fun main() {val numbers = mutableListOf("one", "two", "three")with(numbers) {println("'with' is called with argument $this")println("It contains $size elements")}
}
‘with’ is called with argument [one, two, three]
It contains 3 elements
with 的另一个使用场景是引入一个辅助对象，其属性或函数将用于计算一个值。
fun main() {val numbers = mutableListOf("one", "two", "three")val firstAndLast = with(numbers) {"The first element is ${first()}," +" the last element is ${last()}"}println(firstAndLast)
}
the last element is three
3.run
上下文对象 作为接收者（this）来访问。 返回值 是 lambda 表达式结果。
run 和 with 做同样的事情，但是调用方式和 let 一样——作为上下文对象的扩展函数.
当 lambda 表达式同时包含对象初始化和返回值的计算时，run 很有用。
class MultiportService(var url: String, var port: Int) {fun prepareRequest(): String = "Default request"fun query(request: String): String = "Result for query '$request'"
}fun main() {val service = MultiportService("https://example.kotlinlang.org", 80)val result = service.run {port = 8080query(prepareRequest() + " to port $port")}// 同样的代码如果用 let() 函数来写:val letResult = service.let {it.port = 8080it.query(it.prepareRequest() + " to port ${it.port}")}println(result)println(letResult)
}
4.apply
上下文对象 作为接收者（this）来访问。 返回值 是上下文对象本身。
对于不返回值且主要在接收者（this）对象的成员上运行的代码块使用 apply。apply 的常见情况是对象配置。这样的调用可以理解为“将以下赋值操作应用于对象”。
data class Person(var name: String, var age: Int = 0, var city: String = "")fun main() {val adam = Person("Adam").apply {age = 32city = "London" }
}
将接收者作为返回值，你可以轻松地将 apply 包含到调用链中以进行更复杂的处理。
5.also
上下文对象作为 lambda 表达式的参数（it）来访问。 返回值是上下文对面本身。
also 对于执行一些将上下文对象作为参数的操作很有用。 对于不会改变上下文对象的操作，可使用 also，例如记录或打印调试信息。 通常，你可以在不破坏程序逻辑的情况下从调用链中删除 also 的调用。
当你在代码中看到 also 时，可以将其理解为“并且执行以下操作”。
fun main() {val numbers = mutableListOf("one", "two", "three")numbers.also { println("The list elements before adding new one: $it") }.add("four")
}
The list elements before adding new one: [one, two, three]
三、函数选择
| 函数 | 对象引用 | 返回值 | 是否是扩展函数 |
|---|---|---|---|
| let | it | Lambda表达式 | 是 |
| run | this | Lambda表达式 | 是 |
| run | - | Lambda表达式 | 不是：调用无需上下文对象 |
| with | this | Lambda表达式 | 不是：把上下文对象当做参数 |
| apply | this | 上下文对象 | 是 |
| also | it | 上下文对象 | 是 |
- 对一个非空（non-null）对象执行 lambda 表达式：let
- 将表达式作为变量引入为局部作用域中：let
- 对象配置：apply
- 对象配置并且计算结果：run
- 在需要表达式的地方运行语句：非扩展的 run
- 附加效果：also
- 一个对象的一组函数调用：with
这个不错
新增
1. let 经常和?.操作符号联合使用,替代IF判断
var name:String? = null
var map = HashMap<String>()
// name是可变变量，IF 条件判断不等于空，对于编译器来讲name还是可空变量，所以必须先赋值到val变量
val theName = name
if(theName !=null){//此时theName是不可空变量map[theName] = "OK"
}
// 使用?.let方法简化上面的代码
name?.let{map[it] = "OK"
}
2. apply 创建对象并初始化设置
val map = HashMap<String,Int>()
map["name1"] = 18
map["name2"] = 18
// 使用apply
val map = HashMap<String,Int>().apply{this["name1"] = 18this["name2"] = 18
}
// 如果对象创建后立即作为参数，那么避免一个变量名
fun processUser(user:User)
processUser(User().apply{this.name = "jimi"this.age = 18
})
3. also
Java中经常使用(line=reader.readLine())!=null这种写法，是由于赋值语句可以作为表达式才可以这么写。
但是kotlin的赋值语句不能作为表达式，所以刚开始使用kotlin会不习惯
public void test(BufferedReader reader) throws IOException {String line;while ( (line=reader.readLine())!=null ){System.out.println(line);}}
在kotlin中：
fun test(reader: BufferedReader) {var line: String?while (reader.readLine().also { line = it } != null) {println(line)}}
also 通过it访问当前变量，并且整体返回自己。所以可以模拟赋值语句当做表达式的效果。
虽然apply也能做类似的事情
while (reader.readLine().apply { line = this } != null)
会造成语义不清晰，可读性不强，this到底指的哪个对象？
选择使用this 还是 it 访问当前对象，一个原则就是：如果使用this，那么就不要把 this. 写出来，利用this关键字可以省略的特性。
4. with
消除对同一个变量多次引用
val service = Service()
service.setName("xxx")
service.doSome()
service.ddd()
service.sddd()// 使用with修改为
with(service){this.setName("xxx")this.doSome()this.ddd()this.sddd()
}// 进一步省略thiswith(service){setName("xxx")doSome()ddd()sddd()
}
这篇关于Kotlin作用域函数 let、run、with、apply 以及 also的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
