第5章 函数与函数式编程

  1. 云栖社区>
  2. 博客>
  3. 正文

第5章 函数与函数式编程

程序员诗人 2017-10-11 14:32:00 浏览651
展开阅读全文

第5章 函数与函数式编程

凡此变数中函彼变数者,则此为彼之函数。 ( 李善兰《代数学》)

函数式编程语言最重要的基础是λ演算(lambda calculus),而且λ演算的函数可以传入函数参数,也可以返回一个函数。函数式编程 (简称FP) 是一种编程范式(programming paradigm)。

函数式编程与命令式编程最大的不同是:函数式编程的焦点在数据的映射,命令式编程(imperative programming)的焦点是解决问题的步骤。函数式编程不仅仅指的是Lisp、Haskell、 Scala等之类的语言,更重要的是一种编程思维,解决问题的思考方式,也称面向函数编程。

函数式编程的本质是函数的组合。例如,我们想要过滤出一个List中的奇数,用Kotlin代码可以这样写

package com.easy.kotlin

fun main(args: Array<String>) {
    val list = listOf(1, 2, 3, 4, 5, 6, 7)
    println(list.filter { it % 2 == 1 }) // lambda表达式
}

这个映射的过程可以使用下面的图来形象化地说明

filter 函数

而同样的逻辑我们使用命令式的思维方式来写的话,代码如下

package com.easy.kotlin;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static java.lang.System.out;

public class FilterOddsDemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7});
        out.println(filterOdds(list)); // 输出:[1, 3, 5, 7]
    }

    public static List<Integer> filterOdds(List<Integer> list) {
        List<Integer> result = new ArrayList();
        for (Integer i : list) {
            if (isOdd(i)) {
                result.add(i);
            }
        }
        return result;
    }

    private static boolean isOdd(Integer i) {
        return i % 2 != 0;
    }
}

我们可以看出,函数式编程是简单自然、直观易懂且美丽优雅的编程风格。函数式编程语言中通常都会提供常用的map、reduce、filter等基本函数,这些函数是对List、Map集合等基本数据结构的常用操作的高层次封装,就像一个更加智能好用的工具箱。

5.1 函数式编程简介

函数式编程是关于不变性和函数组合的编程范式。函数式编程有如下特征

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

5.2 声明函数

Kotlin中使用 fun 关键字来声明函数,其语法实例如下图所示

Kotlin 声明函数

为了更加直观的感受到函数也可以当做变量来使用,我们声明一个函数类型的变量 sum 如下

>>> val sum = fun(x:Int, y:Int):Int { return x + y }
>>> sum
(kotlin.Int, kotlin.Int) -> kotlin.Int

我们可以看到这个函数变量 sum 的类型是

(kotlin.Int, kotlin.Int) -> kotlin.Int

这个带箭头( -> )的表达式就是一个函数类型,表示一个输入两个Int类型值,输出一个Int类型值的函数。我们可以直接使用这个函数字面值 sum

>>> sum(1,1)
2

从上面的这个典型的例子我们可以看出,Kotlin也是一门面向表达式的语言。既然 sum 是一个代表函数类型的变量,稍后我们将看到一个函数可以当做参数传入另一个函数中(高阶函数)。

当然,我们仍然可以像C/C++/Java中一样,直接带上函数名来声明一个函数

fun multiply(x: Int, y: Int): Int {
    return x * y
}

multiply(2, 2) // 4

5.3 lambda表达式

我们在本章开头部分讲到了这段代码

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

这里的filter函数的入参 { it % 2 == 1 } 就是一段 lambda表达式。实际上,因为filter函数只有一个参数,所有括号被省略了。所以,filter函数调用的完整写法是

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

其中的filter函数声明如下

public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

其实,filter函数的入参是一个函数 predicate: (T) -> Boolean 。 实际上,

{ it % 2 == 1 } 

是一种简写的语法,完整的lambda表达式是这样写的

{  it -> it % 2 == 1 } 

如果拆开来写,就更加容易理解

>>> val isOdd = { it: Int -> it % 2 == 1 } // 直接使用lambda表达式声明一个函数,这个函数判断输入的Int是不是奇数
>>> isOdd
(kotlin.Int) -> kotlin.Boolean // isOdd函数的类型
>>> val list = listOf(1, 2, 3, 4, 5, 6, 7)
>>> list.filter(isOdd) // 直接传入isOdd函数
[1, 3, 5, 7]

5.4 高阶函数

其实,在上面的代码示例 list.filter(isOdd) 中,我们已经看到了高阶函数了。现在我们再添加一层映射逻辑。我们有一个字符串列表

val strList = listOf("a", "ab", "abc", "abcd", "abcde", "abcdef", "abcdefg")

然后,我们想要过滤出字符串元素的长度是奇数的列表。我们把这个问题的解决逻辑拆成两个函数来组合实现

val f = fun (x: Int) = x % 2 == 1 // 判断输入的Int是否奇数
val g = fun (s: String) = s.length // 返回输入的字符串参数的长度

我们再使用函数 h 来封装 “字符串元素的长度是奇数” 这个逻辑,实现代码如下

val h = fun(g:  (String) -> Int, f: (Int) -> Boolean):  (String) -> Boolean {
    return { f(g(it)) }
}

但是,这个 h 函数的声明未免有点太长了。尤其是3个函数类型声明的箭头表达式,显得不够简洁。不过不用担心。

Kotlin中有简单好用的 Kotlin 类型别名, 我们使用 G,F,H 来声明3个函数类型

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

那么,我们的 h 函数就可简单优雅的写成下面这样了

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

这个 h 函数的映射关系可用下图说明

h 函数的映射关系

函数体中的这句代码 return { f(g(it)) } , 这里的 {} 它代表这是一个lambda表达式,返回的是一个 (String) -> Boolean 函数类型。如果没有 { } , 那么返回值就是一个布尔类型Boolean了。

通过上面的代码例子,我们可以看到,在Kotlin中,我们可以简单优雅的实现高阶函数。OK,现在逻辑已经实现完了,下面我们在 main 函数中运行测试一下效果。

fun main(args: Array<String>) {
    val strList = listOf("a", "ab", "abc", "abcd", "abcde", "abcdef", "abcdefg")
    println(strList.filter(h(g, f))) // 输出:[a, abc, abcde, abcdefg]
}

当你看到 h(g, f) 这样的复合函数的代码时,你一定很开心,感到很自然,这跟数学公式真是很贴近,简单易懂。

本章小结

在Kotlin中,支持函数作为一等公民。它支持高阶函数、lambda表达式等。我们不仅可以把函数当做普通变量一样传递、返回,还可以把它分配给变量、放进数据结构或者进行一般性的操作。在Kotlin中进行函数式编程相当简单自如。

网友评论

登录后评论
0/500
评论