swift之函数式编程

函数式编程初探

最近初学swift，和OC比，发现语言更现代，也有了更多的特性。如何写好swift代码，也许，熟练使用新特性写出更优秀的代码，就是答案。今天先从大的方向谈谈swift中的编程范式-函数式编程。主要还是读了大佬帖子，写写自己的理解。

什么是函数式编程

"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

它属于"结构化编程"的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。

它使代码更像自然语言，告诉程序员要干什么，而不是怎么干，把怎么干的细节拆分到各个函数中。调用的地方逻辑清晰，便于debug。

举例来说，现在有这样一个数学表达式：

  
　　(1 + 2) * 3 - 4

传统的过程式编程，可能这样写：

var a = 1 + 2;

var b = a * 3;

var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

var result = subtract(multiply(add(1,2), 3), 4);

这就是函数式编程。

为什么使用函数式编程

  1. 代码简洁，开发快速

    函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

  2. 接近自然语言，易于理解

    函数式编程的自由度很高，可以写出很接近自然语言的代码。我们把程序的逻辑分成了几个函数，这样一来，我们的代码逻辑也会变得几个小碎片，于是我们读代码时要考虑的上下文就少了很多，阅读代码也会更容易。 而把代码逻辑封装成了函数后，我们就相当于给每个相对独立的程序逻辑取了个名字，于是代码成了自解释的。

    前文曾经将表达式(1 + 2) * 3 - 4，写成函数式语言：

    subtract(multiply(add(1,2), 3), 4)

    对它进行变形，不难得到另一种写法：

    　　add(1,2).multiply(3).subtract(4)

     

  3. 更方便的代码管理

    函数式编程不依赖、也不会改变外界的状态，只要给定输入参数，返回的结果必定相同。因此，每一个函数都可以被看做独立单元，很有利于进行单元测试（unit testing）和除错（debugging），以及模块化组合。

  4. 易于"并发编程"

    函数式编程不需要考虑"死锁"（deadlock），因为它不修改变量，所以根本不存在"锁"线程的问题。不必担心一个线程的数据，被另一个线程修改，所以可以很放心地把工作分摊到多个线程，部署"并发编程"（concurrency）。

函数式编程的一些重要概念

函数是"第一等公民"

所谓"第一等公民"（first class），指的是函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。

举例来说，下面代码中的print变量就是一个函数，可以作为另一个函数的参数。

var print = function(i){ console.log(i);};

[1,2,3].forEach(print);

函数（function)和procedure是有区别的

函数(function)这个名词来自于数学，函数通过一个给定的值，计算出另外一个值，也就是上学时常见的f(x)。

在通常的理解中，下面代码里面，f1，f2，f3通常都被叫做函数：

  
//伪代码 函数无入参，返回2
def f1(): return 2
//函数有参数x，返回 x+1
def f2(int x): return x+1
//函数无入参，无返回值，打印hello world
def f3(): print("hello world")

 

复制代码但实际上，函数（function)和procedure是有区别的： function 通过运算返回一个值，而procedure只执行一段代码，没有返回值。 这一点对于后面的理解是非常有帮助的，首先要区分出二者。

再回到上面的代码中，f1，f2，为function而f3为procedure。

Pure Function（纯函数）

Pure：纯的； 单纯的； 纯真的； 干净的 我们将满足下面两个条件的函数称作Pure Function：

  • 函数不会产生side effect(no side effect)

  • 函数满足referential transparency这个条件 （原谅我不会翻译这两个名词）

  1. Side effect

    函数调用后不会对外部状态产生影响,比如下面这段代码中sum函数是no side effect的：

    def sum(a,b): return a+b

    产生side effect的函数长成什么样呢？其实经常会写这样的函数：

    int sum = 0
def plus(a,b){
sum = a + b
return sum
}

     

    plus函数除了计算参数之和以外，还改变了外部变量sum的值，我们plus这个函数产生了side effect。 常见的Side effect

  • 改变外部变量的值（上面的例子中plus函数）
  • 像磁盘中写入数据

  • 将页面上的一个按钮设置为可点击，或者不可点击

    前面提到function和procedure的不同点，在side effect这个角度来讲，pure funcion不会产生side effect，procedure通常会产生side effect。

    满足Referential Transparency的函数可以将可以将用函数计算的结果替换表达式本身，而不影响程序的逻辑。 给定指定的参数，在任何时候返回的值都是相同的。不受其他外部条件影响。

    两者说的意思是一样的，只是表达的角度是不同的 举个满足RT的例子

      
    def f(): return 2

print(f() + f())
print(2)

    下面这段代码中的f()是满足RT的函数,按照上面的解释，我们可以将f()的结果也就是2替换掉f()，不会影响程序本身的逻辑：

    def f(): return 2

print(2 + f())
print(2)

    或者这样替换：

    def f(): return 2

print(f() + 2)
print(2)

    从另一个角度说，f()这个函数无论在什么时候调用，返回的值都是一样的，不会发生改变（没有外部条件影响）

    举个不满足RT的例子

    int counter = 0

def f(x){
counter += 1
return x + counter
}

    这个例子中，f(x)这个函数不满足RT 下面的代码中，当我们用f(1)的计算结果一次替换代码中f(1)本身时，程序的逻辑是错误的：

    //原始的代码执行结果是：3
f(1) + f(1)

//把f(1)的结果1替换进来，下面函数执行的结果是：2
f(1) + 1

//同样，得到2
1 + f(1)

//得到2
1 + 1

    我们不能用执行的结果替换函数本身， 换个角度，下面两行代码执行的结果也不同

    f(1) + f(1)
2 * f(1)

    虽然入参都为1，但f(1)在不同时候调用得到的结果不同，因此f不满足RT这个条件

    回到pure function,理解了side effect 和 referential transparency的含义，我们再来重温pure function的定义，就很好理解了：

  • No side effect

  • Referential transparency

    满足这两个条件的函数，称之为pure function

引用透明

引用透明（Referential transparency），指的是函数的运行不依赖于外部变量或"状态"，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。

有了前面的第三点和第四点，这点是很显然的。其他类型的语言，函数的返回值往往与系统状态有关，不同的状态之下，返回值是不一样的。这就叫"引用不透明"，很不利于观察和理解程序的行为。

swift中函数式编程的应用

高阶函数

先说两个概念型的名词：

高阶函数（high order func），指可以将其他函数作为参数或者返回结果的函数。

一级函数（first class func），指可以出现在任何其他构件（比如变量）地方的函数。

map 

map { (Element) -> Element in
    对 element 进行处理
}

一般用在集合类型，对集合里的元素进行遍历，函数体里实现对每一个元素的操作。

var arr = [1,3,2,4]
let mapres = arr.map {
    "NO." + String($0)
}

// 运行结果：["NO.1", "NO.3", "NO.2", "NO.4"]

reduce

reduce(Result) { (Result, Element) -> Result in
    基于 Result 对当前的 Element 进行操作，并返回新的 Result
}

一般用在集合类型，对集合里的元素进行叠加处理，函数体里传两个参数，第一个是之前的叠加结果，第二个是当前元素，返回值是对当前元素叠加后的结果。

// 对数组里的元素：奇数相加，偶数相乘
var arr = [1,3,2,4]
let reduceRes = arr.reduce((0,1)) { (a:(Int,Int), t:Int) -> (Int,Int) in
    if t % 2 == 1 {
        return (a.0 + t, a.1)
    } else {
        return (a.0, a.1 * t)
    }
}
// 运行结果：(4,8)

filter

filter { (Element) -> Bool
    对元素的筛选条件，返回 Bool
}

一般用在集合类型，对集合里的元素进行筛选。函数体里实现筛选条件，返回 true 的元素通过筛选。

var arr = [1,3,2,4]
let filterRes = arr.filter {
    $0 % 2 == 0
}
// 运行结果：[2,4]

flatMap

首先先看下 Swift 源码里对集合数组的map和flatmap的实现：

// Sequence.swift
extension Sequence {
    public func map<T>(_ transform: (Element) -> T) -> [T] {}
}

// SequenceAlgorithms.swift.gyb
extension Sequence {
    public func flatMap<T>(_ transform: (Element) -> T?) -> [T] {}
    public func flatMap<S : Sequence>(_ transform: (Element) -> S) -> [S.Element] {}
}

 

前面我们已经知道，map是一种遍历，而上面的代码又显示出来，flatmap有两种重载的函数：

其中一种与map非常相似，差别只在闭包里的返回值变成了可选类型。 另一种稍微有点不同，闭包传入的是数组，最后返回的是数组的元素组成的集合。

  
// map
let arr = [1,2,nil,4,nil,5]
let arrRes = arr.map { $0 } // 结果为：[Optional(1), Optional(2), nil, Optional(4), nil, Optional(5)]

// flatmap
let brr = [1,2,nil,4,nil,5]
let brrRes = brr.flatmap { $0 } // 结果为：[1, 2, 4, 5]

let crr = [[1,2,4],[5,3,2]]
let ccRes = crr.flatmap { $0 } // 结果为：[1, 2, 4, 5, 3, 2]
let cdRes = crr.flatmap { c in
    c.map { $0 * $0 }
} // 结果为[1, 4, 16, 25, 9, 4]

// 使用 map 实现的上面平铺功能
let ceRes = Array(crr.map{ $0 }.joined()) // 同 ccRes
let cfRes = Array(crr.map{ $0 }.joined()).map{ $0 * $0 } // 同 cdRes

简单理解为，flatMap可以将多维数组平铺，也还以过滤掉一维数组中的nil元素。

map和flatMap不只在数组中可以使用，对于 Optional 类型也是可以进行操作的。先看下面这个例子：

  
let a: Date? = Date()
let formatter = DateFormatter()
formatter.dateStyle = .medium

let c = a.map(formatter.string(from:))
let d = a == nil ? nil : formatter.string(from: a!)
c 和 d 是两种不同的写法，c 写法是不是更优雅一些?

 

参考文章：

理解函数式编程的本质

函数式编程初探

swift函数式编程介绍

Swift之函数式编程

posted @ 2018-09-25 16:16  6度XZ  阅读(420)  评论(0)  编辑  收藏  举报