Redux在iOS中的使用

littleplayer
0 阅读5分钟

好的，我们来详细探讨一下 Redux 在 iOS 开发中的应用。Redux 是一个源自 Web 前端（通常与 React 搭配）的架构模式，它因其单一数据源、状态不可变和纯函数Reducer 等特性，在 iOS 开发中也获得了大量关注和实践。

Redux 核心概念回顾

理解 Redux 在 iOS 的实现，首先要理解其三个基本原则：

  1. 单一数据源 (Single Source of Truth)： 整个应用的状态（State）被存储在一个单一的、中心化的 Store 对象中。这消除了状态分散在不同组件所带来的复杂性，使得状态的追踪和调试变得非常容易。

  2. 状态是只读的 (State is Read-Only)： 唯一改变状态的方法就是派发一个 Action。Action 是一个简单的、描述“发生了什么”的对象（通常是结构体或枚举）。你不能直接修改状态，这保证了状态更新的可预测性。

  3. 使用纯函数进行更改 (Changes are Made with Pure Functions)： 为了指定状态如何被 Action 转换，你需要编写 Reducers。Reducer 是一个纯函数，它接收当前的 State 和一个 Action，并返回一个新的、更新后的 State（而不是修改旧的 State）。

在 iOS 中的核心组件映射

Redux 概念iOS 中的实现说明
State一个结构体 (struct) 或类包含整个应用当前所有数据的模型。必须是值类型（struct）以确保不可变性。
Action一个枚举 (enum)描述所有可能改变状态的事件。每个 case 可以关联一些数据。
Reducer一个函数 (function)(State, Action) -> State。根据 Action 生成新 State 的纯函数。
Store一个单例或通过依赖注入的类 (class)持有当前 State；接收并派发 Action；运行 Reducer 来更新 State；通知观察者。
ViewUIViewController 或 SwiftUI.View观察 State 的变化并重新渲染 UI；向 Store 派发用户交互产生的 Action。

一个简单的计数器示例 (SwiftUI + Combine)

让我们用一个经典的计数器例子来演示如何在 iOS (SwiftUI) 中实现 Redux。

第 1 步：定义 State

// 应用的状态。必须是结构体，以保证不可变性。
struct AppState {
    var count: Int = 0
}

第 2 步：定义 Action

// 所有能改变状态的动作。
enum Action {
    case increment
    case decrement
    case incrementBy(Int) // 关联值
}

第 3 步：定义 Reducer

// 这是一个纯函数：相同的输入，永远得到相同的输出，且无副作用。
func appReducer(state: AppState, action: Action) -> AppState {
    var newState = state // 复制当前状态（因为 state 是 struct，是值类型）
    
    switch action {
    case .increment:
        newState.count += 1
    case .decrement:
        newState.count -= 1
    case .incrementBy(let amount):
        newState.count += amount
    }
    // 返回一个全新的状态对象
    return newState
}

第 4 步：创建 Store

这是最关键的一步。Store 是大脑，它协调所有操作。

import Combine

// Store 是一个 ObservableObject，这样 SwiftUI 视图才能观察它的变化。
class Store: ObservableObject {
    // 发布者：State 的变化会驱动 UI 更新
    @Published private(set) var state: AppState
    
    // Reducer 函数
    private let reducer: (AppState, Action) -> AppState
    
    init(initialState: AppState, reducer: @escaping (AppState, Action) -> AppState) {
        self.state = initialState
        self.reducer = reducer
    }
    
    // 唯一能改变状态的方法：派发 Action
    func dispatch(_ action: Action) {
        // 在主线程上同步更新状态，保证线程安全
        DispatchQueue.main.async {
            // 调用 reducer 生成新状态，并替换旧状态
            self.state = self.reducer(self.state, action)
            // 由于 @Published 属性发生变化，objectWillChange 会自动发出信号，
            // 通知所有观察的 View 更新。
        }
    }
}

第 5 步：在 SwiftUI View 中使用

struct CounterView: View {
    // 从环境中获取或直接注入 Store
    @EnvironmentObject var store: Store
    
    var body: some View {
        VStack {
            Text("Count: \(store.state.count)") // 从 Store 中读取状态
                .font(.largeTitle)
            
            HStack {
                // 向 Store 派发 Action
                Button("-") { store.dispatch(.decrement) }
                Button("+") { store.dispatch(.increment) }
                Button("+10") { store.dispatch(.incrementBy(10)) }
            }
            .buttonStyle(.borderedProminent)
        }
    }
}

第 6 步：在入口点设置 Store

@main
struct MyApp: App {
    // 创建全局唯一的 Store，并注入到环境中
    let store = Store(initialState: AppState(), reducer: appReducer)
    
    var body: some Scene {
        WindowGroup {
            CounterView()
                .environmentObject(store) // 注入 Store
        }
    }
}

处理副作用 (Side Effects)

上面的 Reducer 是纯的，但真实应用需要副作用（如网络请求、读写磁盘等）。纯函数不能处理这些。解决方案是使用 “Effect” 模式（这正是 The Composable Architecture (TCA) 等库的核心）。

  1. 让 Reducer 返回一个 Effect：Reducer 除了返回新 State，还返回一个描述副作用的 Effect 对象。
  2. Store 执行 Effect：Store 在运行 Reducer 后，会执行返回的 Effect（比如发起网络请求）。
  3. Effect 完成后派发新 Action：当网络请求完成时，Effect 会自动派发一个新的 Action（如 .dataLoaded(Result)），这个 Action 会再次通过 Reducer 来更新状态。

简化版的 Effect 示例：

// 1. 扩展 Action 来包含副作用结果
enum Action {
    case increment
    case fetchButtonTapped
    case dataLoaded(Result<Data, Error>)
}

// 2. Reducer 可以返回一个额外的 Effect
func appReducer(state: AppState, action: Action) -> (AppState, Effect<Action>?) {
    var newState = state
    var effect: Effect<Action>? = nil
    
    switch action {
    case .fetchButtonTapped:
        effect = Effect { // 返回一个发起网络请求的 Effect
            // 模拟网络请求
            let result = Result { try await fetchDataFromNetwork() }
            return Action.dataLoaded(result)
        }
    case .dataLoaded(.success(let data)):
        newState.data = data
    case .dataLoaded(.failure(let error)):
        newState.error = error
    ...
    }
    return (newState, effect)
}

// 3. Store 的 dispatch 方法需要处理返回的 Effect 并执行它。

在 UIKit 中的使用

在 UIKit 中，概念完全相同，但需要手动实现状态观察。

  1. Store 仍然是一个中心化的类。
  2. ViewControllers 需要订阅 Store 的状态变化（例如，使用 Combine 的 $state.sink {...}）。
  3. 在订阅的闭包中，根据新的 State 来手动更新 UI（设置 label 的 text、刷新 table view 等）。
  4. 在 IBAction 或代理方法中，调用 store.dispatch(...)。

优缺点分析

优点：

  • 可预测性：状态变化非常清晰，总是 Action -> Reducer -> New State。
  • 可调试性：可以轻松记录和重放每一个 Action 和状态快照。
  • 可测试性：Reducer 是纯函数，极易测试。只需给定输入，断言输出。
  • 单一数据源：避免了状态在不同组件间同步的难题。

缺点：

  • 样板代码 (Boilerplate)：需要为每个功能定义 State, Action, Reducer，略显繁琐。
  • 学习曲线：对于新手来说，概念相对复杂。
  • 性能：对于非常庞大的状态树，频繁复制整个 state 可能带来性能开销（但通常不是问题）。

总结与建议

  • 对于简单应用：直接使用 @Published 和 ObservableObject 可能更轻量。
  • 对于中大型复杂应用：Redux 架构能极大地提升代码的可维护性和可预测性。
  • 推荐使用库：手动实现完整的 Redux 和副作用处理比较复杂。强烈推荐使用 The Composable Architecture (TCA)，它是一个非常成熟、强大的 Swift 库，完美实现了 Redux 模式，并提供了出色的工具和测试支持。它大大减少了样板代码，是 iOS 上实践 Redux 的最佳选择。
avatar
文章
阅读
粉丝