Kotlin的作用域函数有哪些？-51CTO.COM

Kotlin作用域函数

Kotlin提供了几个作用域函数，用于在特定的作用域内执行代码块。这些作用域函数包括：

(1) let函数：let函数允许您在对象上执行代码块，并将对象作为参数传递给代码块。它的语法如下：

obj.let {
    // 在这里可以使用obj对象
}1.
2.
3.

在代码块中，您可以使用it来引用传递给let函数的对象。

(2) run函数：run函数类似于let函数，但它不使用it来引用对象，而是直接使用this关键字。它的语法如下：

obj.run {
    // 在这里可以使用this关键字引用obj对象
}1.
2.
3.

(3) with函数：with函数允许您在没有接收者对象的上下文中执行代码块。它的语法如下：

with(obj) {
    // 在这里可以直接使用obj对象的成员
}1.
2.
3.

(4) apply函数：apply函数类似于run函数，但它返回的是对象本身，而不是代码块的结果。它的语法如下：

obj.apply {
    // 在这里可以使用this关键字引用obj对象
}1.
2.
3.

(5) also函数：also函数类似于let函数，但它返回的是对象本身，而不是代码块的结果。它的语法如下：

obj.also {
    // 在这里可以使用it来引用obj对象
}1.
2.
3.

这些作用域函数可以根据不同的使用场景来选择，可以简化代码，并提供更清晰的上下文。

let

let作用域函数可以在一个对象上执行一系列操作，并返回一个结果。它的语法如下：

object.let {
    // 在这里可以对object进行操作
    // 返回结果
}1.
2.
3.
4.

使用let函数可以方便地对一个对象进行操作，例如：

val name: String? = "John"

name?.let {
    // 当name不为null时执行以下操作
    println("Name is $it")
}1.
2.
3.
4.
5.
6.

在上面的例子中，如果name不为null，则会打印出Name is John。let函数将name作为参数传递给lambda表达式，并在lambda表达式中使用it来引用该参数。

let函数还可以用于链式调用，例如：

val result = "Hello, World!".let {
    // 对字符串进行操作
    it.toUpperCase()
}.let {
    // 继续对字符串进行操作
    it.substring(0, 5)
}

println(result) // 输出 "HELLO"1.
2.
3.
4.
5.
6.
7.
8.
9.

在上面的例子中，let函数将字符串转换为大写，并截取前5个字符，最终结果为HELLO。

let函数是Kotlin中非常有用的一个作用域函数，可以简化代码并提高可读性。

run

run作用域函数是一个高阶函数，它可以在指定的上下文中执行代码块，并返回最后一个表达式的结果。run函数的语法如下：

run(block: T.() -> R): R

obj.run {
    // 在这里可以使用this关键字引用obj对象
}1.
2.
3.
4.
5.

其中 block是要执行的代码块，T是上下文对象的类型，R是代码块的返回类型。

使用run函数可以方便地在一个对象的上下文中执行多个操作，而不需要重复引用对象的名称。例如：

val person = Person("Alice", 25)

val result = person.run {
    println("Name: $name")
    println("Age: $age")
    age + 1
}

println("Result: $result")1.
2.
3.
4.
5.
6.
7.
8.
9.

在上面的例子中，我们创建了一个Person对象，并使用run函数在该对象的上下文中执行了两个操作：打印出姓名和年龄，并返回年龄加1的结果。最后，我们打印出了结果。

请注意，run函数的返回值是代码块的最后一个表达式的结果。在上面的例子中，run函数返回了age + 1的结果。

with

with作用域函数允许你在一个特定的上下文中执行一系列操作，而无需重复引用该上下文对象。

with函数的语法如下：

with(obj) {
    // 在这里可以使用obj的成员函数和属性
    // 进行一系列操作
}1.
2.
3.
4.

在with函数的代码块中，你可以直接使用obj的成员函数和属性，而无需重复使用对象名来引用它们。这样可以使代码更加简洁和易读。

示例代码：

data class Person(val name: String, var age: Int)

fun main() {
    val person = Person("Alice", 25)
    
    with(person) {
        println("姓名：$name")
        println("年龄：$age")
        age += 1
    }
    
    println("年龄增加后的值：${person.age}")
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

输出结果为：

姓名：Alice
年龄：25
年龄增加后的值：261.
2.
3.

在上面的示例中，我们使用with函数来操作person对象。在with函数的代码块中，我们可以直接使用name和age属性，而无需重复使用person对象名来引用它们。同时，我们还可以修改age属性的值，这样会直接影响到person对象。

apply

apply作用域函数允许你在一个对象上执行一系列操作，并返回该对象本身。它的语法如下：

object.apply {
    // 在这里执行一系列操作
}1.
2.
3.

使用apply函数可以方便地对一个对象进行初始化或者配置。在apply的代码块中，你可以调用对象的方法、设置属性等。最后，apply函数会返回该对象本身，这样你可以继续对该对象进行其他操作。

示例代码：

val person = Person().apply {
    name = "Alice"
    age = 25
    setAddress("123 Main St")
}1.
2.
3.
4.
5.

在上面的示例中，我们创建了一个Person对象，并使用apply函数对其进行了初始化。在apply的代码块中，我们设置了name和age属性，并调用了setAddress方法。最后，apply函数返回了该对象本身，我们可以继续对其进行其他操作。

使用apply函数可以简化代码，特别是在需要对一个对象进行多个操作时。可以提高代码的可读性和可维护性。

also

also作用域函数允许你在对象上执行一些操作，并返回对象本身。它的语法如下：

inline fun <T> T.also(block: (T) -> Unit): T

obj.also {
    // 在这里可以使用it来引用obj对象
}1.
2.
3.
4.
5.

使用also函数，你可以在对象上执行一些操作，例如打印日志、修改属性等。这个函数会返回对象本身，因此你可以在链式调用中使用它。

示例代码：

val list = mutableListOf(1, 2, 3)

list.also {
    println("原始列表：$it")
    it.add(4)
    it.remove(2)
}.also {
    println("修改后的列表：$it")
}1.
2.
3.
4.
5.
6.
7.
8.
9.

输出结果为：

原始列表：[1, 2, 3]
修改后的列表：[1, 3, 4]1.
2.

在上面的示例中，我们使用also函数在list对象上执行了两个操作：添加元素4和移除元素2。同时，我们还在每个操作之前打印了相关的日志。最后，我们打印了修改后的列表。

also函数是一个非常有用的作用域函数，它可以让你在对象上执行一些操作，并返回对象本身。这在链式调用和调试过程中非常有用。

使用及适用场景

作用域函数可以在特定的上下文中执行代码块，并且可以方便地访问上下文对象。

(1) let函数：let函数将上下文对象作为参数传递给代码块，并返回代码块的结果。它适用于需要对对象进行非空判断或者进行链式调用的场景。

val result = someObject?.let {
    // 对非空对象进行操作
    // 返回操作结果
}1.
2.
3.
4.

(2) run函数：run函数将上下文对象作为接收者（this）传递给代码块，并返回代码块的结果。它适用于需要在上下文对象上执行多个操作的场景。

val result = someObject.run {
    // 在上下文对象上执行操作
    // 返回操作结果
}1.
2.
3.
4.

(3) with函数：with函数将上下文对象作为参数传递给代码块，并返回代码块的结果。它类似于run函数，但是不使用扩展函数的方式调用。

val result = with(someObject) {
    // 在上下文对象上执行操作
    // 返回操作结果
}1.
2.
3.
4.

(4) apply函数：apply函数将上下文对象作为接收者（this）传递给代码块，并返回上下文对象本身。它适用于需要在创建对象后立即对其进行初始化的场景。

val someObject = SomeObject().apply {
    // 对对象进行初始化操作
}1.
2.
3.

(5) also函数：also函数将上下文对象作为参数传递给代码块，并返回上下文对象本身。它类似于apply函数，但是不使用扩展函数的方式调用。

val someObject = SomeObject().also {
    // 对对象进行初始化操作
}1.
2.
3.

作用域函数可以提高代码的可读性和简洁性，适用于各种场景，如链式调用、对象初始化等。根据具体的需求和编码风格，选择合适的作用域函数可以使代码更加清晰和易于维护。