Functions和Higher functions
一、Functions
语法格式：
一个function由function header和function body两部分组成。
function header包括5部分：
- Visibility modifier
- function declaration keyword
- function name
- function parameters
- return type。
注意function parameter和function argument的区别：
Technically a parameter is what a function requires and an argument is what the caller passes in to fulfill the requirement.
function body由大括号括起来的代码块组成。
1. Single expression functions: 只有一个表达式的函数
fun concat1(a: String, b: String) = a + b
fun concat2(a: String, b: String): String {
return a + b
}
fun isSuccess1(): Boolean {
return try {
true
} catch (e: Exception) {
false
}
}
fun isSuccess2(): Boolean = try {
true
} catch (e: Exception) {
false
}
注意：
- 只有一个表达式的函数有block body和expression body两种写法。只有expression body的形式可以省略返回类型。
- 单一表达式函数不一定只有一行代码，像try..catch这种控制结构是有多行代码的。
2. Member functions
定义在class、object或 interface内部的函数称之为成员函数。
3. Local functions或nested functions.
局部或嵌套函数时定义在函数体内部的函数。举例：
fun printArea(width: Int, height: Int): Unit {
fun calculateArea(width: Int, height: Int): Int = width * height
val area = calculateArea(width, height)
println("The area is $area")
}
局部函数可以访问外部作用域中的参数和变量。
fun printArea2(width: Int, height: Int): Unit {
fun calculateArea(): Int = width * height
val area = calculateArea()
println("The area is $area")
}
另外一个例子：
fun fizzBuzz(start: Int, end: Int): Unit {
for (k in start..end) {
if (k % 3 == 0 && k % 5 == 0)
println("Fizz Buzz")
else if (k % 3 == 0)
println("Fizz")
else if (k % 5 == 0)
println("Buzz")
else
println(k)
}
}
fun fizzBuzz2(start: Int, end: Int): Unit {
fun isFizz(k: Int): Boolean = k % 3 == 0
fun isBuzz(k: Int): Boolean = k % 5 == 0
for (k in start..end) {
if (isFizz(k) && isBuzz(k))
println("Fizz Buzz")
else if (isFizz(k))
println("Fizz")
else if (isBuzz(k))
println("Buzz")
else
println(k)
}
}
fun fizzBuzz3(start: Int, end: Int): Unit {
for (k in start..end) {
fun isFizz(): Boolean = k % 3 == 0
fun isBuzz(): Boolean = k % 5 == 0
if (isFizz() && isBuzz())
println("Fizz Buzz")
else if (isFizz())
println("Fizz")
else if (isBuzz())
println("Buzz")
else
println(k)
}
}
fun fizzBuzz4(start: Int, end: Int): Unit {
for (k in start..end) {
fun isFizz(): Boolean = k % 3 == 0
fun isBuzz(): Boolean = k % 5 == 0
when {
isFizz() && isBuzz() -> println("Fizz Buzz")
isFizz() -> println("Fizz")
isBuzz() -> println("Buzz")
else -> println(k)
}
}
}
4. Top-level functions
5. Inline functions
fun main(args: Array) {
characterCount("fun.txt")
}
fun characterCount(fileName: String): Int {
val input = Files.newInputStream(Paths.get(fileName))
return withResource(input) {
input.buffered().reader().readText().length
}
}
fun withResource(resource: T, fn: (T) -> U): U {
try {
return fn(resource)
} finally {
resource.close()
}
}
以上述代码为例，如果withResource为非inline函数时，在调用withResource函数时，会首先创建一个实参类型（function argument）的实例。编译器会为withResource函数的lambda表达式参数生成一个InlineUtils$characterCount$1类，该类继承自Lambda、并实现了Function1
6. 函数字面量（Function literals）
就像字符串字面量（string literals）一样，我们也可以定义函数字面量（function literals）。
lambda表达式（Lambda expressions）和匿名函数（Anonymous functions）统称为函数字面量。举例：
{ println("I am a function literal") }
函数字面量可以赋值给一个变量：
val printHello: () -> Unit = { println("hello") }
printHello()
函数字面量也可以接收参数：
val printMessage = { message: String -> println(message) }
printMessage("Hello")
printMessage("World")
显式指定函数类型的写法：
val printMessage: (String) -> Unit = { message: String -> println(message) }
如果想明确地说明“正在创建的是一个函数”，也可以使用匿名函数。注意匿名函数是一个表达式（expression），而不是一个声明（declaration）。
将一个匿名函数赋值给变量：
val cubePI = fun(x: Double): Double {
return x * x * x
}
再看下面的例子：
fun main(args: Array) {
//lambda表达式作为实参传递
callWithPi(3.14) { it * it }
//匿名函数作为实参传递
callWithPi(3.14, fun(x: Double): Double {
return x * x
})
//匿名函数作为实参传递
callWithPi(3.14, fun(x: Double): Double = x * x)
//匿名函数赋值给变量，其中匿名函数为block body形式形式.
val cubePI = fun(x: Double): Double {
return x * x * x
}
//匿名函数赋值给变量，其中匿名函数为expression body形式.
val cubePI2 = fun(x: Double) = x * x * x
//lambda表达式赋值给变量
val cubePI3 = { x: Double ->
x * x * x
}
//函数类型变量作为实参传递.
callWithPi(3.14, cubePI)
callWithPi(3.14, cubePI2)
callWithPi(3.14, cubePI3)
}
二、Higher order函数
2.1. 定义：
如果一个函数的参数或返回值是一个函数类型，那么这样的函数称为Higher order函数。
如果一个语言支持higher order函数和函数赋值（function assignment），我们称这样的语言支持first class函数。
自持
2.2 函数类型(function types)的定义及变量赋值
函数类型语法格式：
function type语法格式.png
举例，定义传入参数为String、返回值也为String的函数类型的变量：
val reversed: (String) -> String = { str: String -> str.reversed() }
2.3. 函数的参数为一个函数类型（function type）
举例，定义一个foo函数，其中一个参数为String，另一个参数为函数类型，返回值为String。
private fun foo(str: String, operate: (String) -> String): String {
return operate(str)
}
fun testFoo() {
val reversed: (String) -> String = { str: String -> str.reversed() }
val fooResult = foo("123", reversed)
println("testFoo result: $fooResult")
}
2. 4. 函数的返回值为一个函数类型（function type）
fun testModulo() {
val ints = listOf(1, 2, 3, 4, 5, 6)
val odd = ints.filter(modulo(1)) //被1整除的元素列表
println("testModulo odd: $odd") //testModulo odd: [1, 2, 3, 4, 5, 6]
val evens = ints.filter(modulo(2)) //被2整除的元素列表
println("testModulo evens: $evens") //testModulo evens: [2, 4, 6]
val mod3 = ints.filter(modulo(3)) //被3整除的元素列表
println("testModulo mod3: $mod3") //testModulo mod3: [3, 6]
}
/**
* @param k: 传入的模数
* @return 返回一个函数, 类型为: (Int) -> Boolean. 这个函数接受一个入参, 判断该入参是否可以被k整除.
*/
private fun modulo(k: Int): (Int) -> Boolean {
return { it: Int -> it % k == 0 }
}
三、闭包（Closures）
在函数式编程里，闭包是指访问了外部作用域（outer scopes）的变量（ variables）或参数（parameters）的函数。我们称这样的函数close over了这些变量，闭包（closure）名字正是由此而来。
举例：
fun main(args: Array) {
val f = makeFun()
f() //1
f() //2
f() //3
}
fun makeFun(): () -> Unit {
var count = 0
return fun(): Unit {
println(++count)
}
}
闭包可以改变改变它所close over的变量：
fun main(args: Array) {
var containsNegative = false
val ints = listOf(-1, 0, 1, 2, 3, 4, 5)
ints.forEach {
if (it < 0)
containsNegative = true
}
println("containsNegative: $containsNegative") //containsNegative: true
}
匿名函数（Anonymous functions）
val evens = ints.filter(fun(k: Int): Boolean = k % 2 == 0) //匿名内部类.
匿名内部类可以转化为更简洁的lambda形式：
val evens = ints.filter { k -> k % 2 == 0 } //lambda表达式
函数引用（Function references）
Top-level function references
举例：
fun isEven(k: Int): Boolean = k % 2 == 0
fun main(args: Array) {
val ints = listOf(1, 2, 3, 4, 5)
ints.filter { isEven(it) } //lambda表达式的形式
}
lambda表达式可以转化为function references的形式：
fun isEven(k: Int): Boolean = k % 2 == 0
fun main(args: Array) {
val ints = listOf(1, 2, 3, 4, 5)
ints.filter(::isEven)
}
Member and extension function references
定义一个扩展函数：
fun Int.isOdd(): Boolean = this % 1 == 0
然后在函数字面量中使用该函数：
fun main(args: Array) {
val ints = listOf(1, 2, 3, 4, 5)
val oddLists = ints.filter { it.isOdd() }
println(oddLists) //[1, 2, 3, 4, 5]
}
然后使用extension function reference替换：
fun main(args: Array) {
val ints = listOf(1, 2, 3, 4, 5)
val oddLists = ints.filter(Int::isOdd)
println(oddLists) //[1, 2, 3, 4, 5]
}
使用member function reference的例子：
fun main(args: Array) {
fun foo(a: Double, b: Double, f: (Double, Double) -> Double) = f(a, b)
foo(1.0, 2.0, Math::pow)
}
对应的lambda的写法：
fun main(args: Array) {
fun foo(a: Double, b: Double, f: (Double, Double) -> Double) = f(a, b)
foo(1.0, 2.0) { a, b -> Math.pow(a, b) }
}
Bound references
举个例子：
fun String.equalsIgnoreCase(other: String) = this.toLowerCase() ==
other.toLowerCase()
println(listOf("Foo", "moo", "Boo","Bar").filter {
(String::equalsIgnoreCase)("bar", it)
})
如果使用bound reference的话，可以这样写：
fun String.equalsIgnoreCase(other: String) = this.toLowerCase() ==
other.toLowerCase()
println(listOf("Foo", "moo", "Boo", "Bar").filter("bar"::equalsIgnoreCase))
Function Literals with Receivers
在Kotlin中，在类的实例上调用成员函数或扩展函数时，这个实例称为Receiver。
val substring = fun String.(substr: String): Boolean = this.contains(substr)
"hello".substring("ello") //true
再看另外一个例子：
class Car(val horseName:String, val horsePowers:Int)
val car = Car("SportsCar",100)
val boast: Car.() ->String = {
"I am a $horseName car with $horsePowers HP!"
}
println(car.boast()) //I am a SportsCar car with 100 HP!
让我们看一下标准函数apply的定义：
public inline fun T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
它是定义在泛型T上的扩展函数，接受一个函数类型的参数，函数的类型是T.() -> Unit，即泛型T上的扩展函数。这样入参的lambda表达式的Receiver就是泛型T，也是apply函数的Receiver，因此可以在lambda内部调用T的properties和functions 。
Higher-order函数中的控制流(control flow)
- lambda中的return语句：non-local return
如果lambda中有return，那么会直接从调用lambda的函数中返回，而不是仅仅从lambda块中返回。举例：
fun lookForAlice(people: List) {
people.forEach {
if (it.name == "Alice") {
println("Found!")
return //直接返回lookForAlice函数.
}
}
println("Alice is not found")
}
- 从lambda中返回：带label的return
要标签化一个lambda表达式的话，将后加一个"@"字符，放在lambda的大括号前面，然后在需要从lambda中返回时，直接调用 return@ 。看例子：
fun lookForAlice2(people: List) {
people.forEach label@{
if (it.name == "Alice") {
println("Found Alice")
return@label
}
}
println("Alice might be somewhere")
}
另外，使用lambda作为参数的函数的函数名也可以作为LabelName。
fun lookForAlice3(people: List) {
people.forEach {
if (it.name == "Alice") {
println("Found Alice")
return@forEach
}
}
println("Alice might be somewhere")
}
- 给this表达式加标签
fun testPrint() {
val stringBuilder = StringBuilder().apply sb@{
listOf(1, 2, 3).apply {
[email protected](this.toString())
}
}
println(stringBuilder.toString()) //[1, 2, 3]
}
-
匿名类：默认的local returns
匿名类和lambda的区别