Kotlin-小抄（五）函数与函数式编程

简介

• 函数式编程是一种编程范式，它与命令式编程最大的不同是，函数式编程的焦点在于数据的映射，命令式编程的焦点是解决问题的步骤，函数式编程强调的是一种编程思维，解决问题的思考方式，也叫面向函数编程
  eg:

@Test
    fun test() {
        val list = listOf(1, 2, 3, 4, 5)
        // 函数式编程打印偶数
        print(list.filter { it % 2 == 0 }) // [2, 4]
        // 命令式编程打印偶数
        for (i in list) {
            if (i % 2 == 0) {
                println(i) // 2 4
            }
        }
    }
}

• 通过比较可以看出函数式编程更直观易懂且优雅

函数式编程特征

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

eg:

// 两者等价
fun sum(x: Int, y: Int): Int {
    return x + y
}

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

• 由此可知，Kotlin是一种面向表达式的语言

Lambda表达式

list.filter { it % 2 == 0 }

• 这里面的list.filter()函数的入参{it % 2 == 0}就是Lambda表达式的简写形式，因为filter()函数只有一个参数
• 其中filter函数声明如下：

// filter函数的入参是一个函数predicate:(T)->Boolean
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

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
}

• 完整写法如下

list.filter({it -> it % 2 == 0}）

高阶函数

eg：想要过滤出字符串列表中长度为奇数的字符串

val strList = listOf("a ", "ab ", "abc ", "abcd", "abcde", "abcdf ", "abcdefg")
val f = fun(x: Int): Boolean = x % 2 == 1
val g = fun(s: String) : Int = s.length
val h = fun(g: (String) -> Int, f: (Int) -> Boolean): (String) -> Boolean {
    return { f(g(it)) } // {}代表返回的是一个lambda表达式,类型是(String)->boolean类型，如果没有{},返回的就是一个Boolean类型
}

// 使用Kotlin的别名可以简写成如下形式
typealias G = (String) -> Int
typealias F = (Int) -> Boolean
typealias H = (String) -> Boolean
val h = fun (g : G, f : F) : H {
    return {f(g(it))}
}

@Test
fun testH() {
    print(strList.filter(h(g, f))) // [ab , abcde, abcdefg]
}

• 复合函数h的映射关系

Kotlin中的特殊函数

run()函数

• run函数定义如下

@kotlin.internal.InlineOnly
public inline fun <R> run(block: () -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block() // 直接调用传入的lambda表达式
}

• run函数使用

fun myfun() :String {
    println("myfun is running")
    return "myfun return value"
}


@Test
fun testRunFun() {
    // 直接调用myfun函数
    myfun() // myfun is running
    // 使用run调用myfun函数
    run({myfun()}) // myfun is running
    // run函数的括号传入的是一个参数可以省略
    run{myfun()} //myfun is running
    // 等价于pprintln("A")
    run{println("A")} // A
}

apply()函数

• apply函数定义如下

@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block() // 调用传入的lambda表达式
    return this // 返回函数的调用者，类似于builder模式
}

• apply函数的使用

@Test
fun testApply() {
    val list = ArrayList<String>().apply {
        add("A")
        add("B")
        add("C")
    }
    println(list) // [A, B, C]
}

let函数

• let函数定义如下

@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this) // 把当前的调用对象传入block中
}

• let函数的使用

@Test
fun testLet() {
    "ABC".let{println(it)} // ABC
    myfun().let { println(it) } // myfun is running  myfun return value
}

also函数

• also函数定义如下

@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this) // 把当前的调用对象传入block中
    return this // 返回函数的调用者
}

• also函数的使用

@Test
fun testAlso() {
    "ABC".also { println("1" + it.also { println("2" + it) }) }.let { println(it) } // block(this)打印2ABC返回ABC调用者，然后执行1ABC返回调用者
}

with函数

• with函数定义如下

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

• with函数的使用

@Test
fun testWith() {
    with(ArrayList<String>()) {
        add("A")
        add("b")
        add("C")
        println("$this") // 返回给receiver即当前函数调用者 [A, b, c]
    }
}