Kotlin 内联函数语法之let、apply、also、run、with的用法与详解

一、介绍

kotlin的语法千奇百怪，今天我们将介绍项目中频率使用比较高的几个内联函数。

二、什么叫内联函数？

内联函数 的语义很简单：把函数体复制粘贴到函数调用处 。使用起来也毫无困难，用 inline关键字修饰函数即可。

语法：

inline fun 函数名(){
}

介绍：

        在正常定义的函数最前面通过inline修饰一下，不管你在哪里调用了内联函数，该函数体内的方法都会被插入到调用出。

实战与分析：

class TestInline {

    inline fun log(msg: String) {
        System.out.println("show log=${msg}")
    }
    
    fun printLog() {
        log("I am working")
    }
}

fun main() {
    val  tt=TestInline()
    tt.log("aaaa")

}

kotlin编译后的结果：

 

 

分析：

        通过kotlin的源码与翻译后的对比发现，只要调用了内联函数，内联函数体的代码会被复制到调用处。

        通过以上对比我们大概了解到内联函数的作用，其实对于我的分析，如果内联函数体很大，被到处引用，就会编译出特别多的多余代码，这个方式与方法的抽取调用有什么好处？目前我并没有发现这种方式的特别之处，唯一的好处就是在kotlin译码后，在结果中更方便阅读。

三、高频常用let、apply、also、run、with的介绍与使用

let、apply、also、run、with都是内联函数，但是通过使用有所不同，接下来我们做详细的分析与介绍

1、let

@kotlin.internal.InlineOnly
public inline fun  T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

从源码中可以分析，有两个泛型，一个是自身，一个是结果

所以在调用返回值传的是this，自身，返回值可以是任意类型。常见的用法就是通过对象

aa?.let这种执行。

常用的两种：

1.需要用到对象自身aa?.let{},免去对变量的判空

    var aa: String? = "text-"
    //创建TestKKK对象，aa作为变量复制，返回tt
    val aaa = aa.let {
        val tt=TestKKK()
        tt.name=it
        tt
    }

    //返回aa的长度
    val length=aa?.let {
        it.length
    }

2.apply

public inline fun  T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

apply的用法是返回调用参数类型一样的变量。

常见的用法：

1.初始化

    tt?.apply {
        tt = TestKKK()
        tt!!.name = "nodify"
        tt
    }

2.修改变量参数

    tt?.apply {
        tt!!.name = "nodify"
        tt
    }

3.also

public inline fun  T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}

also的语法和apply使用类似，在block高阶函数中接受自己，但是，block不接受返回值，也就是说，你无法通过also去做初始化的工作。如果一个对戏是null，那么在使用also的使用，会报空指针

    var talso: TestKKK? = null
    talso=talso?.also {
        talso=TestKKK()
        talso!!.name = "0000"
        talso
    }
    Log.log("also=${talso!!.name}")

 所以，也就是说，变量自身的内存地址不接受also体修改，also只能修改变量的属性。

4.run

public inline fun  T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

run的用法比较随意。它返回任意类型，即使自身为null也可以执行返回结果。

    var trun: TestKKK? = null
    val run1 = trun.run {
        "Hello"
    }

    Log.log("run1 is String=${run1}")

    val run2 = trun.run {
        trun = TestKKK()
        trun!!.name = "run"

        trun
    }
    Log.log("run2 is TestKKK=${run2!!.name}")

返回类型取决于block代码快最后一行的参数，如果最后一行有返回值就是该返回的类型

5.with

public inline fun  with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

with的用法是接受一个参数，然后返回任性参数类型。接受的参数将会是block函数体的参数。

    val with = with(run3) {
        run2.name = run3.toString()
        run2
    }
    Log.log("with is TestKKK=${with.name}")

四、总结

        通过以上的学习，从一开始的内联函数是什么到如何定义，以及译码后函数体的变化，都做了一次普及。最后就是我们常见的let、apply、also、run、with语法使用。

        这里特别注意的是also的用法，由于also无法在block体做对象的初始化工作，所以在工作中，尽量少使用block，避免出现空指针。

        如果需要初始化，可以使用apply，如果使用当前变量返回任意类型使用with、run与let。

apply：不要使用?去做空的拦截，特别在出初始化，否则初始化永远都不会执行

五、返回类型

1.返回自身的：apply与also，返回this，但是also如果是null，返回就是null，即使你在block初始化也没用

2.其他返回类型取决于block的最后一行代码，如果最后一行是变量、或者属性的get或者方法有返回值，那么久有返回值，否则为unit。