状态管理

import SwiftUI

struct CounterView: View {
    // 方式：@State
    // 源在这块视图自己身上。View 是结构体，body 会反复执行；
    // 存储跟视图身份走，所以重算之后 count 还是原来的数。
    @State private var count = 0

    var body: some View {
        Button("\(count)") {
            count += 1 // 事件里只改 @State，读过 count 的 body 会重算
        }
    }
}

import SwiftUI

struct CounterLabel: View {
    // 方式：@Binding
    // 子视图不持有存储。这里的 count 就是父视图那份 @State。
    @Binding var count: Int

    var body: some View {
        Button("\(count)") { count += 1 }
    }
}

struct CounterScreen: View {
    // 方式：@State，源在父视图
    @State private var count = 0

    var body: some View {
        // $count 的类型是 Binding<Int>，子视图因此能写回这一份
        CounterLabel(count: $count)
    }
}

import SwiftUI

@MainActor
@Observable // 方式：Observation。属性变化会通知读过它的视图
final class CounterModel {
    private(set) var count = 0 // 外面只能读，写入走 increment()

    func increment() {
        count += 1
    }
}

struct CounterModelView: View {
    // 方式：@State 持有 @Observable
    // 这里存的是类实例。视图重算不会换一个新的 CounterModel。
    @State private var model = CounterModel()

    var body: some View {
        Button("\(model.count)") {
            model.increment() // 改的是模型。body 读过 count，所以会重算
        }
    }
}

struct CounterReadout: View {
    // 方式：把 @Observable 只读传下来
    // let 不复制存储。子视图和父视图看的是同一个对象。
    let model: CounterModel

    var body: some View {
        Text("\(model.count)")
    }
}

import SwiftUI

@MainActor
@Observable
final class ProfileModel {
    var name = ""
}

struct NameField: View {
    // 方式：@Bindable
    // 对象是父视图持有的。@Bindable 只负责把 name 投影成 Binding<String>。
    @Bindable var model: ProfileModel

    var body: some View {
        TextField("名字", text: $model.name) // $model.name 写回 ProfileModel.name
    }
}

import SwiftUI

struct CounterRootView: View {
    // 方式：@State 持有，全树只创建这一次
    @State private var model = CounterModel()

    var body: some View {
        CounterDetailView()
            .environment(model) // 方式：环境注入。子视图不用逐层写参数
    }
}

struct CounterDetailView: View {
    // 方式：@Environment
    // 从祖先注入的那一份 @Observable 里取。读到的属性仍会触发重算。
    @Environment(CounterModel.self) private var model

    var body: some View {
        Text("\(model.count)")
    }
}

import Combine
import SwiftUI

final class LegacyCounterModel: ObservableObject {
    // 方式：@Published。赋值时通过 ObservableObject 通知界面
    @Published private(set) var count = 0

    func increment() {
        count += 1
    }
}

struct LegacyCounterView: View {
    // 方式：@StateObject
    // 由这块视图创建并持有。对象活在视图身份上，body 重算不会换新实例。
    @StateObject private var model = LegacyCounterModel()

    var body: some View {
        Button("\(model.count)") {
            model.increment()
        }
    }
}

import SwiftUI

struct SettingsView: View {
    // 方式：@AppStorage
    // 源在 UserDefaults，键是 "notificationsOn"。视图重算之后开关状态还在。
    @AppStorage("notificationsOn") private var notificationsOn = false

    var body: some View {
        Toggle("通知", isOn: $notificationsOn) // $ 得到 Binding，和 @State 传给子视图相同
    }
}

import UIKit

final class CounterViewController: UIViewController {
    private var count = 0 // 这一页的源
    private let label = UILabel()

    override func viewDidLoad() {
        super.viewDidLoad()
        label.frame = CGRect(x: 20, y: 100, width: 200, height: 40)
        view.addSubview(label)

        let button = UIButton(type: .system)
        button.frame = CGRect(x: 20, y: 150, width: 80, height: 40)
        button.setTitle("加一", for: .normal)
        button.addTarget(self, action: #selector(increment), for: .touchUpInside)
        view.addSubview(button)
        apply() // 第一次把 0 画上去
    }

    @objc private func increment() {
        count += 1
        apply() // 改完模型再画，标签只在这里写
    }

    private func apply() {
        label.text = "\(count)"
    }
}

import UIKit

final class ToggleRow: UIView {
    let toggle = UISwitch()
    var onChange: ((Bool) -> Void)? // 父视图填进来，用来接收新值

    override init(frame: CGRect) {
        super.init(frame: frame)
        toggle.addTarget(self, action: #selector(switched), for: .valueChanged)
        addSubview(toggle)
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    @objc private func switched() {
        onChange?(toggle.isOn)
    }
}

import UIKit

final class SettingsViewController: UIViewController {
    private var notificationsOn = false
    private let row = ToggleRow()

    override func viewDidLoad() {
        super.viewDidLoad()
        row.onChange = { [weak self] isOn in
            self?.notificationsOn = isOn // 源仍在设置页
            self?.apply()
        }
    }

    private func apply() {
        title = notificationsOn ? "开" : "关"
    }
}

import UIKit

struct Item: Identifiable {
    let id: UUID
    var title: String
}

enum Section: Hashable {
    case main
}

final class ItemListViewController: UIViewController {
    private var dataSource: UITableViewDiffableDataSource<Section, Item.ID>!

    func apply(items: [Item]) {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Item.ID>()
        snapshot.appendSections([.main])
        snapshot.appendItems(items.map(\.id)) // 快照里只放稳定 id
        dataSource.apply(snapshot, animatingDifferences: true)
    }
}

protocol CounterView: AnyObject {
    func show(count: Int)
}

final class CounterPresenter {
    private weak var view: CounterView? // 控制器持有 Presenter，这里用 weak 避免成环
    private var count = 0

    init(view: CounterView) {
        self.view = view
    }

    func increment() {
        count += 1
        view?.show(count: count)
    }
}

struct CounterState: Equatable {
    var count = 0
    var fact: String?
}

enum CounterAction {
    case incrementTapped
    case factLoaded(String)
}

func reduce(_ state: inout CounterState, _ action: CounterAction) {
    switch action {
    case .incrementTapped:
        state.count += 1 // 同步改状态，不在这里发请求
    case let .factLoaded(text):
        state.fact = text // 请求回来之后，用下一个动作写入
    }
}

import Combine

final class CounterViewModel {
    @Published private(set) var count = 0 // $count 会在每次赋值时发出新值

    func increment() {
        count += 1
    }
}

import Combine
import UIKit

final class CounterCombineViewController: UIViewController {
    private let viewModel: CounterViewModel
    private let label = UILabel()
    private var cancellables = Set<AnyCancellable>() // 订阅留在这里，控制器在才继续收值

    init(viewModel: CounterViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        viewModel.$count
            .receive(on: DispatchQueue.main) // 改控件排到主队列
            .sink { [weak self] count in
                self?.label.text = "\(count)"
            }
            .store(in: &cancellables)
    }

    @objc private func increment() {
        viewModel.increment()
    }
}

import Combine

final class SearchViewModel {
    @Published var keyword = ""
    private var cancellables = Set<AnyCancellable>()

    init() {
        $keyword
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main) // 停手 300 毫秒再往下
            .removeDuplicates() // 同一个词不重复搜索
            .sink { [weak self] text in
                self?.search(text)
            }
            .store(in: &cancellables)
    }

    private func search(_ text: String) {}
}

import RxRelay
import RxSwift

final class RxCounterViewModel {
    let count = BehaviorRelay(value: 0) // 记住当前值，新订阅者马上能拿到

    func increment() {
        count.accept(count.value + 1) // 用 accept 发出下一个值
    }
}

import RxSwift

viewModel.count
    .observe(on: MainScheduler.instance)
    .subscribe(onNext: { [weak self] count in
        self?.label.text = "\(count)"
    })
    .disposed(by: disposeBag) // 控制器释放时取消订阅

import ReactorKit
import RxSwift

final class CounterReactor: Reactor {
    enum Action {
        case increment
    }

    enum Mutation {
        case bump
    }

    struct State {
        var count = 0
    }

    let initialState = State()

    func mutate(action: Action) -> Observable<Mutation> {
        switch action {
        case .increment:
            return .just(.bump) // 没有网络，动作直接变成一次变更
        }
    }

    func reduce(state: State, mutation: Mutation) -> State {
        var state = state
        switch mutation {
        case .bump:
            state.count += 1 // 加一写在纯函数里，连点两次各加一次
        }
        return state
    }
}

import RxCocoa
import RxSwift

button.rx.tap
    .map { CounterReactor.Action.increment } // 点击变成动作
    .bind(to: reactor.action)
    .disposed(by: disposeBag)

reactor.state
    .map(\.count)
    .distinctUntilChanged()
    .observe(on: MainScheduler.instance)
    .subscribe(onNext: { [weak self] count in
        self?.label.text = "\(count)"
    })
    .disposed(by: disposeBag)

import ReSwift

struct AppState: StateType {
    var count = 0
}

struct Increment: Action {}

func counterReducer(action: Action, state: AppState?) -> AppState {
    var state = state ?? AppState() // 第一次进来还没有状态
    switch action {
    case is Increment:
        state.count += 1
    default:
        break // 别的页面的动作从这里走掉
    }
    return state
}

let store = Store<AppState>(reducer: counterReducer, state: nil)
store.dispatch(Increment())

import ComposableArchitecture

enum NumberAPI {
    static func fact(for count: Int) async -> String {
        "关于 \(count) 的说明"
    }
}

@Reducer
struct CounterFeature {
    @ObservableState
    struct State: Equatable {
        var count = 0
        var fact: String?
    }

    enum Action {
        case incrementTapped
        case factTapped
        case factResponse(String)
    }

    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .incrementTapped:
                state.count += 1
                return .none // 没有副作用

            case .factTapped:
                return .run { [count = state.count] send in
                    // 请求在 Effect 里。先抄出 count，闭包不抓整个 state
                    let fact = await NumberAPI.fact(for: count)
                    await send(.factResponse(fact)) // 结果再变回一个动作
                }

            case let .factResponse(fact):
                state.fact = fact
                return .none
            }
        }
    }
}

import ComposableArchitecture
import SwiftUI

struct CounterFeatureView: View {
    let store: StoreOf<CounterFeature>

    var body: some View {
        VStack {
            Button("\(store.count)") {
                store.send(.incrementTapped) // 视图只发动作，不自己改 count
            }
            Button("说明") {
                store.send(.factTapped)
            }
            if let fact = store.fact {
                Text(fact)
            }
        }
    }
}

CounterFeatureView(
    store: Store(initialState: CounterFeature.State()) {
        CounterFeature() // 初值和 Reducer 交给 Store，视图只拿着它
    }
)