纯函数

什么是纯函数？

在函数式编程里我们会经常谈到这两个概念。一个是纯函数。另一个是附加作用（副作用）。这里我们就结合实际来介绍一下纯函数和附加作用。

下面我们给出两个函数 increaseA 和 increaseB，他们其中一个是纯函数，另一个不是纯函数：

var state = 0

func increaseA() {
    state += 1
}

increaseA()

print(state) // 结果： 1

func increaseB(state: Int) -> Int {
    return state + 1
}

let state = increaseB(state: 0)

print(state) // 结果： 1

他们的作用差不多，使 state + 1，我们可以猜测一下 increaseA 和 increaseB 哪一个是纯函数？

...

... 经过 10 秒后

现在公布答案：increaseB 是纯函数，increaseA 不是纯函数

为什么 increaseB 是纯函数？

因为他特别纯洁：除了用入参 state 计算返回值以外没做任何其他的事情。

那为什么 increaseA 不是纯函数？

因为他修改了函数本体以外的值 state, 他拥有这个附加作用，因此他 并不纯洁 就不是纯函数。

我们再来做以下两个测试，然后猜测他们能不能测试成功：

func testIncreaseA() {
    increaseA()
    state == 1 // 结果：?? 🤔
}

func testIncreaseB() {
    let state = increaseB(state: 0)
    state == 1 // 结果：true 😎
}

...

... 经过 20 秒后

嗯... 这里我们可以肯定第二个测试 testIncreaseB 会成功。0 + 1 肯定等于 1。那第一个测试呢？这可不好说了，我们并不知道 increaseA 是在什么环境下被调用的，不知道在这个环境下初始 state 是多少。如果他是 0 那测试就会成功的，如果他不是 0 那测试就会失败的。因此在不知道所处环境时，我们无法判断测试是否会成功。

由于 increaseA 存在修改外部 state 的附加作用所以他不是纯函数。事实上如果函数有以下任意一种作用，他也不是纯函数：

发起网络请求
刷新 UI
读写数据库
获取位置信息
使用蓝牙模块
打印输出
...

我们将这些作用称为函数的附加作用（副作用）。

而纯函数的定义就是： 没有附加作用的函数，并且在参数相同时，返回值也一定相同。

因此在已知执行逻辑时，纯函数所产生的结果是可以被预测的。一些现代化的库都利用了这个特性来做状态管理，如：RxFeedback， Redux，ReactorKit 等等。

纯函数用于状态管理

我们用一个足够简单的例子来演示，如何用纯函数做状态管理：

typealias State = Int

enum Event {
    case increase
    case decrease
}

func reduce(_ state: State, event: Event) -> State {
    switch event {
    case .increase:
        return state + 1
    case .decrease:
        return state - 1
    }
}

这个例子似乎过于简单，以至于我们看不出他有什么特别的。好吧，我承认他的主要目的是向大家演示，用纯函数做状态管理的基本单元是什么。

首先，我们得有个状态：

typealias State = Int

然后，我们要有各种事件：

enum Event {
    case increase
    case decrease
}

最后，我们要有一个纯函数来管理我们的状态：

func reduce(_ state: State, event: Event) -> State {
    switch event {
    case .increase:
        return state + 1
    case .decrease:
        return state - 1
    }
}

这样，我们就可以做测试了，当 App 处于某个状态时，发生了某个事件，会产生一个结果，这个结果是否符合我们的预期：

func testReduce() {

    let state1 = reduce(0, event: .increase)
    state1 == 1 // 结果：true 😎

    let state2 = reduce(10, event: .decrease)
    state2 == 9 // 结果：true 😎
}

以上两个测试都是成功的。当然这里的状态管理过于简单。而真实应用程序的状态都是非常复杂的。并且程序的行为都是很难预测的。要解决这个问题，我们要感谢纯函数，还记得他的特征吗？

纯函数在参数相同时，返回值也一定相同。

我们再来看下 reduce 方法：

func reduce(_ state: State, event: Event) -> State { ... }

我们有没有获得一点点灵感...

...

... 经过 60 秒后

希望你已经获得答案了。

当程序处于某个特定状态时，发生了某个特定事件，会产生某个唯一的结果。这个结果与所处的环境无关，不论是处于应用程序运行环境，还是在测试环境。这个结果只和初始状态以及发生的事件有关。因此，程序的行为是可以被预测的，而且程序运行时的状态更新，可以在测试环境中被模拟出来。

...

... 经过 60 秒后

现在，我们来看一个相对复杂的例子：

登录状态管理

typealias UserID = String

enum LoginError: Error, Equatable {
    case usernamePasswordMismatch
    case offline
}

struct State: Equatable {

    var username: String
    var password: String

    var loading: Bool
    var data: UserID?
    var error: LoginError?

    enum Event {
        case onUpateUsername(String)
        case onUpatePassword(String)
        case onTriggerLogin
        case onLoginSuccess(UserID)
        case onLoginError(LoginError)
    }

    static func reduce(_ state: State, event: Event) -> State {
        var newState = state
        switch event {
        case .onUpateUsername(let username):
            newState.username = username
        case .onUpatePassword(let password):
            newState.password = password
        case .onTriggerLogin:
            newState.loading = true
            newState.data = nil
            newState.error = nil
        case .onLoginSuccess(let userId):
            newState.loading = false
            newState.data = userId
        case .onLoginError(let error):
            newState.loading = false
            newState.error = error
        }
        return newState
    }
}

我们重新走下流程 😄，用纯函数做状态管理：

首先，我们得有个状态：

struct State: Equatable {

    var username: String    // 输入的用户名
    var password: String    // 输入的密码

    var loading: Bool       // 登录中
    var data: UserID?       // 登录成功
    var error: LoginError?  // 登录失败

    ...
}

然后，我们要有各种事件：

    enum Event {
        case onUpateUsername(String)    //  更新用户名
        case onUpatePassword(String)    //  更新密码
        case onTriggerLogin             //  触发登录
        case onLoginSuccess(UserID)     //  登录成功
        case onLoginError(LoginError)   //  登录失败
    }

最后，我们要有一个纯函数来管理我们的状态：

    static func reduce(_ state: State, event: Event) -> State {
        var newState = state
        switch event {
        case .onUpateUsername(let username):
            newState.username = username
        case .onUpatePassword(let password):
            newState.password = password
        case .onTriggerLogin:
            newState.loading = true
            newState.data = nil
            newState.error = nil
        case .onLoginSuccess(let userId):
            newState.loading = false
            newState.data = userId
        case .onLoginError(let error):
            newState.loading = false
            newState.error = error
        }
        return newState
    }

现在我们可以在测试环境模拟各种事件，并且判断结果是否符合预期：

更新用户名事件

func testOnUpateUsername() {

    let state = State(
        username: "",
        password: "",
        loading: false,
        data: nil,
        error: nil
    )

    let newState = State.reduce(state, event: .onUpateUsername("beeth0ven"))

    let expect = State(
        username: "beeth0ven",
        password: "",
        loading: false,
        data: nil,
        error: nil
    )

    newState == expect // 结果：true 😎
}

更新密码事件

func testOnUpatePassword() {

    let state = State(
        username: "beeth0ven",
        password: "",
        loading: false,
        data: nil,
        error: nil
    )

    let newState = State.reduce(state, event: .onUpatePassword("123456"))

    let expect = State(
        username: "beeth0ven",
        password: "123456",
        loading: false,
        data: nil,
        error: nil
    )

    newState == expect // 结果：true 😎
}

触发登录事件

func testOnTriggerLogin() {

    let state = State(
        username: "beeth0ven",
        password: "123456",
        loading: false,
        data: nil,
        error: nil
    )

    let newState = State.reduce(state, event: .onTriggerLogin)

    let expect = State(
        username: "beeth0ven",
        password: "123456",
        loading: true,
        data: nil,
        error: nil
    )

    newState == expect // 结果：true 😎
}

登录成功事件

func testOnLoginSuccess() {

    let state = State(
        username: "beeth0ven",
        password: "123456",
        loading: true,
        data: nil,
        error: nil
    )

    let newState = State.reduce(state, event: .onLoginSuccess("userID007"))

    let expect = State(
        username: "beeth0ven",
        password: "123456",
        loading: false,
        data: "userID007",
        error: nil
    )

    newState == expect // 结果：true 😎
}

登录失败事件

func testOnLoginError() {

    let state = State(
        username: "beeth0ven",
        password: "123456",
        loading: true,
        data: nil,
        error: nil
    )

    let newState = State.reduce(state, event: .onLoginError(.usernamePasswordMismatch))

    let expect = State(
        username: "beeth0ven",
        password: "123456",
        loading: false,
        data: nil,
        error: .usernamePasswordMismatch
    )

    newState == expect // 结果：true 😎
}

这样我们可以轻易掌控程序的运行状态，以及各种状态更新。

现在，我们知道如何用纯函数做状态管理了。不过当前的代码形态，离投入生产环境，还存在好几个过度形态。这些过度形态有的是围绕如何引入附加作用，而做了一些应用架构。在这个问题上，不同地架构也提出了不同的解决方案，如：RxFeedback 用 feedbackLoop 引入附加作用，Redux 用 middleware 引入附加作用等等。这里就不一一介绍了，这些库的官方网站都会有相关说明。

最后，我们还是将代码演化到下一个形态，这里我选择使用 Redux 流派。因为个人的觉得他的知识依赖要少一些，可以让更多读者从中获益。

下一步 -- 引入 Store

class Store {

    // 观察者，用于响应状态更新，第一个 State? 为旧状态，第二个 State 为当前状态
    typealias Observer = (State?, State) -> Void

    private(set) var state: State  // 当前状态
    private var _observers: [UUID: Observer]  // 所有的观察者

    // 初始化
    init(initailState: State) {
        self.state = initailState
        self._observers = [:]
    }

    // 发出事件
    func dispatch(event: State.Event) {
        let oldState = self.state
        self.state = State.reduce(self.state, event: event)
        _publish(oldState: oldState, newState: self.state)
    }

    // 订阅状态更新
    func subscribe(observer: @escaping Observer) -> UUID {
        let subscriptionID = UUID() //  UUID 是唯一标识符，该 id 可用于取消订阅
        _observers[subscriptionID] = observer
        observer(nil, self.state) // 订阅时，将当前状态回放给该观察者
        return subscriptionID
    }

    // 取消订阅
    func unsubscribe(_ subscriptionID: UUID) {
        _observers.removeValue(forKey: subscriptionID)
    }

    // 私有方法，通知所有的观察者，状态已经更新了
    private func _publish(oldState: State?, newState: State) {
        _observers.values.forEach { observer in
            observer(oldState, newState)
        }
    }
}

如何使用 Store:

func useStore() {

    let initailState = State(
        username: "",
        password: "",
        loading: false,
        data: nil,
        error: nil
    )

    let store = Store(initailState: initailState)

    // 以下变量 newStates 和 oldStates 用于录制状态历史
    var newStates: [State] = []
    var oldStates: [State?] = []

    let subscriptionID = store.subscribe { (oldState, newState) in
        newStates.append(newState)
        oldStates.append(oldState)
    }

    // 模拟真实事件
    store.dispatch(event: .onUpateUsername("beeth0ven"))
    store.dispatch(event: .onUpatePassword("123456"))

    // 取消订阅
    store.unsubscribe(subscriptionID)

    // 描叙预期 
    let expectNewStates = [
        State(
            username: "",
            password: "",
            loading: false,
            data: nil,
            error: nil
        ),
        State(
            username: "beeth0ven",
            password: "",
            loading: false,
            data: nil,
            error: nil
        ),
        State(
            username: "beeth0ven",
            password: "123456",
            loading: false,
            data: nil,
            error: nil
        )
    ]

    let expectOldStates = [
        nil,
        State(
            username: "",
            password: "",
            loading: false,
            data: nil,
            error: nil
        ),
        State(
            username: "beeth0ven",
            password: "",
            loading: false,
            data: nil,
            error: nil
        )
    ]

    // 比对结果
    newStates == expectNewStates // 结果：true 😎
    oldStates == expectOldStates // 结果：true 😎
}

以上是在单元测试环境下,

首先下创建 Store:

    let initailState = State(
        username: "",
        password: "",
        loading: false,
        data: nil,
        error: nil
    )

    let store = Store(initailState: initailState)

然后，订阅程序状态，并且将这些状态录制下来:

    var newStates: [State] = []
    var oldStates: [State?] = []

    let subscriptionID = store.subscribe { (oldState, newState) in
        newStates.append(newState)
        oldStates.append(oldState)
    }

然后，模拟输入用户名事件和输入密码事件:

    store.dispatch(event: .onUpateUsername("beeth0ven"))
    store.dispatch(event: .onUpatePassword("123456"))

然后，取消订阅:

    store.unsubscribe(subscriptionID)

最后，比对录制的状态是否符合预期：

    let expectNewStates = [
        State(
            username: "",
            password: "",
            loading: false,
            data: nil,
            error: nil
        ),
        State(
            username: "beeth0ven",
            password: "",
            loading: false,
            data: nil,
            error: nil
        ),
        State(
            username: "beeth0ven",
            password: "123456",
            loading: false,
            data: nil,
            error: nil
        )
    ]

    let expectOldStates = [
        nil,
        State(
            username: "",
            password: "",
            loading: false,
            data: nil,
            error: nil
        ),
        State(
            username: "beeth0ven",
            password: "",
            loading: false,
            data: nil,
            error: nil
        )
    ]

    newStates == expectNewStates // 结果：true 😎
    oldStates == expectOldStates // 结果：true 😎

这就是如何在测试环境里面使用 Store，那么在 App 里面如何使用 Store 呢。一个 相对简单（并未优化） 的方法，就是将 Store 注入到对应的组件里面，这里以 ViewController 为例：

ViewController 可以使用 store.subscribe 方法订阅程序的状态。当状态更新时，比对新旧状态，然后刷新过时了的 UI。
当用户触发某个事件时，调用 store.dispatch 方法将事件发出去，如：当用户点击登录按钮时，就调用 store.dispatch(event: .onTriggerLogin)。
在 ViewController 的 deinit 方法里面注销订阅 store.unsubscribe(subsriptionID)。

总结

本节主要介绍了纯函数和附加作用，期间还演示如何用纯函数做状态管理的。最后还演化出了一个极简版的 Redux。希望大家可以从中获益！

纯函数

纯函数

什么是纯函数？

纯函数用于状态管理

登录状态管理

下一步 -- 引入 Store

总结

参考

results matching ""

No results matching ""