如何使用 iOS MVVM 处理子视图中的用户交互

在这种情况下，我会问自己的第一个问题是，视图控制器中的任何状态是否必须根据单元格中的输入而更改。如果是这样，那么选项 2 是最佳选择（假设是 RxSwift）。如果您使用的是委托/闭包而不是 Observables，那么选项 3 可以方便地减少所需的委托数量。

从您的描述来看，当用户点击按钮时，视图控制器的状态似乎不需要更新，因此选项 1 听起来是最好的。

以下是我可能使用我的 CLE 架构实现它的方式......您可以将这些函数视为视图模型。connect

extension ViewController {
    // The view controller doesn't have much to do. Just fetch the array of
    // likables and show them on the table view.
    func connect(api: API) {
        api.response(.fetchLikables)
            .bind(to: tableView.rx.items(cellIdentifier: "Cell", cellType: LikableCell.self)) { _, item, cell in
                cell.connect(api: api, item: item)
            }
            .disposed(by: disposeBag)

        api.error
            .map { $0.localizedDescription }
            .bind(onNext: presentScene(animated: true) { message in
                UIAlertController(title: "Error", message: message, preferredStyle: .alert).scene {
                    $0.connectOK()
                }
            })
            .disposed(by: disposeBag)
    }
}

extension LikableCell {
    // The cell has the interesting behavior. If the thing is liked, then the
    // `likeButton` is selected. When the button is tapped, update the state
    // and send the network request. If the request fails, then reset the state.
    func connect(api: API, item: LikableThing) {
        enum Input {
            case tap
            case updateSucceeded
            case updateFailed
        }
        cycle(
            input: likeButton.rx.tap.map(to: Input.tap),
            initialState: (current: item.isLiked, reset: item.isLiked),
            reduce: { state, input in
                switch input {
                case .tap:
                    state.current.toggle() // toggle the like state right away.
                case .updateSucceeded:
                    state.reset = state.current // if server success, update the reset
                case .updateFailed:
                    state.current = state.reset // if server fail, update the current state.
                }
            },
            reaction: { args in
                args
                    .filter { $0.1 == .tap } // only make network request when user taps
                    .flatMapLatest { state, _ in
                        return api.successResponse(.setLikable(id: item.id, isLiked: !state.current))
                            .map { $0 ? Input.updateSucceeded : Input.updateFailed }
                    }
            }
        )
        .map { $0.current }
        .bind(to: likeButton.rx.isSelected)
        .disposed(by: disposeBag)
    }
}

struct LikableThing: Decodable, Identifiable {
    let id: Identifier<Int, LikableThing>
    let isLiked: Bool
}

extension Endpoint where Response == [LikableThing] {
    static let fetchLikables: Endpoint = Endpoint(
        request: apply(URLRequest(url: baseURL)) { request in
            // configure request
        },
        decoder: JSONDecoder()
    )
}

extension Endpoint where Response == Void {
    static func setLikable(id: LikableThing.ID, isLiked: Bool) -> Endpoint {
        let request = URLRequest(url: baseURL)
        // configure request
        return Endpoint(request: request)
    }
}