Kotlin标准函数库学习

apply：apply 函数可看作一个配置函数：你可以传入一个接收者，然后调用一系列函数来配置它以便使用。如果提供lambda 给apply 函数执行，它会返回配置好的接收者。

apply 可以用在初始化时，的不断引用的情况。

//原始代码
val person = Person()
person.name = "John"
person.age = 30

//优化后的代码
val person = Person().apply {
    name = "John"
    age = 30
}

let：let 函数能使某个变量作用于其lambda 表达式里，让it 关键字（详见第5 章）能引用它。

//1. 非空检查 (Null Checks)
val str: String? = "Hello"
if (str != null) {
    println(str.length)
}

val str: String? = "Hello"
str?.let {
    println(it.length)
}

//2. 数据转换并返回一个新值
fun convertToInt(value: String): Int {
    val intValue = Integer.parseInt(value)
    return intValue * 2
}

fun convertToInt(value: String): Int {
    return value.let { Integer.parseInt(it) * 2 }
}

//3.可以避免临时变量
val name: String? = getName()
val length: Int
if (name != null) {
    length = name.length
} else {
    length = 0
}
println("Length is $length")

val name: String? = getName()
val length = name?.let { it.length } ?: 0
println("Length is $length")

//4. 链式调用
data class User(val name: String, val age: Int)

fun processUser(user: User?) {
    user?.let {
        println("Processing user ${it.name}, age ${it.age}")
    }?.run {
        // 进一步处理...
    }
}

run：光看作用域行为，run 和apply 差不多。但与apply 不同，run函数不返回接收者。比较用run 的链式调用和以下嵌套语法

//1. 初始化带有逻辑的对象
val person = Person()
person.name = if (someCondition) "John" else "Jane"
person.age = calculateAge()

val person = Person().run {
    name = if (someCondition) "John" else "Jane"
    age = calculateAge()
    this // 如果需要返回这个对象本身
}

//2. 局部作用域，避免创建临时变量
fun calculate(): Int {
    return run {
        val a = 5
        val b = 10
        a + b
    }
}
//3. 非空判断与操作
val str: String? = "Hello"
str?.run {
    println(length)
}
//4. 配置对象并返回结果
val result = TextView(context).run {
    textSize = 16f
    setTextColor(Color.BLACK)
    setPadding(10, 10, 10, 10)
    textSize // 返回配置后的textSize
}

with：是run 的变体。它们的功能行为是一样的，但with 的调用方式不同。和之前介绍的标准函数都不一样，调用with 时需要值参作为其第一个参数传入。

        val nameTooLong = with("Polarcubis, Supreme Master of NyetHack") {
            length >= 20
        }.run(::println)

also：和let 函数功能相似。和let 一样，also 也是把接收者作为值参传给lambda。但有一点不同：also 返回接收者对象，而let 返回lambda 结果。

        var fileCOntents: List<String>
        File("file.txt").also { println(it.name) }
            .also { fileCOntents = it.readLines() }

和 apply 类似，不过引用时使用 it。

takeIf：和其他标准函数有点不一样，takeIf 函数需要判断lambda中提供的条件表达式（叫predicate），给出true 或false 结果。

        val fileContents = File("myfile.txt")
            .takeIf { it.canRead() && it.canWrite() }
            ?.readText()

//        val file = File("myfile.txt")
//        val fileContents = if (file.canRead() && file.canWrite()) {
//            file.readText()
//        } else {
//            null
//        }

takeUnless：。takeUnless 和takeIf 唯一的区别是：只有判断你给定的条件结果是false 时，takeUnless 才会返回原始接收者对象。

val fileContents = File("myfile.txt").takeUnless { it.isHidden }?.readText()