Kotlin-作用域函數(shù)apply，also，let，run，with，takeIf，takeUnless

什么是作用域函數(shù)

當(dāng)對一個(gè)對象調(diào)用某個(gè)函數(shù)并提供一個(gè) lambda 表達(dá)式時(shí)，它會形成一個(gè)臨時(shí)作用域。在此作用域中，可以訪問該對象而無需其名稱。這些函數(shù)稱為作用域函數(shù)。

作用域函數(shù)的作用

在一個(gè)對象上執(zhí)行一個(gè)代碼塊。

各個(gè)作用域函數(shù)的區(qū)別

一個(gè)對象在代碼塊中如何使用（上下文對象：this or it），以及整個(gè)表達(dá)式的結(jié)果是什么（返回值：上下文對象 or lambda表達(dá)式結(jié)果）。

apply

T.apply(block: T.() -> Unit): T

源碼
//以 "this" 值作為接收者調(diào)用指定的函數(shù) [block] 并返回 "this" 值。
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}
特性
  1. 擴(kuò)展：是擴(kuò)展函數(shù)，擴(kuò)展了所有對象；
  2. 參數(shù)：沒有閉包參數(shù)，使用上下文對象作為接受者this來訪問；
  3. 返回：返回上下文對象本身；
  4. 用途：對象的配置。
示例
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" 值作為參數(shù)調(diào)用指定的函數(shù) [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
}
特性
  1. 擴(kuò)展：是擴(kuò)展函數(shù)，擴(kuò)展了所有對象；
  2. 參數(shù)：有閉包參數(shù)，使用上下文對象作為labmda表達(dá)式的參數(shù)it來訪問；
  3. 返回：返回上下文對象本身；
  4. 用途：可以理解為"并且為該對象執(zhí)行以下操作"，即附加效果。
示例
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" 值作為參數(shù)調(diào)用指定的函數(shù) [block] 并返回其結(jié)果。
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}
特性
  1. 擴(kuò)展：是擴(kuò)展函數(shù)，擴(kuò)展了所有對象；
  2. 參數(shù)：有閉包參數(shù)，使用上下文對象作為lambda表達(dá)式的參數(shù)it來訪問；
  3. 返回：返回lambda表達(dá)式的結(jié)果，即lambda表達(dá)式最后有一行；
  4. 用途：處理數(shù)據(jù)，并可以返回一個(gè)不同類型的值，且可引入作用于受限的局部變量以提高代碼的可讀性，即替換 it。
示例
fun main() {
    val user = User("Peter", 18)
    val letResult1 = user.let {
        it.name = "Linda" //這句表達(dá)式僅對name進(jìn)行了賦值，并不代表任何值，所以該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" 值作為接收者調(diào)用指定的函數(shù) [block] 并返回其結(jié)果。
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
特性
  1. 擴(kuò)展：是擴(kuò)展函數(shù)，擴(kuò)展了所有對象；
  2. 參數(shù)：沒有閉包參數(shù)，使用上下文對象作為接受者this來訪問；
  3. 返回：返回lambda表達(dá)式的結(jié)果，即lambda表達(dá)式最后有一行；
  4. 用途：對象配置并處理數(shù)據(jù)，和 let 很類似，但可以省略 let 的 it 參數(shù)，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

源碼
//調(diào)用指定的函數(shù) [block] 并返回其結(jié)果。
@kotlin.internal.InlineOnly
public inline fun <R> run(block: () -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
特性
  1. 擴(kuò)展：不是擴(kuò)展函數(shù)；
  2. 參數(shù)：沒有閉包參數(shù)，沒有上下文對象；
  3. 返回：返回lambda表達(dá)式的結(jié)果，即lambda表達(dá)式最后有一行；
  4. 用途：在需要表達(dá)式的地方運(yùn)行語句，并獲取返回值。
示例
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] 作為接收者調(diào)用指定的函數(shù) [block] 并返回其結(jié)果。
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}
特性
  1. 擴(kuò)展：不是擴(kuò)展函數(shù)；
  2. 參數(shù)：有參數(shù)，但沒有閉包參數(shù)，上下文對象作為參數(shù)傳遞，但是在lambda表達(dá)式內(nèi)部，它可以作為接收者this使用；
  3. 返回：返回lambda表達(dá)式的結(jié)果，即lambda表達(dá)式最后有一行；
  4. 用途：將上下文對象當(dāng)做參數(shù)來使用。
示例
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
}
特性
  1. 擴(kuò)展：是擴(kuò)展函數(shù)，擴(kuò)展了所有對象；
  2. 參數(shù)：有閉包參數(shù)，使用上下文對象作為lambda表達(dá)式的參數(shù)it來訪問；
  3. 返回：返回如果滿足給定的lambda表達(dá)式的條件，則返回上下文對象this，否則返回null；
  4. 用途：對對象進(jìn)行檢查判斷，并可以嵌套到調(diào)用鏈中。
示例
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
}
特性
  1. 擴(kuò)展：是擴(kuò)展函數(shù)，擴(kuò)展了所有對象；
  2. 參數(shù)：有閉包參數(shù)，使用上下文對象作為lambda表達(dá)式的參數(shù)it來訪問；
  3. 返回：返回如果不滿足給定的lambda表達(dá)式的條件，則返回上下文對象this，否則返回null，與takeIf剛好相反；
  4. 用途：對對象進(jìn)行檢查判斷，并可以嵌套到調(diào)用鏈中。
示例
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)

總結(jié)

函數(shù) 對象引用 返回值 是否是擴(kuò)展函數(shù)
apply this 上下文對象 是
also it 上下文對象 是
let it lambda表達(dá)式結(jié)果 是
run this lambda表達(dá)式結(jié)果 是
run - lambda表達(dá)式結(jié)果 不是：調(diào)用無需上下文對象
with this lambda表達(dá)式結(jié)果 不是：把上下文對象當(dāng)參數(shù)

repeat

上面這些作用域函數(shù)都是位于Standard.kt中，最后說說Standard.kt中另一個(gè)函數(shù)repeat。
repeat(times: Int, action: (Int) -> Unit)

源碼
//重復(fù) [times] 次執(zhí)行給定的功能 [action]。
@kotlin.internal.InlineOnly
public inline fun repeat(times: Int, action: (Int) -> Unit) {
    contract { callsInPlace(action) }

    for (index in 0 until times) {
        action(index)
    }
}
特性
  1. 擴(kuò)展：不是擴(kuò)展函數(shù)；
  2. 用途：對指定的功能 [action] 進(jìn)行重復(fù)執(zhí)行。
示例
fun main() {
    repeat(3) {
        println("執(zhí)行第${it}次")
    }
    //執(zhí)行第0次
    //執(zhí)行第1次
    //執(zhí)行第2次
}
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容