介绍

Kotlin是函数式编程，所以可以把函数作为参数传递给函数，或者作为函数的返回值使用，我们称其为高阶函数。本篇文章就带着大家由浅入深的介绍一下高阶函数。

函数类型

我们可以定义一下常量，常量的类型是一个函数，实现是一个Lambda表达式。

fun main() {
    val test:(String)->Unit={
        println(it)
    }

    test("你好")
}

我们运行后可以打开AS的工具栏中的View->Show Bytecode 查看编译后的字节码，其中重要的部分如下

...
   L0
    LINENUMBER 4 L0
    GETSTATIC com/kotin/chapter/TestKt$main$test$1.INSTANCE : Lcom/kotin/chapter/TestKt$main$test$1;
    CHECKCAST kotlin/jvm/functions/Function1
    ASTORE 0
   L1
    LINENUMBER 8 L1
    ALOAD 0
    LDC "\u4f60\u597d"
    INVOKEINTERFACE kotlin/jvm/functions/Function1.invoke (Ljava/lang/Object;)Ljava/lang/Object; (itf)
    POP
...

其中CHECKCAST和INVOKEINTERFACE 的方法调用都 说明(String)->Unit是Function1类型。其实函数的类型定义报名为 kotlin.jvm.functions 下定义了很多接口，而且我们每次写的类似(String)->Unit都是这些接口的具体实现类。

函数作为函数的参数使用

函数作为函数的参数使用，一般在Android中定义CallBack接口只有一个抽象函数的时候，可以省略接口，定义函数类型作为参数传递给函数。比如

fun main() {
    handle("jawe"){
        println(it)
    }
}

fun handle(name:String, action:(String)->Unit){
    action(name)
}

关于handle方法调用的时候，如何演变成最简单的写法，这里不在描述，请自行百度。
当一个函数A只有一个函数类型作为参数的时候，如果调用的时候传递的是一个具名函数B，而且函数B的类型和函数A的参数类型一样，那么可以简写成函数引用。比如

fun main(args:Array<String>) {
    args.forEach(::println)//包级函数的引用
}

我们可以点进去看一下forEach函数的签名

fun main(args:Array<String>) {
    args.filter(String::isNotBlank) //类名引用的函数默认有一个参数是this
}

forEach只有一个参数action类型是(T) -> Unit
我们再去看一下println函数的定义

public actual inline fun println(message: Any?) {
    System.out.println(message)
}

println接口一个Any类型的参数，其中Any是Kotlin中所有类的基类（和Java中的Object一样），返回值是Unit，和forEach的参数类型是一样的所以可以使用引用，println是包下的顶级函数，所以引用方式是::println
那么类的函数的引用怎么写呢？我们继续向下看

fun main(args:Array<String>) {
    args.filter(String::isNotBlank) //类名引用的函数默认有一个参数是this
}

同样我们分别看一下filter和isNotBlank的定义

public inline fun <T> Array<out T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

filter是数组的扩展函数，接受的参数是一个(T) -> Boolean的函数类型

public inline fun CharSequence.isNotBlank(): Boolean = !isBlank()

isNotBlank也是一个扩展函数，函数的返回值是一个Boolean，但是函数没有任何接收参数。然而在函数的内部其实是可以接受当前CharSequence实例this的。所以我们可以使用类名引用即String::isNotBlank,类名引用的函数其实有一个默认参数是this。
那么有参数的函数怎么引用的？我们看一下下边的例子

fun main(args:Array<String>) {
    args.forEach(PDFPrinter::printPdf)
}

class PDFPrinter{
    fun printPdf(any:Any?){
        println(any)
    }
}

我们定义了一个PDFPrinter，还有一个函数printPdf。这段代码放到AS是会报如下错误

error.png

如图所示提示类型不匹配，forEach需要的是一个参数的(T)->Unit,但是接收到的是Function2类型（接受两个参数，第一个参数是PDFPrinter实例，第二个参数是Any）的函数。所以这种情况就不能使用类名引用函数，应该使用对象实例引用函数。修改后的代码如下

fun main(args:Array<String>) {
//    args.forEach(PDFPrinter::printPdf)//不能使用类名引用,否则类型不匹配
    args.forEach(PDFPrinter()::printPdf)//这里只能使用类的实例引用

}

关于Kotlin内置的将函数类型作为参数的函数，我们在开发的时候会见到很多。

闭包-函数作为函数的返回值

我们先看以下代码

fun main() {
    val x = makeFun()
    for (i in 1..5) {
        x()
    }
}
fun makeFun():()->Unit{
    var count = 1

    return fun()=println(++count) //返回匿名函数

}

打印的结果如下

makeFun.png

从结果可以看到count进行了累加，而不是永远的2。通常的理解是函数内部定义的都是局部变量，每次进入函数的时候都是重新初始化count，然而这里的结果却不是，那么是怎么回事呢？
还记得我们说过定义的()->Unit都是函数接口的实现类，所以我们可以写的在直白一点

fun makeFun(): Function0<Unit> {
    return object : Function0<Unit> {
        var count = 1
        override fun invoke() = println(++count)

    }
}

看到这里就一目了然了吧，我们在main函数内定义的常量x其实是Function0的实例，所以在for循环内只是对x实例的count变量进行了修改。

复合函数

我们上高中的时候学过复合函数，关于复合函数的定义参看百度百科，复合函数的公式是y=f[g(x)]，即一个函数的值作为另一个函数的参数，这个在开发中应该经常用到，比如

val add5:(Int)->Int = { a: Int -> a + 5 }
val multiplyby2:(Int)->Int = {b:Int->b*2}

fun main() {
    println(multiplyby2(add5(3)))
}

函数add5的值作为multiplyby2的参数使用。我们可以基于这种思想写一个通用的复合函数：

infix fun <P1, P2, R> Function1<P2, R>.compose(func: Function1<P1, P2>): Function1<P1, R> {
    return fun(p: P1): R {
        return this.invoke(func.invoke(p))
    }
}

infix定义一个中缀表达式，Function1的扩展函数compose接收一个Function1参数，返回一个Function1类型的值，即如果通过P1得到R的时候，但是P1需要经过处理转换成P2,然后在处理P2得到R。
如何使用呢？如下所示

fun main() {
    val compose = add5 compose multiplyby2
    println(compose(5))
}

颗粒化

currying 颗粒化，指将一个多参数的函数拆封成一系列的单个参数的函数。这么讲有点抽象，我们还是看具体的例子吧。

fun log(tag:String, target:OutputStream, message:String){
    target.write("$tag, $message \n".toByteArray())
}

fun log(tag:String):(target:OutputStream)->(message:String)->Unit{
    return fun(target:OutputStream):(message:String)->Unit{
        return fun(message:String):Unit{
            target.write("$tag, $message \n".toByteArray())
        }
    }
}

三个参数的函数log，经过颗粒化后的代码成为了一连串单个参数的函数。颗粒化后的代码开起来可能阅读起来比较难，我把它写成通俗点方式：

fun log(tag:String)
 =fun(target:OutputStream)
 =fun(message:String)
 =target.write("$tag, $message \n".toByteArray())

颗粒化函数其实是函数的返回值嵌套函数。
颗粒化的函数使用方式如下：

fun main() {
    log("jawe")(System.out)("Hello World")
}

偏函数

当一些函数的部分参数大部分是固定值的时候，我们可以使用默认参数的实现，但是默认参数实现的方式也有局限性，如果不是最后一个，其他参数在使用的时候就要使用具名参数。那么还有没有其他方式呢？有一种方式是使用偏函数实现。我们先看一个例子：

fun <P1,P2,R> Function2<P1,P2,R>.partial(p2:P2)=fun(p1:P1)=this(p1,p2)//1
//指定其他位置参数默认值的偏函数
val makeString=fun(byteArray:ByteArray, charset: Charset)= String(byteArray, charset)

fun main() {
    //普通函数的偏函数
    val makeString2 = makeString.partial(Charset.forName("UTF-8"))//2
    println(makeString2("我是中国人".toByteArray()))
}

注释1出定义了一个通用的偏函数，即对Function2扩展一个函数（通常这个函数的参数是默认值）得到只有一个参数的函数。
注释2出是具体的使用方式，通过partial得到一个单参数的匿名函数makeString2 。

总结

本篇文章介绍了部分高阶函数，其中颗粒化和偏函数理解起来比较难，而且使用的极少，大家作为扩展知识点学习一下就行。