RxSwift #01 | 函数式编程和观察者模式

RxSwift 结合了函数式编程(Fuction Programming)和观察者模式(Observer pattern)的特点，能够以更加优雅的方式进行异步编程。

函数式编程

熟悉 Swift 的同学应该都使用过函数式编程(Fuction Programming)。相比于常用的命令式编程，函数式编程有以下几个特点：

• 纯函数，不可变状态和副作用
• 函数是一等公民

纯函数，不可变状态和副作用

纯函数：函数的返回值仅取决于输入值，不会引起任何状态的改变，因此不会带来副作用(Side effect)。也就是说：相同的输入值，一定会有相同的输出值。

举个子：

func sum(_ a: Int, _ b: Int) -> Int {
        return a + b
}

再来个声明式的例子：

// ...
var name = "Tom"
func setupUI() {
        name = "Jerry"
        label.text = name
        // ....
}
print(name)
// ...

在上述声明式的例子中，为了设置 label 的 text，在 setupUI() 中，改变了外部变量 name 的值，也就是改变了 name 的状态。

如果在其他地方去打印 name，会发现打印的结果和 name 的初始值不一样，也就是说 name 变得不可控了，这样可能会导致一些副作用。

而纯函数则很好地避免了可能会带来的副作用。

从代码含义上去理解，声明式编程则像是表达“怎么做”，如果 setupUI() 函数，第一步先把 name 设置为 “Jerry”，第二步把 label 的 text 设置为 name。

而函数式编程更像是表达“做什么”，比如只要调用了 sum(_:, _:) 函数，就知道一定是对输入的参数求和，并且不会有任何额外的操作。

函数是一等公民

当函数是一等公民时，这个意思就是我们可以把一个函数赋值给一个变量，就跟我们使用 Int 或者 String 一样。

func inside() -> Void {
    print("Yo!")
}

func outside(inner:() -> Void) {
    inner()
}

outside(inside)
// prints: Yo!

而如果我们的函数符合以下两个特征的任意一种：

• 使用函数作为参数
• 函数是返回值

那么这个函数则可以认定为是高阶函数。

在 Swift 标准库中，内置了丰富的高阶函数，比如我们常用的 map(_:) 函数：

[1, 2, 3].map { $0 * 2 }
// output: [2, 4, 6]

如果不使用高阶函数，实现起来则是这样的：

var array = [1, 2, 3]
func map(_ array: [Int]) {
        var result = [Int]()
        for item in array {
            result.append(item * 2)
        }
        return result
}
map(array)
// output: [2, 4, 6]

代码复杂了很多，而且只能实现把每个元素乘以2这一种操作，如果我想把每个元素都乘以3，那就需要写很多重复代码。

而 map(_:) 函数的实现则是这样的：

extension Array {
  // T is the output type
  func myMap(_ transform: (Element) -> T) -> [T] {
    var result: [T] = []

    for item in self {
      result.append(transform(item))
    }

    return result
  }
}

可以看到，高阶函数就像是一个模板，允许传入我们自定义的函数组件，配合泛型，能够灵活地进行各种组合，提高代码的复用率的同时，广泛地解决各种各样的问题。

观察者模式

观察者模式是一种行为设计模式， 允许你定义一种订阅机制， 可在对象事件发生时通知多个 “观察” 该对象的其他对象。

observer-2x (1).png

被观察者(Observable)

• 维护了一个观察者成员列表
• 用于添加或者移除观察者的方法
• 用于发布事件给观察者的方法

具体实现如下：

class Observable {
    private lazy var observers = [Observer]()
    
    func subscribe(_ observer: Observer) {
        observers.append(observer)
    }

    func unscribe(_ observer: Observer) {
        guard let index = observers.first(where: { $0 === observer }) else { return }
        observers.remove(at: index)
    }

    func publish() {
        var value = Int.random(in: 0...100)
        observers.forEach { $0.onNext(value) }
    }
}

观察者(Observer)

观察者实现比较简单，为了不和被观察者耦合，只需要实现统一的接口用于接收事件即可：

Protocol Observer {
    func onNext(_ value: Int)
}

class ObserverA: Observer {
    func onNext(_ value: Int) {
        print("observerA valuer: \(value)")
    }
}

class ObserverB: Observer {
    func onNext(_ value: Int) {
        print("observerB valuer: \(value)")
    }
}

发送通知

接下来，只需要在 observable 里，把 observer 对象添加到观察者列表中，然后再发布事件即可：

let observable = Observable()
let observerA = ObserverA()
let observerB = ObserverB()

observable.subscribe(observerA)
observable.subscribe(observerB)
observable.publish()

/**
    output: 
    observerA valuer: 1
    observerA valuer: 2
**/

总结

函数式编程和观察者模式是学习 RxSwift 的基础，如果你理解上述示例代码的话，在后面学习 RxSwift 的过程中，你还会看到很多类似的代码。

因此，学习本节的知识，有助于接下来学习和理解 RxSwift。

参考资料

函数式编程：基本概念

观察者模式