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<T>(_ transform: (Element) -> T) -> [T] {
var result: [T] = []
for item in self {
result.append(transform(item))
}
return result
}
}
可以看到，高阶函数就像是一个模板，允许传入我们自定义的函数组件，配合泛型，能够灵活地进行各种组合，提高代码的复用率的同时，广泛地解决各种各样的问题。
观察者模式
观察者模式是一种行为设计模式， 允许你定义一种订阅机制， 可在对象事件发生时通知多个 “观察” 该对象的其他对象。
被观察者(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。
