Combine技术问询：流绑定、副作用处理及withLatestFrom替代方案

1. 更优的状态流绑定方式 #

你当前用sink手动发送到outputSubject的方式可以简化，推荐两种更贴合Combine设计思路的方案：

方案一：用scan维护状态（无额外Subject） #

直接用scan操作符管理状态流转，完全不需要依赖CurrentValueSubject，让整个数据流更纯粹：

private func transformPipeline() {
    let statePublisher = input
        .scan(.initial) { currentState, event in
            mapEventToState(event, with: currentState)
        }
        .handleOutput { state in
            handleSideEffects(for: state)
        }
    
    self.output = statePublisher.eraseToAnyPublisher()
}

方案二：用assign替代sink（保留Subject场景） #

如果必须保留outputSubject（比如需要手动修改状态的特殊场景），可以用assign简化发送逻辑：

input
    .map { event in
        mapEventToState(event, with: outputSubject.value)
    }
    .handleOutput { state in
        handleSideEffects(for: state)
    }
    .assign(to: \.value, on: outputSubject)
    .store(in: &cancellables)

2. Combine中等效RxSwift的withLatestFrom #

Combine原生自带withLatestFrom操作符，用法和RxSwift几乎一致：

• 仅获取第二个Publisher的最新值：

publisherA.withLatestFrom(publisherB)
    .sink { latestValueFromB in
        // 处理逻辑
    }
    .store(in: &cancellables)

• 同时保留原事件和第二个Publisher的最新值：

publisherA.withLatestFrom(publisherB) { eventFromA, latestValueFromB in
    return (eventFromA, latestValueFromB)
}
.sink { combinedValue in
    // 处理组合后的结果
}
.store(in: &cancellables)

3. 在handleOutput中访问原Event #

当前的map操作已经把Event转换成了State，后续无法直接获取原事件。可以通过元组封装的方式同时保留两者：

private func transformPipeline() {
    input
        .map { event -> (Event, State) in
            let newState = mapEventToState(event, with: outputSubject.value)
            return (event, newState)
        }
        .handleOutput { (event, state) in
            handleSideEffects(for: state)
            // 这里可以直接访问原event
            print("处理事件：\(event)，生成状态：\(state)")
        }
        .map { $0.1 } // 提取State，传给后续的Subject
        .assign(to: \.value, on: outputSubject)
        .store(in: &cancellables)
}

如果追求可读性，也可以自定义结构体来替代元组封装Event和State。

内容的提问来源于stack exchange，提问作者iOSer