Kotlin 中的 lateinit 、lazy、let 、apply 、also 、takeif、takeUnless

前提

Kotlin和Groovy等语言一样，支持闭包(block)，如果函数中最后一个参数为闭包，那么最后一个参可以不写在括号中，而写在括号后面，如果只有一个参数，而在之后的调用中参数没有被调用，则括号也可以去掉。

viewPager.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

            }
       });      

那么在 Kotlin 中，我们可以得到如下代码

view.setOnClickListener ({
        print("name")
    })

只有一个参数，括号可以去掉

view.setOnClickListener {
        print("name")
    }

---

lateinit 、by lazy

在 Kotlin 中 lateinit 和 lazy 是两种不同的延迟初始化 技术。

• lateinit 只用于 var，而 lazy 只用于 val

• lazy 应用于单例模式(if-null-then-init-else-return)，而且当且仅当变量被第一次调用的时候，委托方法才会执行。

• lateinit 则用于只能生命周期流程中进行获取或者初始化的变量，比如 Android 的 onCreate()

• lateinit 只能修饰非 kotlin 基本类型，在 kotlin 中会以 null 初始化由lateinit 修饰的变量，而基础类型没有null 。

• 使用 lateinit 修饰的变量，在使用时不必使用 ?或 !! 修饰，但是必须在第一次使用时保证为变量赋初值，不然程序会报出空指针异常。

• 使用 by lazy 修饰的变量：

val name by lazy{
	name.....
} 

在第一次使用 name 时，会执行闭包中的代码对变量 name 进行初始化。

let

以当前这个对象作为闭包的 it 参数，返回值是函数里面最后一行，或者指定 return 。

var str = listof(3,3,6)
fun main(args: Array){
	str.let{
	  println(it)
	  println(it)
	  return
	}
}

打印记录：

[3, 3, 6]
[3, 3, 6]

repeat

重复执行闭包里面的内容

repeat(3){
   println("name")
}

打印信息如下：

name
name
name

with

Calls the specified function block with the given receiver as its receiver and returns its result.

使用给定接收器作为接收器,调用指定的功能块并返回其结果。

它是将某对象作为函数的参数，在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式。

val name  = with("mike"){
	print(this)
	"Job"
}
print(name)

// 日志
mike
Job

apply

调用某对象的 apply 函数，在该函数的范围内，可以使用该对象的任意函数，并且返回该对象。

 ArrayList().apply {
        add(1)
        add(2)
        add(3)
        println(this)
    }.let { println(it) }

打印结果：

[1, 2, 3]
[1, 2, 3]

run

run 函数的使用基本和 apply 函数相同，唯一不同的是，run 函数的返回值由最后一行决定，而 apply 函数返回该对象。

ArrayList().run {
        add(1)
        add(2)
        add(3)
        println(this)
        get(1)
    }.let { println(it.toString() + "3535") }

打印日志：

23535

also

执行闭包，返回调用对象 this。

ArrayList().run {
        add(1)
        add(2)
        add(3)
        println(this)
        get(1)
    }.also {
        println(it)
        it + 2
    }.let { println(it) }

执行结果

[1,2,3]
2
2

最后一个 2 的得到原因为：also 函数为执行闭包中操作后返回 this，那么在此处 this 便是在 run 函数中返回的元素 – 2。

takeif

如果 满足 闭包中的条件返回调用对象，否则返回 null 。

4.takeIf {
        it > 3
    }.let {
        println(it)
    }

执行结果

4
如果具体代码如下：

2.takeIf {
        it > 3
    }.let {
        println(it)
    }

则执行结果为

null

takeUnless

如果 不满足 闭包中的条件返回调用对象，否则返回 null 。
与 takeif 中相同的例子，得到的结果正好是相反的。