Kotlin作用域函数 let、run、with、apply 以及 also

本文主要是介绍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的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---