“ 函数式”编程 vs 编程写个函数——“函数式”编程和编程写个函数的区别

观看泊学高清视频
阅读泊阅文档

Swift是一种支持多种编程范式的语言，除了传统的面向对象之外，它还支持functional programming。我们通过一个简单的例子，来理解这个有些理论的概念。

从在数组中筛选元素说起

假设我们需要在一个数组里筛选出所有的偶数：

// filter in array
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var evens = [Int]()

for n in numbers {
    if n % 2 == 0 {
        evens.append(n)
    }
}

这样写有一个很明显的缺陷，如果我们需要筛选所有的奇数，那么我们只好复制for循环，之后把if条件改为判断奇数。如果我们接下来还要筛选3的倍数、4的倍数、5的倍数呢？我们只好就复制很多个for循环，但这显然是不符合代码重用思想的。

实际上，Swift提供了一个更简单的方式，我们先来感受下：

let evens1 = numbers.filter({ 
        (n: Int) -> Bool in 
            return n % 2 == 0) })
evens1 // [2, 4, 6, 8]

filter接受一个closure参数，这个closure接受一个Int参数表示数组中的每一个成员，返回一个Bool，表示是否满足筛选的条件，之后把满足筛选条件的元素，存放到evens1里。当然，在filter里，我们可以对closure做一些简化：

let evens1 = numbers.filter({ $0 % 2 == 0 })

那么，什么是functional programming？

Functional programming是一种编程范式，如同面向对象一样，这是一个关于我们思考方式的问题，而不是我们要做什么的问题。

在面向对象的世界里，我们把要解决的问题抽象成一个个类，通过类之间通信解决问题。而functional programming则是通过函数来描述我们要解决的问题和解决方案。我们管这样的函数，叫做Mathematical functions。而平实我们开发中编写的函数叫做computational functions。它们有什么区别呢？

它们最本质的区别是：Computational function是一组完成特定任务指令的封装，关乎的是要完成的任务；而Mathematical function关注的则是描述参数和返回值之间的关系。通过这种关系，确定的一个参数将总是有固定的返回值。

---

“这也正是Mathematical function这个名字的来源，它并不是指使用数学公式的函数，而是遵从数学中对于函数理解的函数。”
——特别提示

---

举个例子，对于匀速直线运动，位移s = 速度v x 时间t，对于一个速度是80km/h的物体来说，f(t) = 80 x t。只要时间固定，我们将总是得到一个固定的位移，于是，f(t) = 80 x t就是一个mathematical function，它关注的是描述位移和时间之间的关系。 把它写成Swift代码，就是这样：

func distance(t: Double) -> Double {
    return 80 * t
}

如果在实际的编程中，distance会受到某些我们无法控制的外部变量的干扰（例如来自某个其他程序员），我们的代码可能会变成这样：

func distance(t: Double) -> Double {
    let condition = externalCondition
    return 80 * t * condition
}

如果我们无法控制externalCondition，那么我们就无法确定时间和位移之间的关系，相同时间得到的位移完全有可能不同，这时，distance就已经变成了一个computational function，它只是一个用于完成“计算位移任务”的函数。

通过上面这个简单的对比，我们不难发现，通常一个computational function的实现里，存在着控制结果的多个维度，让结果变得不确定。而functional programming的思考方式，就是去掉这些不确定因素。让同样的输入，总是产生同样的结果。

重新审视之前的filter算法

结合functional programming的思想，我们可以给Array添加一个自定义的filter：

extension Array {
    func myOwnFilter<T>(predicate:(T) -> Bool) -> [T] {
        var tmp = [T]()
        
        for i in self {
            if predicate(i as! T) {
                tmp.append(i as! T)
            }
        }
        
        return tmp
    }
}

首先，我们使用struct extension给Array添加了函数，由于Array可以包含各种类型的元素，因此我们要把myOwnFilter实现为一个泛型函数，它的参数类型使用<T>表示。myOwnFilter同样接受一个closure参数，用来指定过滤的条件。

myOwnFilter的实现逻辑和我们一开始手动过滤偶数是类似的：定一个空数组，遍历数组找到满足条件的元素，存入新数组，将结果返回。唯一需要说明的是我们需要使用强制类型转换as!告诉编译器i的类型，是T（因为我们无法针对Array<T>使用extension）。

有了myOwnFilter之后，我们就可以像下面这样，过滤numbers变量中，所有的奇数：

let odds = numbers.myOwnFilter({ $0 % 2 != 0 })
odds // [1, 2, 3, 5, 7, 9]

在模拟了filter的实现之后，我们不难发现：

在我们最初的方法里，evenArray必须是一个变量，因为我们在循环里要修改evenArray。通过functional programming，我们可以直接获得一个常量。事实上，尽可能使用常量，是functional programing的一个核心主张；
filter是一个mathematical function，它没有对Array做任何修改，也没有依赖任何未知的外界条件。即便传入的Array是个变量，也不用担心在使用filter的时候，其内部的代码会修改Array；
filter是一个函数，也是我们描述问题和解决问题的方式。我们把“在数组中过滤特定条件的元素”，这个事情用函数封装了起来，而filter本身，实际上什么也没做，它只描述了一个输入数组（函数参数）和输出数组（函数返回值）之间的关系；