Posts Kotlin 高阶函数和lambda表达式
Post
Cancel

Kotlin 高阶函数和lambda表达式

高阶函数

高阶函数是将函数用作参数或返回值的函数。 这种函数的一个很好的例子是 lock(),它接受一个锁对象和一个函数,获取锁,运行函数并释放锁:

1
2
3
4
5
6
7
8
9
fun <T> lock(lock: Lock, body: () -> T): T {
    lock.lock()
    try {
        return body()
    }
    finally {
        lock.unlock()
    }
}

body 拥有函数类型:() -> T, 所以它应该是一个不带参数并且返回 T 类型值的函数。 它在 try代码块内部调用、被 lock 保护,其结果由lock()函数返回。

如果我们想调用 lock() 函数,我们可以把另一个函数传给它作为参数:

1
2
3
fun toBeSynchronized() = sharedResource.operation()

val result = lock(lock, ::toBeSynchronized)

通常会更方便的另一种方式是传一个lambda表达式:

1
val result = lock(lock, { sharedResource.operation() })
  • lambda表达式总是括在花括号中;
  • 其参数(如果有的话)在 -> 之前声明(参数类型可以省略);
  • 函数体(如果存在的话)在 -> 后面

Kotlin 中有一个约定,如果函数的最后一个参数是一个函数,并且你传递一个 lambda 表达式作为相应的参数,你可以在圆括号之外指定它

1
2
3
lock (lock) {
    sharedResource.operation()
}

高阶函数的另一个例子是 map():

1
2
3
4
5
6
fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
    val result = arrayListOf<R>()
    for (item in this)
        result.add(transform(item))
    return result
}

该函数可以如下调用:

1
val doubled = ints.map { value -> value * 2 }

请注意,如果lambda是该调用的唯一参数,则调用中的圆括号可以完全省略。

it:单个参数的隐式名称

另一个有用的约定是,如果函数字面值只有一个参数, 那么它的声明可以省略(连同 ->),其名称是 it

1
ints.map { it * 2 }

下划线用于未使用的变量(自 1.1 起)

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

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

Lambda 表达式与匿名函数

一个lambda表达式或匿名函数是一个“函数字面值”,即一个未声明的函数, 但立即做为表达式传递。考虑下面的例子:

1
max(strings, { a, b -> a.length < b.length })

函数max是一个高阶函数,换句话说它接受一个函数作为第二个参数。 其第二个参数是一个表达式,它本身是一个函数,即函数字面值。写成函数的话,它相当于:

1
fun compare(a: String, b: String): Boolean = a.length < b.length

函数类型

对于接受另一个函数作为参数的函数,我们必须为该参数指定函数类型。 例如上述函数max定义如下:

1
2
3
4
5
6
7
fun <T> max(collection: Collection<T>, less: (T, T) -> Boolean): T? {
    var max: T? = null
    for (it in collection)
        if (max == null || less(max, it))
            max = it
    return max
}

参数less的类型是 (T, T) -> Boolean,即一个接受两个类型T的参数并返回一个布尔值的函数: 如果第一个参数小于第二个那么该函数返回true

在上面第 4 行代码中,less作为一个函数使用:通过传入两个T类型的参数来调用。

如上所写的是就函数类型,或者可以有命名参数,如果你想文档化每个参数的含义的话。

1
val compare: (x: T, y: T) -> Int = ……

如要声明一个函数类型的可空变量,请将整个函数类型括在括号中并在其后加上问号:

1
var sum: ((Int, Int) -> Int)? = null

Lambda 表达式语法

Lambda 表达式的完整语法形式,即函数类型的字面值如下:

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

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

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

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

一个lambda表达式只有一个参数是很常见的。 如果Kotlin可以自己计算出签名,它允许我们不声明唯一的参数,并且将隐含地为我们声明其名称为 it

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

我们可以使用限定的返回语法从lambda显式返回一个值。否则,将隐式返回最后一个表达式的值。因此,以下两个片段是等价的:

1
2
3
4
5
6
7
8
9
ints.filter {
    val shouldFilter = it > 0 
    shouldFilter
}

ints.filter {
    val shouldFilter = it > 0 
    return@filter shouldFilter
}

请注意,如果一个函数接受另一个函数作为最后一个参数,lambda 表达式参数可以在圆括号参数列表之外传递。

匿名函数

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

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

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

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

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

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

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

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

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

This post is licensed under CC BY 4.0 by the author.

生成绑定类

签署Android应用

Comments powered by Disqus.