Kotlin 作用域函数之let、with、run、also、apply的使用笔记

文章目录

• • • 作用域函数
    • • let
      • with
      • run
      • also
      • apply
      • 总结
    • takeIf 与 takeUnless
    • • takeIf结合let使用
    • 资料

作用域函数

Kotlin 标准库包含几个函数，目的是在对象的上下文中执行代码块。当对一个对象调用这样的函数并提供一个 lambda 表达式时，会形成一个临时作用域。在此作用域中，可以访问该对象而无需其名称。这些函数称为作用域函数。共有以下五种：let、run、with、apply 以及 also。

作用域函数区别

• 引用上下文对象的方式

引用上下文对象的方式	作用域函数
it	let、 also 可以用it ，主要用做lambda表达式中的参数
this	run、 with、 apply 通过this引用上下文对象，当访问类中的变量或方法时，可以使用this，也可以省略

• 函数返回值

返回值	作用域函数
返回上下文对象	apply、 also返回上下文对象
返回表达式结果	let 、run、 with 返回lambda表达式结果，其中表达式也可以没有结果

let

let常用的两个作用：一是定义对象在特定的作用域范围内，另一个更常用的场景是对对象执行 xxx ?.let{ }，在 lambda 表达式中执行 *** 作，以一种更优雅的形式来判空。

 fun letFunc() {
    //let{}中可以使用it来代表intList对象
    val intList: List = arrayListOf(1, 2, 3)
    intList.let {
        println(it.size) //3
        println(it.lastIndex) //2
    }

    //通过?.let{}进行判断，如何为空，后面就不会再执行
    val list2: List? = null
    list2?.let {
        println(it.size)
    }
 }

with

 fun withExam(person: Person = Person("xmkp", 18, 1)) {
     //将person对象以参数的方式传递到Lambda表达式中
     with(person) {
         println(name)
         println(age)
         println(sex)
     }
 }
 
data class Person(var name: String, var age: Int, var sex: Int)

非扩展函数with(){}的使用，一般不需要用返回值， 而是将上下文对象作为参数传递到Lambda表达式中，典型应用是对一个对象在Lambda表达式中调用它的多个函数时使用，如with(RecyclerView.Holder){} 。

run

run和with的作用基本一致，run可以以扩展函数的方式调用，通用场景：当表达式中同时包含对象初始化及返回值计算时使用。

 fun runExam() {
     val list = arrayListOf(1, 2, 3)
     val size = list.run {
         list.add(4) //添加一条数据
         list.size  //返回最终的size
     }
     println("list.size:$size") //执行结果：list.size:4
 }

also

also通常执行将上下文对象作为参数的 *** 作，返回值是上下文对象本身。lambda表达式中用it来表示上下文对象，可以将also理解为并且用该对象执行以下 *** 作

 fun alsoExam() {
     val list = arrayListOf(1, 2, 3)
     list.also {
         println("添加前：$list")
     }.add(4)
     println("添加后：$list")
 }
    
 //执行结果：
 // 添加前：[1, 2, 3]
 // 添加后：[1, 2, 3, 4]

apply

lambda表达式中不返回值，且主要是对对象成员进行 *** 作的场景使用apply。典型使用场景：对象的配置，可以将apply理解为将以下赋值应用于对象。

 fun applyExam() {
     val person = Person().apply {
         //给Person对象设置属性
         name = "xxx"
         age = 30
         sex = 1
     }
     println(person) // 执行结果：Person(name=xxx, age=30, sex=1)
 }

总结

作用域函数	上下文对象	返回值	使用场景
let	it	表达式结果，也可不返回	1、定义对象在特定的作用域范围内; 2、对象执行 xxx ?.let{ }来判空
with	this	表达式结果，也可不返回	对一个对象在Lambda表达式中调用它的多个函数时使用，如with(RecyclerView.Holder){}
run	this	表达式结果，也可不返回	当表达式中同时包含对象初始化及返回值计算时使用
also	it	上下文对象	附加效果，相当于并且对该对象执行以下 *** 作
apply	this	上下文对象	lambda表达式中执行对象的配置，可以理解为**将以下赋值应用于对象

takeIf 与 takeUnless

takeIf、takeUnless 函数可以以链式调用的方式进行对象状态检查，是单个对象的过滤函数。个人认为可以简单理解成是对if/else的链式调用。使用规则：

• takeIf： 如果takeIf后面的表达式或闭包符合要求，则takeIf返回此对象；否则返回null。
• takeUnless：与takeIf用法相反，如果takeUnless不匹配后面的表达式或闭包，则返回该对象；否则返回null。

使用举例：

 fun takeXXFunc() {
     val num = Random.nextInt(100)
     val evenOrNull = num.takeIf { it % 2 == 0 } //结果为偶数 或 null
     val oddOrNull = num.takeUnless { it % 2 == 0 } //结果为奇数 或 null
     print("evenOrNull：$evenOrNull, oddOrNull：$oddOrNull")
    }

执行结果：

//奇数：evenOrNull：null, oddOrNull：69
//偶数：evenOrNull：4, oddOrNull：null

takeIf结合let使用

 /**
  * takeIf结合let使用
  */
 fun takeIfExam() {
     val list = arrayListOf(1, 2, 3)
     list.takeIf { it.size < 4 }?.let {
         println("list:$list")
     }
 }

执行结果：

list:[1, 2, 3]

如果改为val list = arrayListOf(1, 2, 3, 4)，则takeIf判断不成立，直接返回null，后面就不会再执行了。

资料

【1】https://www.kotlincn.net/docs/reference/scope-functions.html