Kotlin学习笔记之标准库函数

package com.example.firstkotlin.koltin

import java.io.File

/**
 * 项目名称 firstKotlin，标准库函数
 * 创建时间 12/29/21 9:45 PM
 *
 **/
class apply {
}


fun main(){

    runFun()
    alsoFun()
}

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

fun applyFunc(){
   val file1 = File("E:..../name.txt")
   file1.setReadable(true)
   file1.setWritable(true)
   file1.setExecutable(true)
   
   // 等价于 on 1/1/22 3:17 PM
   val file2 = File("E:..../name.txt").apply {
       // 通过隐式调用（this）的方式执行每一个函数 on 1/1/22 3:22 PM
       setReadable(true)
       setWritable(true)
       setExecutable(true)
   }
   // 在lambda表达式中，apply能让每个函数都作用于接收者，
   // 这种行为又叫做相关作用域，此时lambda表达式中的所有函数都是针对接收者的
   // apply函数最终会返回接收者的对象    on 1/1/22 3:20 PM
}

• 1、let函数能使某个变量以it关键字引用的方式传递到lambda表达式中。
• 匿名函数执行完成之后，let函数会返回匿名函数中最后一行。
• 2、更多的是和可控类型搭配使用

fun letFun(){

    // 计算list中的第一个索引处的数值的平方 on 1/1/22 3:26 PM
    val list = listOf(3,2,1).first().let {
        it * it
    }
    /**
     * let函数与apply函数的不同之处：
     * 1、let会将变量传递到匿名函数内部，通过it关键字引用，
     *  而apply不会传递变量对象，匿名函数内部通过this关键字隐式调用函数
     * 2、let函数执行完成之后，会返回匿名函数的最后一行，而apply返回的是this关键字所表示的对象
     */
}

• run函数
• 1、和apply函数类似，唯一的不同是run不返回接收者对象，返回的是匿名函数的执行结果，即最后一行的结果

fun  runFun(){
    val list = listOf(3,2,1)
    val result = list.run {
        contains(3)
    }
    val result1 = list.run {
        contains(5)
    }
    println(result) // true on 1/1/22 3:34 PM
    println(result1) // false on 1/1/22 3:34 PM

    // 使用run函数来执行我们的函数引用 on 1/1/22 3:40 PM
    val number = 100

    fun isGood(score:Int) = 100 > 60
    fun saySomeThing(isGood:Boolean):String{
        if(isGood){
            return "太棒了"
        }else{
            return "继续努力"
        }
    }
    fun printIt(content:String){
        println(content)
    }

    number
        .run(::isGood)
        .run(::saySomeThing)
        .run(::printIt)   // 太棒了 on 1/1/22 3:45 PM

    /**
     * run函数和let函数的相同点：都是返回匿名函数的执行结果
     * run函数和apply函数的相同点，在匿名函数内部，通过this关键字进行隐式调用
     */
}

• with函数
• with函数是run函数的变体，他们的功能行为是一样的，唯一的不同之处在于使用with时，需要值参作为其第一个参数传入。

fun withFun(){
    val list = listOf(3,2,1)
    with(list,{
        contains(3)
    })
}

• also函数
• also函数和let函数功能类似，唯一的不同点是：
• also函数返回的是调用者的对象，let函数返回的是匿名函数的执行结果

fun alsoFun(){
    var number = 100
    number.also {
        number = number + 100
    }.also {
        number = number - 200
    }
    print(number)
}

• takeif
• takeif需要判断lambda中提供的条件表达式，给出true或者false，如果判断结果是true，
• 从takeif函数返回接收者对象，如果是false，返回null。
• 应用场景：
• 如果需要判断某个条件是否满足，才决定是否赋值或者执行某项任务。

fun takeifFun(){
    // 如果这个文件存在并且可读，返回文件对象，然后去读取文件 on 1/1/22 4:17 PM
    File("E:..../name.txt").takeIf {
        it.exists() && it.canRead()
    }?.readText()
}

• takeUnless
• 与takeif刚好相反，只有判定条件为false时，才会返回接收者对象

fun takeUnlessFun(){
    File("E:..../name.txt").takeIf {
        it.exists() && it.canRead()
    }?.takeUnless { 
        // 文件未被隐藏时，才会返回文件对象 on 1/1/22 4:20 PM
        it.isHidden
    }?.readText()
}