Scope函数翻译过来就叫作用域函数吧，Kotlin中的作用域函数包含let, run with, apply, also五个.
作用域函数方便我们更加容易操作对象本身，使得代码更加易读。举个例子
定一个Person类
class Person(var name : String, var age : Int, var country : String) {
override fun toString(): String {
return "Person(name='$name', age=$age, city='$country')"
}
}
通常操作如下
val person = Person("jay",22,"china")
person.country = "usa"
Log.i("tag", person.toString())
无非是更改国家后再输出该对象的值，如果使用作用域中函数效果是
Person("jay",22,"china").let {
it.country = "usa"
Log.i("tag", it.toString())
}
上面使用作用域函数代码会更加清晰.
下面来说下每个作用域函数的区别. 主要有两个
1，引用到的context对象不同
2，返回值不同
下面分别来看
1，引用到的context对象不同
context有两种，一个是this一个是it.
fun main() {
val str = "Hello"
// this
str.run {
println("The receiver string length: $length")
//println("The receiver string length: ${this.length}") // does the same
}
// it
str.let {
println("The receiver string's length is ${it.length}")
}
}
run, with, apply是使用的是this作为context对象，因此在函数中，对象本身可以像它类中方法一样使用，你也可以忽略掉this的调用
val adam = Person("Adam").apply {
age = 20 // same as this.age = 20 or adam.age = 20
city = "London"
}
println(adam)
let和also以lambda参数形式传入，它的context是it(前提是没有指定参数名字).
fun getRandomInt(): Int {
return Random.nextInt(100).also {
writeToLog("getRandomInt() generated value $it")
}
}
val i = getRandomInt()
另外也可以自定义参数名字
fun getRandomInt(): Int {
return Random.nextInt(100).also { value ->
writeToLog("getRandomInt() generated value $value")
}
}
val i = getRandomInt()
2，返回值不同
apply和also返回的context对象
let,run和with返回的是lambda执行的结果
来看看also调用的情况
val numberList = mutableListOf<Double>()
numberList.also { println("Populating the list") }
.apply {
add(2.71)
add(3.14)
add(1.0)
}
.also { println("Sorting the list") }
.sort()
在返回context对象这种情况下可以作为一个链式调用使用.
当然也可以不去操作context对象，用来输出一些信息然后返回context对象
fun getRandomInt(): Int {
return Random.nextInt(100).also {
writeToLog("getRandomInt() generated value $it")
}
}
val i = getRandomInt()
另外一种情况就是let,run和with返回的是lambda执行的结果，如下
val numbers = mutableListOf("one", "two", "three")
val countEndsWithE = numbers.run {
add("four")
add("five")
count { it.endsWith("e") }
}
println("There are $countEndsWithE elements that end with e.")
每个作用域函数的区别
每个作用域函数实际上在使用上是可以互换的，主要是看如何使用起来更加方便易读.
let
1,let用来在一个调用链返回后调用一个或者更多函数，举个例子
val numbers = mutableListOf("one", "two", "three", "four", "five")
val resultList = numbers.map { it.length }.filter { it > 3 }
println(resultList)
如果使用write你可以重写成
val numbers = mutableListOf("one", "two", "three", "four", "five")
numbers.map { it.length }.filter { it > 3 }.let {
println(it)
// and more function calls if needed
}
2,let用来执行一个非空对象的代码块.
val str: String? = "Hello"
//processNonNullString(str) // compilation error: str can be null
val length = str?.let {
println("let() called on $it")
processNonNullString(it) // OK: 'it' is not null inside '?.let { }'
it.length
}
3,另外一个场景是let引进一个本地变量去提高代码的可读性.
val numbers = listOf("one", "two", "three", "four")
val modifiedFirstItem = numbers.first().let { firstItem ->
println("The first item of the list is '$firstItem'")
if (firstItem.length >= 5) firstItem else "!" + firstItem + "!"
}.toUpperCase()
println("First item after modifications: '$modifiedFirstItem'")
with
With通常需要穿一个context对象作为参数，在函数内部使用this作为context对象调用，返回值是lambda的执行结果.
1, 通常我们用它做一些伴生操作，官方文档认为它 “with this object, do the following.” 自行体会
val numbers = mutableListOf("one", "two", "three")
with(numbers) {
println("'with' is called with argument $this")
println("It contains $size elements")
}
2，另外可以用来计算一个结果后返回值
val numbers = mutableListOf("one", "two", "three")
val firstAndLast = with(numbers) {
"The first element is ${first()}," +
" the last element is ${last()}"
}
println(firstAndLast)
run
run属于context对象是this, 返回结果是lambda执行的结果.
1,通常用来执行一些对象初始化和一些操作后返回结果, 它可以和let进行互换
val service = MultiportService("https://example.kotlinlang.org", 80)
val result = service.run {
port = 8080
query(prepareRequest() + " to port $port")
}
// the same code written with let() function:
val letResult = service.let {
it.port = 8080
it.query(it.prepareRequest() + " to port ${it.port}")
}
2, run还有另外一个特点，它可以不作为对象的扩展函数，直接调用执行一个代码块.
val hexNumberRegex = run {
val digits = "0-9"
val hexDigits = "A-Fa-f"
val sign = "+-"
Regex("[$sign]?[$digits$hexDigits]+")
}
for (match in hexNumberRegex.findAll("+1234 -FFFF not-a-number")) {
println(match.value)
}
apply
apply的context是this, 返回对象的对象自己.
使用apply通常是对象的属性进行赋值操作,然后返回它自己，进行一些链式操作
val adam = Person("Adam").apply {
age = 32
city = "London"
}
println(adam)
also
Context对象是it, 返回值是对象本身
通常用来做些输出日志，打印调试信息的操作，可以理解成and also do the following.
val numbers = mutableListOf("one", "two", "three")
numbers
.also { println("The list elements before adding new one: $it") }
.add("four")
对于上面的描述，官方文档给出了一张表格
