Kotlin：作用域函数

2019-03-22 本文已影响0人 SirWwh

Kotlin

前言

最近使用kotlin语言开发了新的项目，kotlin的一些特性和大量的语法糖相当好用，相比于java，开发效率高了不少。但Kotlin大量的语法糖也带来了一些问题：学习成本高，语法糖使用场景的困惑。
比如，当我第一次看到作用域函数就产生了这样的疑问：what is this？Which function to use?

于是我研究了一下什么是作用域函数，以及各个函数的区别和使用场景。

介绍

官方介绍：The Kotlin standard library contains several functions whose sole purpose is to execute a block of code within the context of an object. When you call such a function on an object with a lambda expression provided, it forms a temporary scope. In this scope, you can access the object without its name. Such functions are called scope functions. There are five of them: let, run, with, apply, and also.

翻译理解：作用域函数的目的是在对象的上下文中执行代码块，它为调用者对象提供了一个临时内部作用域，在这个作用域中可以不显式的访问该对象。这样的作用域函数有5个：let，run，with，apply，和also。

函数

run

run函数是最能体现作用域的用途的函数，如下使用示例：
在mian函数中使用run函数创建了一个单独的作用域，在该作用域中重新定义了一个word变量，两次打印使用的是各自作用域中的word变量，互不影响；并且，run函数返回了lambda结果。

使用示例

fun main(args: Array<String>) {
    var word = "我是小明"
    val returnValue = run {
        var word = "我是小红"
        println("run:$word")
        word
    }
    println("main:$word")
    println("returnValue:$returnValue")
}

运行结果：

run:我是小红
main:我是小明
returnValue:我是小红

with

with函数可以将任意对象作为上下文对象this传入，并且可以隐式的访问该对象，返回lambda结果。如下使用示例：在mian函数中使用with函数创建了一个临时作用域，在该作用域中可以重新定义person变量，两个person变量互无影响；并且可以使用this访问上下文对象，隐式修改person的age变量值。

使用示例

data class Person (
    var name: String,
    var age: Int = 0
)
fun main(args: Array<String>) {
    var person = Person("小明",25)
    val returnValue = with(person) {
        println("with:this=$this")
        var person = Person("小红",23)
        println("with:person=$person")
        age = 26
        person
    }
    println("main:person=$person")
    println("main:returnValue=$returnValue")
}

运行结果：

with:this=Person(name=小明, age=25)
with:person=Person(name=小红, age=23)
main:person=Person(name=小明, age=26)
main:returnValue=Person(name=小红, age=23)

T.run

T.run函数可以使用T作为作用域的上下文对象this，在作用域中可以隐式访问T对象，并返回lambda结果。

使用示例

data class Person (
    var name: String,
    var age: Int = 0
)
fun main(args: Array<String>) {
    var person: Person? = null
    // T?.run当T为null时不调用run函数
    person?.run {
        println("person?.run:person=$person")
    }
    person = Person("小明",25)
    val returnValue = person.run {
        println("person.run:this=$this")
        var person = Person("小红",23)
        println("person.run:person=$person")
        age = 26
        person
    }
    println("main:person=$person")
    println("main:returnValue=$returnValue")
}

运行结果：

person.run:this=Person(name=小明, age=25)
person.run:person=Person(name=小红, age=23)
main:person=Person(name=小明, age=26)
main:returnValue=Person(name=小红, age=23)

T.let

T.let函数与T.run函数唯一的区别是：T作为作用域上下文对象的名称不同，前者是it，后者是this，所以在T.let函数中必须显式使用it访问T对象。

使用示例

data class Person (
    var name: String,
    var age: Int = 0
)
fun main(args: Array<String>) {
    var person: Person? = null
    person?.let {
        println("person?.let:person=$person")
    }
    person = Person("小明",25)
    val returnValue = person.let {
        println("person.let:it=$it")
        var person = Person("小红",23)
        println("person.let:person=$person")
        it.age = 26
        person
    }
    println("main:person=$person")
    println("main:returnValue=$returnValue")
}

运行结果：

person.let:it=Person(name=小明, age=25)
person.let:person=Person(name=小红, age=23)
main:person=Person(name=小明, age=26)
main:returnValue=Person(name=小红, age=23)

T.also

如下使用示例，T.also函数和T.let函数的唯一区别是：前者返回值是this（即T），后者返回值是lambda结果。

使用示例

data class Person (
    var name: String,
    var age: Int = 0
)
fun main(args: Array<String>) {
    var person: Person? = null
    person?.also {
        println("person?.also:person=$person")
    }
    person = Person("小明",25)
    val returnValue = person.also {
        println("person.also:it=$it")
        var person = Person("小红",23)
        println("person.also:person=$person")
        it.age = 26
        person
    }
    println("main:person=$person")
    println("main:returnValue=$returnValue")
}

运行结果：

person.also:it=Person(name=小明, age=25)
person.also:person=Person(name=小红, age=23)
main:person=Person(name=小明, age=26)
main:returnValue=Person(name=小明, age=26)

T.apply

如下使用示例，T.apply函数和T.also函数的唯一的区别是：T作为作用域上下文对象的名称不同，前者是this，后者是it，所以在T.apply函数中可以隐式访问T对象。

使用示例

data class Person (
    var name: String,
    var age: Int = 0
)
fun main(args: Array<String>) {
    var person: Person? = null
    person?.apply {
        println("person?.apply:person=$person")
    }
    person = Person("小明",25)
    val returnValue = person.apply {
        println("person.apply:this=$this")
        var person = Person("小红",23)
        println("person.apply:person=$person")
        age = 26
        person
    }
    println("main:person=$person")
    println("main:returnValue=$returnValue")
}

运行结果：

person.apply:this=Person(name=小明, age=25)
person.apply:person=Person(name=小红, age=23)
main:person=Person(name=小明, age=26)
main:returnValue=Person(name=小明, age=26)

特殊的作用域函数

T.takeIf

以it作为在作用域上下文对象T的名称，若lambda结果为true，返回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
}

使用示例

fun main(args: Array<String>) {
    var count = 0
    while (count <= 10) {
        val returnValue = count.takeIf {
            count++ % 2 == 0
        }
        println(returnValue)
    }
}

运行结果：

0
null
2
null
4
null
6
null
8
null
10

T.takeUnless

以it作为在作用域上下文对象T的名称，若lambda结果为true，返回null；否则，返回this。与taskIf的实现相比，其实就是对lambda结果进行了取反操作。

函数源码

@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
}

使用示例

fun main(args: Array<String>) {
    var count = 0
    while (count <= 10) {
        val returnValue = count.takeUnless {
            count++ % 2 == 0
        }
        println(returnValue)
    }
}

运行结果：

null
1
null
3
null
5
null
7
null
9
null

repeat

以当前执行的次数it作为在作用域上下文对象T的名称，执行给定lambda函数指定的次数。从函数源码和使用示例可以看出，执行次数角标是从0开始。

函数源码

@kotlin.internal.InlineOnly
public inline fun repeat(times: Int, action: (Int) -> Unit) {
    contract { callsInPlace(action) }
    for (index in 0 until times) {
        action(index)
    }
}

使用示例

fun main(args: Array<String>) {
    repeat(5) {
        print("$it,")
    }
}

运行结果：

0,1,2,3,4,

总结

从上面的函数介绍和实际使用可以看出let，run，with，apply，和also，这些作用域函数的功能之间起着相互补充的作用，单独看某两个函数可能差别不大，但它们结合起来所实现的功能涵盖了绝大部分的使用场景。

总结一下，用于快速判断操作符使用场景，主要使用这几个因素辨别：

调用者：
- 正常函数：有run，with函数。主要作用是：开辟一个作用域，不受作用域之外上下文影响，with还可以方便地在作用域中访问上下文对象。
- 扩展函数：可以使用T?.fun()在调用之前做空检查，如：null?.run { println("Kotlin") }，作用域内容不会被执行。
上下文对象
- this：方便在作用域中直接访问this
- it：可以更清楚的区分作用域和非作用域中的成员

返回值

上下文对象this：可以作为链式调用。
lambda表达式结果：返回表达式结果，可以将结果结合其他作用域函数，使用更灵活。

// 示例：使用apply函数进行链式调用
class Person {
    var name = ""
    var age = 0
}
fun main(args: Array<String>) {
    val person = Person().apply { name = "小明" }.apply { age = 25 }
    println("${person.name},${person.age}")
}
// 运行结果：小明,25

下面对作用域函数简要区分，可以更方便快速的辨别各函数的作用和使用场景。

作用域函数简要区分：

run：返回lambda结果
with：this上下文，返回lambda结果
T.run：支持空检查，this上下文，返回lambda结果
T.let：支持空检查，it上下文，返回lambda结果
T.also：支持空检查，it上下文，返回this（即T，it）
T.apply：支持空检查，this上下文，返回this（即T，this）

特殊的作用域函数区分：

T.takeIf：支持空检查，it上下文，函数体返回值类型Boolean，函数体返回true，函数返回this；否则返回null
T.takeUnless：支持空检查，it上下文，函数体返回值类型Boolean，函数体返回true，函数返回null；否则返回this
repeat：执行给定函数 action 指定的次数 times （角标：0-times）

参考资料

官方文档：https://www.kotlincn.net/docs/reference/scope-functions.html
medium Elye：https://medium.com/@elye.project/mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84
CSDN george_zyf：https://blog.csdn.net/android_zyf/article/details/82496983

Kotlin：作用域函数

前言

介绍

函数

run

使用示例

with

使用示例

T.run

使用示例

T.let

使用示例

T.also

使用示例

T.apply

使用示例

特殊的作用域函数

T.takeIf

函数源码

使用示例

T.takeUnless

函数源码

使用示例

repeat

函数源码

使用示例

总结

参考资料

猜你喜欢

热点阅读