kotlin:高阶函数

kotlin高阶函数也是函数

第一次看到这个词的时候，我以为是什么神奇的东西，以为是系统提供实习特殊功能的函数，或者提高执行效率的函数框架。简单而言的话，高阶函数就是将函数作为参数或者返回值的函数。这么看来就非常像C语言中的函数指针了。如果老早就习惯java8 lambda表达式的使用，对这一概念也更容易理解。如果读者有使用过kotlin标准函数的话，那么早就接触过高阶函数了：因为kotlin标准函数都是高阶函数。

基本规则

函数作为参数该如何表达呢？
如果参数是基本类型或者其他什么类，我们可以很容易的声明参数类型，那么函数类型该如何作为参数来声明呢？下面这行是函数类型的基本格式，后面我们会进一步在实例中去运用。
(Int, Int) -> Unit
这个非常容易理解，箭头左边括号内的东西为参数列表，箭头右侧为返回值的类型。完整的展示了一个函数所有的特征。举个例子吧：

fun lizi_1(func: (Int, Int) -> Int) {
    println("func(1,2)的运算结果是：${func(1, 2)}")
}

可以看到函数类型的参数的使用也非常简，名称后面加个括号并传入要求的参数类型，完全像使用普通函数一样。至于这个函数是做什么的，就需要我们在传入具体函数类型的参数时去实现了。
这里我们简单的调用下上面这个“lizi_1”，看下高阶函数是如何使用的。

fun plus(num1: Int, num2: Int): Int {
    return num1 + num2
}
fun main() {
    lizi_1(::plus)
}

可以看到，我们先定义了一个参数列表以及返回值和前文中函数类型“(Int, Int) -> Int”完全匹配的函数，然后通过“::plus”将该函数的引用作为参数传递给“lizi_1”函数。现在我们直接运行下程序，控制台将打印出”func(1,2)的运算结果是：3“。

高阶函数中lambda表达式的使用

上面看起来如果每次使用高阶函数时，都需要写一个完整的方法，这样还是很麻烦的。而lambda表达式刚好和函数类型的格式极其相似，且也有参数列表，返回值这类的关键信息，所以可以直接使用lambda表达式作为高阶函数的参数去使用：

fun main() {
    lizi_1() { num1, num2 ->
        num1 + num2
    }
}

内联函数inline

通过观察kotlin文件的字节码，我们可以看到无论是“::plus”形式还是lambda表达式都是通过创建了一个包含plus方法的class，然后在调用时，创建该class的对象，调用该对象的plus方法。也就是说其中包含的创建对象的开销，但大多数情况下，这种开销是没必要的，kotlin新增了内联函数的概念来消除这些额外开销。
内联函数的使用也非常简单，在高阶函数前面加个inline就好了：

inline fun lizi_2(func: (Int, Int) -> Int) {
    println("func(1,2)的运算结果是：${func(1, 2)}")
}

这是再去看kotlin字节码，我们可以发现：它相当于将“lizi_2”函数内的代码直接“搬”到main函数中，且plus方法也没有再通过class去包装，而是直接在调用plus方法的地方执行plus内部的代码。
上面非内联的高阶函数转换为内联函数后，该逻辑的字节码的具体内容就会变成（当然实际的字节码和下面展示的还有较大区别，除了格式易于理解外字符串模板也只是kotlin源码的形式）：

//这个是lambda的形式转化为字节码
main() {
    println("func(1,2)的运算结果是：${1 + 2)}")
}

//这个是“::plus”的形式转化为字节码
fun plus(num1: Int, num2: Int): Int {
    return num1 + num2
}
main() {
    println("func(1,2)的运算结果是：${plus(1, 2)}")
}

可以看到这一过程没有了创建对象所带来的额外开销。
关于内联函数和非内联函数的区别除了上述不同外还有一个重要的地方，就是关于lambda表达式中return的使用。如下非内联函数在lambda表达中无法直接使用return但是可以使用return@方法名的方式来提前结束该lambda函数。

fun lizi_3(func: (Int, Int) -> Int) {
    println("func(9,2)的运算结果是：${func(9, 2)}")
    println("lizi 结束")
}
main(): Int {
    lizi_3() { num1, num2 ->
        if(num1 + num2 > 10) {
            //这里使用return 10会报错
            return 10
            //return@lizi_3表示结束本lambda函数，跳转回lizi_3函数接着执行下面的代码
            return@lizi_3 10
        }
        println("lambda 结束")
        num1 + num2
    }
    println("main 结束")
}

为什么非要“return@方法名”这样写呢？其实如果所有高阶函数中的lambda函数的return都表示结束该lambda函数，那么也就不用“return@方法名”这么麻烦的方式了。但要知道内联函数的实际执行过程不同于非内联函数。它不会创建对象，而是单纯的替换代码，这就使得在内联的lambda函数中return的作用域更应该是代码替换后的区域。如上面的代码倘若函数“lizi_3”是内联函数的话那“return 10”这行代码不会报错，且执行后会直接结束main函数，println("main 结束")也不会执行。当然内联函数也可以通过“return@方法名”的方式，达到结束lambda函数的效果。

noinline和crossinline

编程有时候会有这种需求：一个高阶函数，需要两个函数类型参数，其中一个可以用内联函数模式，另一个不适合。这种情况下就需要用到“noinline”关键字了：

inline fun lizi_4(func1: (Int, Int) -> Int, noinline func2: (Int, Int) -> Int) {
    println("func1(1,2)的运算结果是：${func1(1, 2)}")
    println("func2(1,2)的运算结果是：${func2(1, 2)}")
}

如上在不想要内联的函数前加上“noinline”关键字就好了。
内联函数和非内联函数，区别不仅仅只是return的区别，（return是最关键的区别，其他差异基本是由此引发的）。由此引发的重要的区别还有，非内联函数可以作为一个函数类型参数再次传递给其他高阶函数，而内联函数由于仅仅是代码块所以无法作为参数传递给其他非内联函数的高阶函数。那岂不是只要内联函数的lambda中不使用return关键字不就可以当作参数再次传递了？确实是这样的，如何保证该函数不使用return呢，kotlin提供了crossinline关键字来约定好该lambda函数不会使用return，这样它就可以作为参数传递给其他高阶函数了。

inline fun lizi_5(func1: (Int, Int) -> Int, noinline func2: (Int, Int) -> Int, crossinline func3: (Int, Int) -> Int) {
    //lizi_3(func1)会报错
    lizi_3(func1)
    //lizi_3(func2)不会报错
    lizi_3(func2)
    //lizi_3(func3)由于crossinline约定好func3不会使用return关键字，所以不会报错
    lizi_3(func3)
}

还有需要说明的是：crossinline和普通的内联lambda函数的区别仅仅是不能使用return，其他特性完全一致。