如何在Swift Combine中用不同方式处理Publisher的首个值与其余值

问题背景 #

现有一个Combine Publisher，需要分别处理首个值和后续所有值，当前实现是创建两个独立订阅：

let bar = foo
    .first()
    .sink { value in
        print("first value is \(value)")
    }

let baz = foo
    .dropFirst()
    .sink { value in
        print("one of the rest is \(value)")
    }

foo.send(1)
foo.send(2)
foo.send(3)
foo.send(4)
foo.send(5)
foo.send(6)

该方案可行但不够简洁，希望合并为单个订阅，且无需外部状态标记。

解决方案1：使用enumerated()操作符（最简洁） #

enumerated()会为流中的每个元素附加索引，首个元素索引为0，后续依次递增，只需在sink中判断索引即可区分：

let foo = PassthroughSubject<Int, Never>()

let subscription = foo
    .enumerated()
    .sink { index, value in
        if index == 0 {
            print("first value is \(value)")
        } else {
            print("one of the rest is \(value)")
        }
    }

foo.send(1)
foo.send(2)
foo.send(3)
foo.send(4)
foo.send(5)
foo.send(6)

优点：代码极简，无需额外状态管理，完全依托Combine内置操作符实现。

解决方案2：使用scan追踪状态 #

通过scan操作符维护一个状态标记，记录当前是否是首个元素，后续在sink中根据状态处理：

let foo = PassthroughSubject<Int, Never>()

let subscription = foo
    .scan((isFirst: true, value: nil as Int?)) { state, currentValue in
        // 首次处理后标记为非首个元素
        (isFirst: false, value: currentValue)
    }
    .compactMap { ($0.value!, $0.isFirst) } // 解包值并传递状态
    .sink { value, isFirst in
        if isFirst {
            print("first value is \(value)")
        } else {
            print("one of the rest is \(value)")
        }
    }

foo.send(1)
foo.send(2)
foo.send(3)
foo.send(4)
foo.send(5)
foo.send(6)

优点：状态完全封装在流内部，无需外部变量，适合需要更复杂状态追踪的场景。

解决方案3：合并分流为带标记的单一流 #

通过自定义枚举区分元素类型，结合multicast确保分流后的流共享原始数据，再合并为单一流处理：

// 自定义枚举标记元素类型
enum ElementType<Value> {
    case first(Value)
    case rest(Value)
}

let foo = PassthroughSubject<Int, Never>()

let subscription = foo
    .multicast { PassthroughSubject<Int, Never>() } // 共享流避免重复发送
    .autoconnect()
    .flatMap { publisher -> AnyPublisher<ElementType<Int>, Never> in
        // 分流处理首个和其余元素，转换为带标记的流
        let firstStream = publisher
            .prefix(1)
            .map(ElementType.first)
        let restStream = publisher
            .dropFirst()
            .map(ElementType.rest)
        // 合并两个流
        return firstStream.merge(with: restStream).eraseToAnyPublisher()
    }
    .sink { element in
        switch element {
        case .first(let value):
            print("first value is \(value)")
        case .rest(let value):
            print("one of the rest is \(value)")
        }
    }

foo.send(1)
foo.send(2)
foo.send(3)
foo.send(4)
foo.send(5)
foo.send(6)

优点：类型安全，适合后续需要扩展更多元素类型处理逻辑的场景。

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