Kotlin基础知识十一：Functions和Higher or

作者: 北雁南飞_8854 | 来源:发表于2020-06-14 21:47 被阅读0次

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<String>) {
    characterCount("fun.txt")
}

fun characterCount(fileName: String): Int {

    val input = Files.newInputStream(Paths.get(fileName))

    return withResource(input) {
        input.buffered().reader().readText().length
    }
}

fun <T : AutoCloseable, U> 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<InputStream, Integer>接口，然后创建该类的一个实例作为实参传递。

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<String>) {
    //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<String>) {
    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<String>) {
    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<String>) {
    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<String>) {
    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<String>) {
    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<String>) {
    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<String>) {
    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<String>) {
    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> 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<Person>) {
    people.forEach {
        if (it.name == "Alice") {
            println("Found!")
            return //直接返回lookForAlice函数.
        }
    }
    println("Alice is not found")
}

从lambda中返回：带label的return
要标签化一个lambda表达式的话，将<LabelName>后加一个"@"字符，放在lambda的大括号前面，然后在需要从lambda中返回时，直接调用 return@<LabenName>。看例子：

fun lookForAlice2(people: List<Person>) {
    people.forEach label@{
        if (it.name == "Alice") {
            println("Found Alice")
            return@label
        }
    }
    println("Alice might be somewhere")
}

另外，使用lambda作为参数的函数的函数名也可以作为LabelName。

fun lookForAlice3(people: List<Person>) {
    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 {
            this@sb.append(this.toString())
        }
    }
    println(stringBuilder.toString()) //[1, 2, 3]
}

匿名类：默认的local returns

匿名类和lambda的区别