《Kotlin入门实战》CH5 | 函数与函数式编程

函数与函数式编程

函数式编程与命令式编程最大的不同是：函数式编程的焦点在于数据的映射，命令式编程（imperative programming）的焦点是解决问题的步骤。

函数式编程和命令式编程比较

fun main() {

    val list = listOf<Int>(1, 2, 3, 4, 5)
    
    // 函数式编程
    println(list.filter { it % 2 == 0 })
    
    // 命令式编程
    for (i in list) {
        if (i % 2 == 0)
            println(i)
    }
}

如果式Java的话，还要写for(;;)遍历，函数式编程就显得可读性更好了。

1. 函数式编程

1. 一等函数支持（first-class function）：函数也是一种数据类型，可以作为参数传入另一个函数中，同时函数也可以返回一个函数。
2. 纯函数（pure function）和不变性（immutable）：纯函数指的是没有副作用的函数（函数不去改变外部的数据状态）。例如，一个编译器就是一个广义上的纯函数。在函数式编程中，倾向于使用纯函数编程。正因为纯函数不会去修改数据，同时又使用不可变的数据，所以程序不会去修改一个已经存在的数据结构，而是根据一定的映射逻辑创建一份新的数据。函数式编程是转换数据而非修改原始数据。
3. 函数的组合（compose function）：在面向对象编程中是通过对象之间发送消息来构建程序逻辑的；而在函数式编程中是通过不同函数的组合来构建程序逻辑的。

2. 声明函数

fun sum(v1: Int, v2: Int): Int {
    return v1 + v2
}

val sum = fun(v1: Int, v2: Int): Int { return v1 + v2 }

3. Lambda表达式

val list = listOf(1, 2, 3, 4, 5, 6, 7)
list.filter { it % 2 == 1 }

因为filter函数只有一个参数所以小括号被省略了

list.filter ({ it % 2 == 1 })

而filter函数的参数式一个函数，参数类型式predicate: (T) -> Boolean

{ it % 2 == 1 } 是一个简写的Lambda表达式

{ it -> it % 2 == 1 } //实际的Lambda 表达式

完整的写法是

val odd = {it:Int -> it % 2 == 1}
list.filter(odd)

可以看一下filter的源码

public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}// predicate 是传入的函数，调用filterTo方法

// filterTo方法中使用了predicate判断是否满足条件
// 如果满足条件则加入destination 容器里面

public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C {
    for (element in this) if (predicate(element)) destination.add(element)
    return destination
}

4. 高阶函数

    val f = fun(x: Int) = x % 2 == 1
    val g = fun(s: String) = s.length
    val h = fun(g: (String) -> Int, f: (Int) -> Boolean): (String) -> Boolean {
        return { f(g(it)) }  // {}表示返回的是lambda表达式，如果没有返回的是boolean值了
    }
    
    val strs = listOf("a", "ab", "abc", "abcd")
    println(strs.filter( h(g, f) ))

使用typealias别名简化

typealias G = (String) -> Int
typealias F = (Int) -> Boolean
typealias H = (String) -> Boolean

val h = fun(g: G, f: F): H {
    return { f(g(it)) } //需要注意的是，这里的{} 是不能省略的
}

image.png

5. kotlin中特殊函数

kotlin包下的Standard.kt 文件中定义的方法

run()、apply()、let()、also()和with()、takeIf、takeUnless、repeat

1. run()

定义

public inline fun <R> run(block: () -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

使用

fun myfun(): String {
    println("执行了myfun 函数")
    return "这是myfun 的返回值"
}

fun main() {
    myfun()
    run({ myfun() })
    run { myfun() }
    run { println("A") }
}

结果

执行了myfun 函数
执行了myfun 函数
执行了myfun 函数
A

2. apply()函数

定义

public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

使用

   val list = ArrayList<String>().apply {
        add("1")
        add("2")
        add("3")
    }
    println(list)

结果

[1, 2, 3]

3. let()函数

定义

public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

使用

list.let { println(it) }

结果

[1, 2, 3]

4. also()函数

定义

public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}

使用

fun testAlsoFun() {
    val a = "ABC".also {
        println(it) //输出：ABC
    }
    println(a)      //输出：ABC
    a.let {
        println(it) //输出：ABC
    }
}

结果

ABC
ABC
ABC

5. with()函数

定义

public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

使用

    with(ArrayList<Int>()){
        add(1)
        add(2)
        add(3)
    }.let { println(it) }

结果

1
2
3