纯函数

什么是纯函数?

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

下面我们给出两个函数 increaseAincreaseB,他们其中一个是 纯函数,另一个不是 纯函数

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, 我们可以猜测一下 increaseAincreaseB 哪一个是 纯函数

...

...

...

... 经过 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
  • 读写数据库
  • 获取位置信息
  • 使用蓝牙模块
  • 打印输出
  • ...

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

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

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

纯函数用于状态管理

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

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 😎
}

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

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

最后,我们还是将代码演化到下一个形态,这里我选择使用 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)
  • ViewControllerdeinit 方法里面注销订阅 store.unsubscribe(subsriptionID)

总结

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

参考

results matching ""

    No results matching ""