带你初识kotlin（四）

头等函数

头等函数（first-class function）是指在程序设计语言中，函数被当作头等公民。这意味着，函数可以作为别的函数的参数、函数的返回值，赋值给变量或存储在数据结构中。 Kotlin 函数都是头等的，这意味着它们可以存储在变量与数据结构中、作为参数传递给其他高阶函数以及从其他高阶函数返回。可以像操作任何其他非函数值一样操作函数。

高阶函数

高阶函数是将函数用作参数或返回值的函数。

比如集合的[函数式风格的 fold，它接受一个初始累积值与一个接合函数，并通过将当前累积值与每个集合元素连续接合起来代入累积值来构建返回值，fold高阶函数定义如下：

fun <T, R> Collection<T>.fold(
    initial: R, 
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}

在上述代码中，参数 combine 具有函数类型(R, T) -> R，因此fold接受一个函数作为参数，该函数接受类型分别为R与T的两个参数并返回一个R类型的值。在 *for*-循环内部调用该函数，然后将其返回值赋值给accumulator。为了调用fold`，需要传给它一个函数类型的实例作为参数，而在高阶函数调用处，lambda 表达式广泛用于此目的。

val items = listOf(1, 2, 3, 4, 5)

// Lambdas 表达式是花括号括起来的代码块。
items.fold(0, { 
    // 如果一个 lambda 表达式有参数，前面是参数，后跟“->”
    acc: Int, i: Int -> 
        print("acc = $acc, i = $i, ") 
    val result = acc + i
    println("result = $result")
    // lambda 表达式中的最后一个表达式是返回值：
    result
})

// lambda 表达式的参数类型是可选的，如果能够推断出来的话：
val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })

// 函数引用也可以用于高阶函数调用：
val product = items.fold(1, Int::times)

执行结果：

acc = 0, i = 1, result = 1
acc = 1, i = 2, result = 3
acc = 3, i = 3, result = 6
acc = 6, i = 4, result = 10
acc = 10, i = 5, result = 15
joinedToString = Elements: 1 2 3 4 5
product = 120

函数类型

Kotlin 使用类似 (Int) -> String 的一系列函数类型来处理函数的声明： val onClick: () -> Unit = ……。

这些类型具有与函数签名相对应的特殊表示法，即它们的参数和返回值：

所有函数类型都有一个圆括号括起来的参数类型列表以及一个返回类型：(A, B) -> C 表示接受类型分别为 A 与 B 两个参数并返回一个 C 类型值的函数类型。参数类型列表可以为空，如 () -> A。Unit 返回类型不可省略。
函数类型可以有一个额外的接收者类型，它在表示法中的点之前指定：类型 A.(B) -> C 表示可以在 A 的接收者对象上以一个 B 类型参数来调用并返回一个 C 类型值的函数。带有接收者的函数字面值通常与这些类型一起使用。
挂起函数属于特殊种类的函数类型，它的表示法中有一个 suspend 修饰符，例如 suspend () -> Unit 或者 suspend A.(B) -> C。

函数类型表示法可以选择性地包含函数的参数名：(x: Int, y: Int) -> Point。这些名称可用于表明参数的含义。

函数类型的实例化

获得函数类型的实例有以下几种方法：

使用函数字面值的代码块

lambda表达式：{ a, b -> a + b }

匿名函数： fun(s: String): Int { return s.toIntOrNull() ?: 0 }
使用已有声明的可调用引用

顶层、局部、成员、扩展函数：::isOdd、 String::toInt，

顶层、成员、扩展属性：List<Int>::size，

构造函数：::Regex

使用实现函数类型接口的自定义类的实例：

class IntTransformer: (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO()
}

val intFunction: (Int) -> Int = IntTransformer()

函数类型实例调用

函数类型的值可以通过其 invoke(……) 操作符调用：f.invoke(x) 或者直接 f(x)。

如果该值具有接收者类型，那么应该将接收者对象作为第一个参数传递。调用带有接收者的函数类型值的另一个方式是在其前面加上接收者对象，就好比该值是一个扩展函数：1.foo(2)，

例如：

val stringPlus: (String, String) -> String = String::plus
val intPlus: Int.(Int) -> Int = Int::plus

println(stringPlus.invoke("<-", "->"))
println(stringPlus("Hello, ", "world!")) 

println(intPlus.invoke(1, 1))
println(intPlus(1, 2))
println(2.intPlus(3)) // 类扩展调用

运行结果：

<-->
Hello, world!
2
3
5

Lambda 表达式与匿名函数

Lambda 表达式语法

Lambda 表达式的完整语法形式如下：

val sum = { x: Int, y: Int -> x + y }

lambda 表达式总是括在花括号中，完整语法形式的参数声明放在花括号内，并有可选的类型标注，函数体跟在一个 -> 符号之后。如果推断出的该 lambda 的返回类型不是 Unit，那么该 lambda 主体中的最后一个（或可能是单个）表达式会视为返回值

如果我们把所有可选标注都留下，看起来如下：

val sum: (Int, Int) -> Int = { x, y -> x + y }

当一个 lambda 表达式只有一个参数时，如果编译器自己可以识别出签名，也可以不用声明唯一的参数并忽略 ->。该参数会隐式声明为 it：

ints.filter { it > 0 } // 这个字面值是“(it: Int) -> Boolean”类型的

如果 lambda 表达式的参数未使用，那么可以用下划线取代其名称：

map.forEach { _, value -> println("$value!") }

匿名函数

上面提供的 lambda 表达式语法缺少的一个东西是指定函数的返回类型的能力。在大多数情况下，这是不必要的。因为返回类型可以自动推断出来。然而，如果确实需要显式指定，可以使用另一种语法： 匿名函数 。

fun(x: Int, y: Int): Int = x + y

匿名函数看起来非常像一个常规函数声明，除了其名称省略了。其函数体可以是表达式（如上所示）或代码块：

fun(x: Int, y: Int): Int {
    return x + y
}

参数和返回类型的指定方式与常规函数相同，除了能够从上下文推断出的参数类型可以省略：

ints.filter(fun(item) = item > 0)

匿名函数的返回类型推断机制与正常函数一样：对于具有表达式函数体的匿名函数将自动推断返回类型，而具有代码块函数体的返回类型必须显式指定（或者已假定为 Unit）。

请注意，匿名函数参数总是在括号内传递。允许将函数留在圆括号外的简写语法仅适用于 lambda 表达式。

Lambda表达式与匿名函数之间的另一个区别是非局部返回的行为。一个不带标签的 return 语句总是在用 fun 关键字声明的函数中返回。这意味着 lambda 表达式中的 return 将从包含它的函数返回，而匿名函数中的 return 将从匿名函数自身返回。