简书链接:kotlin作用域函数letrunwhithapplyalso的区别takeIf的用法
文章字数：588,阅读全文大约需要2分钟

本质区别

有两个主要区别：

引用上下文对象的方式
和```it``` 使用```this```则具备上下文,可以省略```this``` 而```it```不能省略了,因为它是参数.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

###### 返回值
```apply``` ```also```返回上下文对象。
```let```,``` run```, ```with```返回 lambda 结果。

```let``` 与```run```


作用域函数不会引入任何新的技术功能，但它们可以使您的代码更加简洁和可读。
如```ListOf("1","2").let(it.add()) ``` = ``` var list=ListOf("1","2") list.add()```就是个语法糖,让你写代码好像更简洁,没学过的朋友就以为是什么高大上的东西..
| 函数| 对象引用	| 返回值	| 是否是扩展函数
|  ----  | ----  | ----  | ----  |
| let	| it	| Lambda 结果| 是
| run	| this| Lambda 结果	| 是
| run	| this| Lambda 结果	| 否: 没有上下文对象调用
| with| this| Lambda 结果	|否: 接受上下文对象作为参数。
| apply	| this| Context object|是
| also	| it	| Context object|是

### 简短说明
在非空对象上执行 lambda：``` let```
将表达式作为局部作用域中的变量引入：``` let```
对象配置： ```apply```
对象配置和计算结果： ```run```
需要表达式的运行语句：非扩展 ```run```
附加效果： ```also```     *两个值替换*
对对象进行分组函数调用： ```with```

作用域函数使用以下两种方式之一
访问上下文对象：作为 lambda`this` 或作为 lambda 参数  `it`。两者都提供相同的功能，因此我们将针对不同情况描述各自的优缺点

fun main() {
val str = “Hello”
// this
str.run {
// println(“The receiver string length: $length”)
println(“The receiver string length: ${this.length}”) //没有区别
}

// it
str.let {
    println("The receiver string's length is ${it}")
}

}

1
also

fun getRandomInt(): Int {
return Random.nextInt(100).also { value ->
// writeToLog(“getRandomInt() generated value $value”)
print(“getRandomInt() generated value $it”)
}
}

val i = getRandomInt()
println(i)

1
2
先打印日志内容,getRandomInt() generated value 然后再打印i.

var numbers = mutableListOf(“吉a”, “凶bb”, “以ccc”, “情dddd”, “迁eeeee”)
println(numbers)
//return 由于执行了map filter ,所以 返回了新的list对象 numbers本身不变.
var number2=numbers.map { it.length }.filter { it > 1 }.apply{println(“apply $this”)}
//return lamba result 这里是println输出的是kotlin.Unit 如果再加上 ; it 那么和apply效果一样了.
var number3=numbers.map { it.length }.filter { it > 1 }.let{println(“let $it”)}
println(number2)
println(number3)

1
输出结果

[吉a, 凶bb, 以ccc, 情dddd, 迁eeeee]
apply [2, 3, 4, 5, 6]
let [2, 3, 4, 5, 6]
[2, 3, 4, 5, 6]
kotlin.Unit

1
2
3
如果只有一个```it```参数可以直接使用```.let(::println)```
例子 with

val numbers = mutableListOf(“one”, “two”, “three”)
val firstAndLast = with(numbers) {
“The first element is ${this.first()},” +
“ the last element is ${last()}”
}
println(firstAndLast)

1
执行结果

The first element is one, the last element is three

1
2
```takeIf ```  为真返回lambda结果,不匹配则返回null
```takeUnless ```是取反.

val number = Random.nextInt(100)
val evenOrNull = number.takeIf { it % 2 == 0 }
val oddOrNull = number.takeUnless { it % 2 == 0 }
println(“even: $evenOrNull, odd: $oddOrNull”)

1
2

结果,当随机值为33,那么takeif中是否等于偶数不成立,返回null,而takeUnless不成立就取lambda结果

even: null, odd: 33

1
骚操作 实现字符串如果不为空就转换为大写,否则整个结果返回null

val str = “Hello”
val caps = str.takeIf { it.isNotEmpty() }?.uppercase()
//val caps = str.takeIf { it.isNotEmpty() }.uppercase() //compilation error
println(caps)


参考连接
https://kotlinlang.org/docs/scope-functions.html#distinctions