什么是作用域函数
当对一个对象调用某个函数并提供一个 lambda 表达式时，它会形成一个临时作用域。在此作用域中，可以访问该对象而无需其名称。这些函数称为作用域函数。
作用域函数的作用
在一个对象上执行一个代码块。
各个作用域函数的区别
一个对象在代码块中如何使用（上下文对象：this or it），以及整个表达式的结果是什么（返回值：上下文对象 or lambda表达式结果）。
apply
T.apply(block: T.() -> Unit): T
源码
//以 "this" 值作为接收者调用指定的函数 [block] 并返回 "this" 值。
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
特性
- 扩展：是扩展函数，扩展了所有对象；
-
参数：没有闭包参数，使用上下文对象作为接受者
this来访问； - 返回：返回上下文对象本身；
- 用途：对象的配置。
示例
fun main() {
val user = User("Peter", 18)
val applyResult = user.apply {
age = 20
}
println(applyResult) //User(name=Peter, age=20)
println(user) //User(name=Peter, age=20)
println(applyResult === user) //true
}
data class User(var name: String, var age: Int)
also
T.also(block: (T) -> Unit): T
源码
//以 "this" 值作为参数调用指定的函数 [block] 并返回 "this" 值。
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block(this)
return this
}
特性
- 扩展：是扩展函数，扩展了所有对象；
-
参数：有闭包参数，使用上下文对象作为labmda表达式的参数
it来访问； - 返回：返回上下文对象本身；
- 用途：可以理解为"并且为该对象执行以下操作"，即附加效果。
示例
fun main() {
val user = User("Peter", 18)
val alsoResult = user.also {
println("user 之前的名字是：${it.name}") //user 之前的名字是：Peter
}.apply {
name = "Tom"
}
println(alsoResult) //User(name=Tom, age=18)
println(user) //User(name=Tom, age=18)
println(alsoResult === user) //true
}
data class User(var name: String, var age: Int)
let
T.let(block: (T) -> R): R
源码
//以 "this" 值作为参数调用指定的函数 [block] 并返回其结果。
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}
特性
- 扩展：是扩展函数，扩展了所有对象；
-
参数：有闭包参数，使用上下文对象作为lambda表达式的参数
it来访问； - 返回：返回lambda表达式的结果，即lambda表达式最后有一行；
- 用途：处理数据，并可以返回一个不同类型的值，且可引入作用于受限的局部变量以提高代码的可读性，即替换 it。
示例
fun main() {
val user = User("Peter", 18)
val letResult1 = user.let {
it.name = "Linda" //这句表达式仅对name进行了赋值，并不代表任何值，所以该let闭包会返回Unit
}
println(letResult1) //kotlin.Unit
println(user) //User(name=Linda, age=18)
val letResult2 = user.let {
it.age = 24
it.name //let闭包会返回 user.name
}
println(letResult2) //Linda
println(user) //User(name=Linda, age=24)
}
data class User(var name: String, var age: Int)
run
T.run(block: T.() -> R): R
源码
//以 "this" 值作为接收者调用指定的函数 [block] 并返回其结果。
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
特性
- 扩展：是扩展函数，扩展了所有对象；
-
参数：没有闭包参数，使用上下文对象作为接受者
this来访问； - 返回：返回lambda表达式的结果，即lambda表达式最后有一行；
- 用途：对象配置并处理数据，和 let 很类似，但可以省略 let 的 it 参数，this 也可省略。
示例
fun main() {
val user = User("Peter", 18)
val runResult = user.run {
name = "Jim"
name
}
println(runResult) //Jim
println(user) //User(name=Jim, age=18)
}
data class User(var name: String, var age: Int)
run(block: () -> R): R
源码
//调用指定的函数 [block] 并返回其结果。
@kotlin.internal.InlineOnly
public inline fun <R> run(block: () -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
特性
- 扩展：不是扩展函数；
- 参数：没有闭包参数，没有上下文对象；
- 返回：返回lambda表达式的结果，即lambda表达式最后有一行；
- 用途：在需要表达式的地方运行语句，并获取返回值。
示例
fun main() {
val user = User("Peter", 18)
val runResult = run {
user.age = 30
if (user.age < 50) "不到50岁" else "50多岁"
}
println(runResult) //不到50岁
println(user) //User(name=Peter, age=30)
}
data class User(var name: String, var age: Int)
with
with(receiver: T, block: T.() -> R): R
源码
//以给定的 [receiver] 作为接收者调用指定的函数 [block] 并返回其结果。
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return receiver.block()
}
特性
- 扩展：不是扩展函数；
-
参数：有参数，但没有闭包参数，上下文对象作为参数传递，但是在lambda表达式内部，它可以作为接收者
this使用； - 返回：返回lambda表达式的结果，即lambda表达式最后有一行；
- 用途：将上下文对象当做参数来使用。
示例
fun main() {
val user = User("Peter", 18)
val withResult = with(user) {
user.name = "Tim"
user.age
}
println(withResult) //18
println(user) //User(name=Tim, age=18)
}
data class User(var name: String, var age: Int)
takeIf
T.takeIf(predicate: (T) -> Boolean): T?
源码
//如果满足给定的 [谓词] ，则返回"this"值；否则，则返回"null"。
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
contract {
callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
}
return if (predicate(this)) this else null
}
特性
- 扩展：是扩展函数，扩展了所有对象；
-
参数：有闭包参数，使用上下文对象作为lambda表达式的参数
it来访问； -
返回：返回如果满足给定的lambda表达式的条件，则返回上下文对象
this，否则返回null； - 用途：对对象进行检查判断，并可以嵌套到调用链中。
示例
fun main() {
val user = User("Peter", 18)
val takeIfResult = user.takeIf {
it.name.length < 6
}
println(takeIfResult) //User(name=Peter, age=18)
}
data class User(var name: String, var age: Int)
takeUnless
T.takeUnless(predicate: (T) -> Boolean): T?
源码
//如果不满足给定的 [谓词]，则返回"this"值；如果满足，则返回"null"。
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
contract {
callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
}
return if (!predicate(this)) this else null
}
特性
- 扩展：是扩展函数，扩展了所有对象；
-
参数：有闭包参数，使用上下文对象作为lambda表达式的参数
it来访问； -
返回：返回如果不满足给定的lambda表达式的条件，则返回上下文对象
this，否则返回null，与takeIf刚好相反； - 用途：对对象进行检查判断，并可以嵌套到调用链中。
示例
fun main() {
val user = User("Peter", 18)
val takeUnlessResult = user.takeUnless {
it.age < 20
}
println(takeUnlessResult) //null
}
data class User(var name: String, var age: Int)
总结
| 函数 | 对象引用 | 返回值 | 是否是扩展函数 |
|---|---|---|---|
apply |
this |
上下文对象 | 是 |
also |
it |
上下文对象 | 是 |
let |
it |
lambda表达式结果 | 是 |
run |
this |
lambda表达式结果 | 是 |
run |
- |
lambda表达式结果 | 不是：调用无需上下文对象 |
with |
this |
lambda表达式结果 | 不是：把上下文对象当参数 |
repeat
上面这些作用域函数都是位于Standard.kt中，最后说说Standard.kt中另一个函数repeat。
repeat(times: Int, action: (Int) -> Unit)
源码
//重复 [times] 次执行给定的功能 [action]。
@kotlin.internal.InlineOnly
public inline fun repeat(times: Int, action: (Int) -> Unit) {
contract { callsInPlace(action) }
for (index in 0 until times) {
action(index)
}
}
特性
- 扩展：不是扩展函数；
- 用途：对指定的功能 [action] 进行重复执行。
示例
fun main() {
repeat(3) {
println("执行第${it}次")
}
//执行第0次
//执行第1次
//执行第2次
}
