Kotlin let run with apply also 关键字

Kotlin let run with apply also 关键字

参考官网学习资料 https://play.kotlinlang.org/byExample/06_scope_functions/

一、 let

Kotlin 标准库函数 let 可用于范围界定和空检查。当在对象上调用时，let 执行给定的代码块并返回其最后一个表达式的结果。该对象可在块内通过引用it（默认情况下）或自定义名称来访问。

fun customPrint(s: String) {
    print(s.uppercase())
}

fun main() {
    val empty = "test".let {               // 1
        customPrint(it)                    // 2
        it.isEmpty()                       // 3
    }
    println(" is empty: $empty")


    fun printNonNull(str: String?) {
        println("Printing \"$str\":")

        str?.let {                         // 4
            print("\t")
            customPrint(it)
            println()
        }
    }

    fun printIfBothNonNull(strOne: String?, strTwo: String?) {
        strOne?.let { firstString ->       // 5 
            strTwo?.let { secondString ->
                customPrint("$firstString : $secondString")
                println()
            }
        }
    }

    printNonNull(null)
    printNonNull("my string") 
    printIfBothNonNull("First","Second") 
}
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
31
32
33
34
35

1. 根据字符串“test”的结果调用给定块。

2. 通过 it 引用调用“test”上的函数。

3. let 返回该表达式的值。

4. 使用安全调用，因此 let 及其代码块将仅在非空值上执行。

5. 使用自定义名称代替it，以便嵌套let可以访问外部let的上下文对象。在此代码里也就是firstString替代了第一层范围内的it，secondStirng替代了第二层范围内的it

二、 run

与 let 一样，run 是标准库中的另一个作用域函数。基本上，它执行相同的操作：执行代码块并返回其结果。不同之处在于，在运行内部，对象是通过 this 访问的。当您想要调用对象的方法而不是将其作为参数传递时，这非常有用。

fun main() {
    fun getNullableLength(ns: String?) {
        println("for \"$ns\":")
        ns?.run {                                                  // 1
            println("\tis empty? " + isEmpty())                    // 2
            println("\tlength = $length")                           
            length                                                 // 3
        }
    }
    getNullableLength(null)
    getNullableLength("")
    getNullableLength("some string with Kotlin")
}
1
2
3
4
5
6
7
8
9
10
11
12
13

简单来说就是run括号里的可以直接不用额外的this或者it来代替当前对象去调用该对象的方法，可以直接调用该对象里的方法

三、with

with 是一个非扩展函数，可以简洁地访问其参数的成员：引用其成员时可以省略实例名称。

class Configuration(var host: String, var port: Int) 

fun main() {
    val configuration = Configuration(host = "127.0.0.1", port = 9000) 

    with(configuration) {
        println("$host:$port")
    }

    // instead of:
    println("${configuration.host}:${configuration.port}")    
}
1
2
3
4
5
6
7
8
9
10
11
12

用with修饰的小括号里范围内可以直接不用写对象变量名直接调用成员了，比如不用configuration.host,而可以直接写成host

四、apply

apply 在对象上执行一段代码并返回对象本身。在块内，对象由 this 引用。该函数对于初始化对象很方便。

data class Person(var name: String, var age: Int, var about: String) {
    constructor() : this("", 0, "")
}

fun main() {
    val jake = Person()                                     // 1
    val stringDescription = jake.apply {                    // 2
        name = "Jake"                                       // 3
        age = 30
        about = "Android developer"
    }.toString()                                            // 4
    println(stringDescription)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

五、also

也像 apply 一样工作：它执行给定的块并返回调用的对象。在块内部，对象由它引用，因此更容易将其作为参数传递。此函数可以方便地嵌入附加操作，例如登录调用链。

data class Person(var name: String, var age: Int, var about: String) {
             constructor() : this("", 0, "")
}
         
fun writeCreationLog(p: Person) {
    println("A new person ${p.name} was created.")              
}
         
fun main() {
    val jake = Person("Jake", 30, "Android developer")   // 1
        .also {                                          // 2 
            writeCreationLog(it)                         // 3
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14