本文是示例主要来自于官方的实例代码，可从[这里](https://github.com/ReactiveX/RxSwift)下载，实例代码稍有改动。其中的图片来自于https://reactivex.io/ 本文主要的作用是查看实例代码并查看对应实例代码的效果，不需要运行项目 # 操作符目录 * [RxSwift官方使用示例之<创建和订阅Observables>](https://juejin.cn/post/7117900517279268895) * [never](https://juejin.cn/post/7117900517279268895#heading-0)、[empty](https://juejin.cn/post/7117900517279268895#heading-1)、[just](https://juejin.cn/post/7117900517279268895#heading-2)、[of](https://juejin.cn/post/7117900517279268895#heading-3)、[from](https://juejin.cn/post/7117900517279268895#heading-4)、[create](https://juejin.cn/post/7117900517279268895#heading-5)、[range](https://juejin.cn/post/7117900517279268895#heading-6)、[repeatElement](https://juejin.cn/post/7117900517279268895#heading-7)、[generate](https://juejin.cn/post/7117900517279268895#heading-8)、[deferred](https://juejin.cn/post/7117900517279268895#heading-9)、[error](https://juejin.cn/post/7117900517279268895#heading-10)、[doOn](https://juejin.cn/post/7117900517279268895#heading-11) * [RxSwift官方使用示例之<使用Subjects>](https://juejin.cn/post/7117911060404764708) * [PublishSubject](https://juejin.cn/post/7117911060404764708#heading-0)、[ReplaySubject](https://juejin.cn/post/7117911060404764708#heading-1)、[BehaviorSubject](https://juejin.cn/post/7117911060404764708#heading-2) * [RxSwift官方使用示例之<组合操作符>](https://juejin.cn/post/7117926031784640520) * [startWith](https://juejin.cn/post/7117926031784640520#heading-0)、[merge](https://juejin.cn/post/7117926031784640520#heading-1)、[zip](https://juejin.cn/post/7117926031784640520#heading-2)、[combineLatest](https://juejin.cn/post/7117926031784640520#heading-3)、[Array.combineLatest](https://juejin.cn/post/7117926031784640520#heading-4)、[switchLatest](https://juejin.cn/post/7117926031784640520#heading-5)、[withLatestFrom](https://juejin.cn/post/7117926031784640520#heading-6) * [RxSwift官方使用示例之<转换操作符>](https://juejin.cn/post/7117938639002140680) * [map](https://juejin.cn/post/7117938639002140680#heading-0)、[flatMap 和 flatMapLatest](https://juejin.cn/post/7117938639002140680#heading-1)、[scan](https://juejin.cn/post/7117938639002140680#heading-2) * [RxSwift官方使用示例之<过滤及条件操作符>](https://juejin.cn/post/7118575293375676430) * [filter](https://juejin.cn/post/7118575293375676430#heading-0)、[distinctUntilChanged](https://juejin.cn/post/7118575293375676430#heading-1)、[elementAt](https://juejin.cn/post/7118575293375676430#heading-2)、[single](https://juejin.cn/post/7118575293375676430#heading-3)、[take](https://juejin.cn/post/7118575293375676430#heading-4)、[takeLast](https://juejin.cn/post/7118575293375676430#heading-5)、[takeWhile](https://juejin.cn/post/7118575293375676430#heading-6)、[takeUntil](https://juejin.cn/post/7118575293375676430#heading-7)、[skip](https://juejin.cn/post/7118575293375676430#heading-8)、[skipWhile](https://juejin.cn/post/7118575293375676430#heading-9)、[skipWhileWithIndex](https://juejin.cn/post/7118575293375676430#heading-10)、[skipUntil](https://juejin.cn/post/7118575293375676430#heading-11) * [RxSwift官方使用示例之<数学和聚合操作符>](https://juejin.cn/post/7118585478672023582) * [toArray](https://juejin.cn/post/7118585478672023582#heading-0)、[reduce](https://juejin.cn/post/7118585478672023582#heading-1)、[concat](https://juejin.cn/post/7118585478672023582#heading-2) * [RxSwift官方使用示例之<可连接操作符>](https://juejin.cn/post/7118727129944047652) * [interval](https://juejin.cn/post/7118727129944047652/#heading-0)、[publish](https://juejin.cn/post/7118727129944047652/#heading-1)、[replay](https://juejin.cn/post/7118727129944047652/#heading-2)、[multicast](https://juejin.cn/post/7118727129944047652/#heading-3) * [RxSwift官方使用示例之<错误处理操作符>](https://juejin.cn/post/7118734421309521933) * [catchAndReturn](https://juejin.cn/post/7118734421309521933/#heading-0)、[catchError](https://juejin.cn/post/7118734421309521933/#heading-1)、[retry](https://juejin.cn/post/7118734421309521933/#heading-2)、[retry(_:)](https://juejin.cn/post/7118734421309521933/#heading-3) **debug 操作符会打印所有的 subscriptions, events, disposals** ## never ### 示例创建一个永不终止且永不发出任何事件的序列 ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fe92f26945684b1c84ed2d13f9ffcad3~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() let neverSequence = Observable.never() let neverSequenceSubscription = neverSequence .subscribe { _ in print("不可能进入这里") } neverSequenceSubscription.disposed(by: disposeBag) ``` 无打印 ### 核心源码分析 ``` extension ObservableType { static func never() -> Observable { NeverProducer() } } private final class NeverProducer: Producer { override func subscribe(_ observer: Observer) -> Disposable where Observer.Element == Element { // `subscribe` 方法什么也没做，只返回了一个 `Disposable`，所以不可能执行订阅的代码 Disposables.create() } } ``` ## empty ### 示例创建一个只发出 `Completed` 事件的 `Observable` 序列 ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/036af9e810fe4bb78f6adad579bf8ebe~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() Observable.empty() .subscribe { event in print(event) } .disposed(by: disposeBag) ``` 打印 ``` completed ``` ### 核心源码分析 ``` extension ObservableType { static func empty() -> Observable { EmptyProducer() } } private final class EmptyProducer: Producer { override func subscribe(_ observer: Observer) -> Disposable where Element == Observer.Element, Observer : ObserverType { // 此处只发送了一个Complete事件 observer.onCompleted() return Disposables.create() } } ``` ## just ### 示例创建一个发送一个元素的 `Observable` 序列 ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a70740f2634a406ca873ff3ce0111f86~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() Observable.just("🔴") .subscribe { event in print(event) } .disposed(by: disposeBag) ``` 打印 ``` next(🔴) completed ``` ### 核心源码分析1：无 `ImmediateSchedulerType` ``` extension ObservableType { static func just(_ element: Element) -> Observable { Just(element) } } private final class Just: Producer { private let element: Element init(_ element: Element) { // 保存外面传来的元素 self.element = element } override func subscribe(_ observer: Observer) -> Disposable where Element == Observer.Element, Observer : ObserverType { // 一次性发送外面传来的元素，并立即结束 observer.onNext(element) observer.onCompleted() return Disposables.create() } } ``` ### 核心源码分析2：有 `ImmediateSchedulerType` ``` extension ObservableType { static func just(_ element: Element, scheduler: ImmediateSchedulerType) -> Observable { JustScheduled(element, scheduler: scheduler) } } // 这个类不用太过关注，可以认为是中间传参用的中间层，实际操作都在 Sink 里 // 这里实际是调用父类 Producer 的 subscribe 后会执行到 run 方法中，主要逻辑都在 run 方法中 // 而 run 方法的主要逻辑是：1 传递参数；2 调用 Sink 的 run 方法 private final class JustScheduled: Producer { fileprivate let scheduler: ImmediateSchedulerType fileprivate let element: Element init(_ element: Element, scheduler: ImmediateSchedulerType) { self.scheduler = scheduler self.element = element } override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Element == Observer.Element { // 1. 传参 let sink = JustScheduledSink(parent: self, observer: observer, cancel: cancel) // 2. 调用 run let subscription = sink.run() return (sink, subscription) } } private final class JustScheduledSink: Sink { typealias Parent = JustScheduled private let parent: Parent // 传参 init(parent: Parent, observer: Observer, cancel: Cancelable) { self.parent = parent super.init(observer: observer, cancel: cancel) } func run() -> Disposable { let scheduler = parent.scheduler return scheduler.schedule(parent.element) { element in // 1 一次性发送 element 元素 self.forwardOn(.next(element)) return scheduler.schedule(()) { _ in // 2. 发送 complete 事件 self.forwardOn(.completed) self.dispose() return Disposables.create() } } } } ``` ### 补充一下 Producer 源码 ``` // 注意很重要： // Producer 是一个 Observable，也就是说它可以发送各种事件，可以 subscribe // RxSwift 中有很多类继承自 Producer，他们都可以发送各种事件，可以 subscribe class Producer: Observable { override init() { super.init() } private func sinkDisposer(_ observer: Observer) -> Disposable where Observer.Element == Element { let disposer = SinkDisposer() // 调用子类的 run 方法 let sinkAndSubscription = run(observer, cancel: disposer) disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription) return disposer } override func subscribe(_ observer: Observer) -> Disposable where Observer.Element == Element { if CurrentThreadScheduler.isScheduleRequired { // 1. 先执行这里 // schedule 内部会立即执行 sinkDisposer 方法 // 并取出当前线程中的任务去执行 return CurrentThreadScheduler.instance.schedule(()) { _ in return self.sinkDisposer(observer) } } else { // 2. 之后再执行这里 return sinkDisposer(observer) } } // 子类要实现的 run 方法 func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element { rxAbstractMethod() } } ``` ## of ### 示例创建一个有固定数目元素的 `Observable` 序列 ``` let disposeBag = DisposeBag() Observable.of("🐶", "🐱", "🐭", "🐹") .subscribe(onNext: { element in print(element) }) .disposed(by: disposeBag) ``` 打印 ``` 🐶 🐱 🐭 🐹 ``` ### 核心源码分析，主要代码在 `ObservableSequenceSink.run` ``` extension Observable { static func of(_ elements: Element..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable { ObservableSequence(elements: elements, scheduler: scheduler) } } private final class ObservableSequence: Producer { fileprivate let elements: Sequence fileprivate let scheduler: ImmediateSchedulerType init(elements: Sequence, scheduler: ImmediateSchedulerType) { self.elements = elements self.scheduler = scheduler } override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Sequence.Element == Observer.Element { let sink = ObservableSequenceSink(parent: self, observer: observer, cancel: cancel) let subscription = sink.run() return (sink, subscription) } } private final class ObservableSequenceSink: Sink where Sequence.Element == Observer.Element { typealias Parent = ObservableSequence private let parent: Parent init(parent: Parent, observer: Observer, cancel: Cancelable) { self.parent = parent super.init(observer: observer, cancel: cancel) } func run() -> Disposable { // 递归调用列表中的所有元素，一个个发送出去，直到 complete parent.scheduler.scheduleRecursive(parent.elements.makeIterator()) { iterator, recurse in var mutableIterator = iterator if let element = mutableIterator.next() { self.forwardOn(.next(element)) // 递归调用 recurse(mutableIterator) } else { self.forwardOn(.completed) self.dispose() } } } } ``` ## from ### 示例从Array、Dictionary、Set等序列创建一个 `Observable` 序列 ![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8112a790299648d1bbec59b21c424b7b~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() Observable.from(["🐶", "🐱", "🐭", "🐹"]) .subscribe(onNext: { element in print(element) }) .disposed(by: disposeBag) Observable.from(["A": 1, "B", 2]) .subscribe(onNext: { element in print(element) }) .disposed(by: disposeBag) ``` 打印 ``` 🐶 🐱 🐭 🐹 (key: "A", value: 1) (key: "B", value: 2) ``` ### 核心源码与 of 基本一样 ## create ### 示例创建一个自定义的 `Observable` 序列 ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f2a799dc42644997b48d764b1481fc9c~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() Observable.create { observer in observer.on(.next("A")) observer.on(.next("B")) observer.on(.next("C")) observer.on(.completed) return Disposables.create() } .subscribe { print($0) } .disposed(by: disposeBag) ``` 打印 ``` next(A) next(B) next(C) completed ``` ### 核心源码 ``` extension ObservableType { static func create(_ subscribe: @escaping (AnyObserver) -> Disposable) -> Observable { AnonymousObservable(subscribe) } } private final class AnonymousObservableSink: Sink, ObserverType { typealias Element = Observer.Element typealias Parent = AnonymousObservable private let isStoped = AtomicInt(0) override init(observer: Observer, cancel: Cancelable) { super.init(observer: observer, cancel: cancel) } // 4. create 中的 observer.on 方法就是这个方法 func on(_ event: Event) { switch event { case .next: if load(isStoped) == 1 { return } // 5. 给订阅者发送时间 forwardOn(event) case .error, .completed: if fetchOr(isStoped, 1) == 0 { // 5. 给订阅者发送时间 forwardOn(event) dispose() } } } // 3. 执行 run 方法，内部就是执行传进来的闭包 // 把自己包装成一个 AnyObserver，这个 observer 就是 create 闭包中的 observer 参数 func run(_ parent: Parent) -> Disposable { parent.subscribeHandler(AnyObserver(self)) } } private final class AnonymousObservable: Producer { typealias SubscribeHandler = (AnyObserver) -> Disposable let subscribeHandler: SubscribeHandler init(_ subscribeHandler: @escaping SubscribeHandler) { // 1. 外面传进来的闭包 self.subscribeHandler = subscribeHandler } override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Element == Observer.Element { let sink = AnonymousObservableSink(observer: observer, cancel: cancel) // 2. 在 subscribe 时会走到这里 let subscription = sink.run(self) return (sink, subscription) } } ``` ## range ### 示例创建一个发出一系列连续整数后终止的 `Observable` 序列 ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3a9ab2e108304973b507cd0f61b49e2f~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() Observable.range(start: 1, count: 10) .subscribe { print($0) } .disposed(by: disposeBag) ``` 打印 ``` next(1) next(2) next(3) next(4) next(5) next(6) next(7) next(8) next(9) next(10) completed ``` ### 核心源码 ``` extension ObservableType where Element: RxAbstractInteger { static func range(start: Element, count: Element, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable { RangeProducer(start: start, count: count, scheduler: scheduler) } } // 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注 private final class RangeProducer: Producer { fileprivate let start: Element fileprivate let count: Element fileprivate let scheduler: ImmediateSchedulerType init(start: Element, count: Element, scheduler: ImmediateSchedulerType) { guard count >= 0 else { rxFatalError("count can't be negative") } guard start &+ (count - 1) > start || count == 0 else { rxFatalError("overflow of count") } self.start = start self.count = count self.scheduler = scheduler } override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Element == Observer.Element { let sink = RangeSink(parent: self, observer: observer, cancel: cancel) let subscription = sink.run() return (sink, subscription) } } private final class RangeSink: Sink where Observer.Element: RxAbstractInteger { typealias Parent = RangeProducer private let parent: Parent init(parent: Parent, observer: Observer, cancel: Cancelable) { self.parent = parent super.init(observer: observer, cancel: cancel) } // 2. subscribe 的时候执行的核心代码在这里 func run() -> Disposable { parent.scheduler.scheduleRecursive(0 as Observer.Element) { i, recurse in // 3. 会递归的执行这里的代码，就是一个类似 while 循环的逻辑 if i < self.parent.count { self.forwardOn(.next(self.parent.start + i)) // 4. 递归调用 recurse(i + 1) } else { self.forwardOn(.completed) self.dispose() } } } } ``` ## repeatElement ### 示例创建一个无限期发射给定元素的 `Observable` 序列 ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/96c8b60b3b3c47f6abb65ab8fe623252~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() Observable.repeatElement("🔴") .take(3) // 只接收3个，注释的话会无限接收 .subscribe(onNext: { print($0) }) .disposed(by: disposeBag) ``` 打印 ``` 🔴 🔴 🔴 ``` ### 核心源码 ``` extension ObservableType { static func repeatElement(_ element: Element, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable { RepeatElement(element: element, scheduler: scheduler) } } // 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注 private final class RepeatElement: Producer { fileprivate let element: Element fileprivate let scheduler: ImmediateSchedulerType init(element: Element, scheduler: ImmediateSchedulerType) { self.element = element self.scheduler = scheduler } override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Element == Observer.Element { let sink = RepeatSink(parent: self, observer: observer, cancel: cancel) let subscription = sink.run() return (sink, subscription) } } private final class RepeatSink: Sink { typealias Parent = RepeatElement private let parent: Parent init(parent: Parent, observer: Observer, cancel: Cancelable) { self.parent = parent super.init(observer: observer, cancel: cancel) } // 2. subscribe 的时候执行的核心代码在这里 func run() -> Disposable { return parent.scheduler.scheduleRecursive(parent.element) { state, recurse in self.forwardOn(.next(state)) // 3. 递归调用 recurse(state) } } } ``` ## generate ### 示例创建一个根据条件生成值的 `Observable` 序列 ``` let disposeBag = DisposeBag() Observable.generate( initialState: 0, condition: { $0 < 3 }, iterate: { $0 + 1 } ) .subscribe(onNext: { print($0) }) .disposed(by: disposeBag) ``` 打印 ``` 1 2 3 ``` ### 核心源码 ``` extension ObservableType { static func generate(initialState: Element, condition: @escaping (Element) throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: @escaping (Element) throws -> Element) -> Observable { Generate(initialState: initialState, condition: condition, scheduler: scheduler, iterate: iterate) } } // 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注 private final class Generate: Producer { fileprivate let initialState: Element fileprivate let condition: (Element) throws -> Bool fileprivate let iterate: (Element) throws -> Element fileprivate let scheduler: ImmediateSchedulerType init(initialState: Element, condition: @escaping (Element) throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: @escaping (Element) throws -> Element) { self.initialState = initialState self.condition = condition self.iterate = iterate self.scheduler = scheduler super.init() } override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Element == Observer.Element { let sink = GenerateSink(parent: self, observer: observer, cancel: cancel) let subscription = sink.run() return (sink, subscription) } } private final class GenerateSink: Sink { typealias Parent = Generate private let parent: Parent private var state: Observer.Element init(parent: Parent, observer: Observer, cancel: Cancelable) { self.parent = parent self.state = parent.initialState super.init(observer: observer, cancel: cancel) } // 2. subscribe 的时候执行的核心代码在这里 func run() -> Disposable { parent.scheduler.scheduleRecursive(true) { isFirst, recurse in do { if !isFirst { self.state = try self.parent.iterate(self.state) } // 3. 判断是否符合条件 if try self.parent.condition(self.state) { // 4. 生成需要的值 let result = try self.parent.iterate(self.state) // 5. 发送生成的值 self.forwardOn(.next(result)) // 6. 递归 recurse(false) } else { // 7. 不符合条件时结束 self.forwardOn(.completed) self.dispose() } } catch { self.forwardOn(.error(error)) self.dispose() } } } } ``` ## deferred ### 示例为每一个订阅者创建一个新的 `Observable` 序列 ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0da004df88244b3db28832268248a6a3~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() var count = 1 let deferredSequence = Observable.deferred { print("Creating \(count)") count += 1 return Observable.create { observer in print("Emitting...") observer.onNext("🐶") observer.onNext("🐱") observer.onNext("🐵") return Disposables.create() } } deferredSequence .subscribe(onNext: { print($0) }) .disposed(by: disposeBag) deferredSequence .subscribe(onNext: { print($0) }) .disposed(by: disposeBag) ``` 打印 ``` Creating 1 Emitting... 🐶 🐱 🐵 Creating 2 Emitting... 🐶 🐱 🐵 ``` ### 核心源码 ``` extension ObservableType { static func deferred(_ observableFactory: @escaping () throws -> Observable) -> Observable { Deferred(observableFactory) } } // 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注 private final class Deferred: Producer { typealias Factory = () throws -> Source fileprivate let observableFactory: Factory init(_ observableFactory: @escaping Factory) { self.observableFactory = observableFactory } override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Source.Element == Observer.Element { let sink = DeferredSink(parent: self, observer: observer, cancel: cancel) let subscription = sink.run() return (sink, subscription) } } private final class DeferredSink: Sink, ObserverType where Source.Element == Observer.Element { typealias Element = Observer.Element typealias Parent = Deferred private let parent: Parent init(parent: Parent, observer: Observer, cancel: Cancelable) { self.parent = parent super.init(observer: observer, cancel: cancel) } // 2. subscribe 的时候执行的核心代码在这里 func run() -> Disposable { do { // 3. 生成一个新的 Observable let result = try parent.observableFactory() // 4. 新的 Observable 订阅自己 return result.subscribe(self) } catch { forwardOn(.error(error)) dispose() return Disposables.create() } } // 5. 有事件时，自己接收事件 func on(_ event: Event) { // 6. 转发给真正的订阅者 forwardOn(event) switch event { case .next: break default: dispose() } } } ``` ## error ### 示例创建一个立即发送 `error` 的 `Observable` 序列 ``` enum TestError: Error { case test } let disposeBag = DisposeBag() Observable.error(TestError.test) .subscribe { print($0) } .disposed(by: disposeBag) ``` 打印 ``` error(test) ``` ### 核心源码 ``` extension ObservableType { static func error(_ error: Swift.Error) -> Observable { ErrorProducer(error: error) } } private final class ErrorProducer: Producer { private let error: Swift.Error init(error: Swift.Error) { self.error = error } override func subscribe(_ observer: Observer) -> Disposable where Element == Observer.Element { // 订阅时直接发送 error 事件 observer.on(.error(error)) return Disposables.create() } } ``` ## doOn ### 示例为每个发出的事件调用副作用操作并返回原始事件 ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7f937457d1cf4ad6af32ef2e1fa473a5~tplv-k3u1fbpfcp-watermark.image?) ``` let disposeBag = DisposeBag() Observable.of("🍎", "🍐", "🍊", "🍋") .do(onNext: { print("Intercepted:", $0) }, afterNext: { print("Intercepted after:", $0) }, onError: { print("Intercepted error:", $0) }, afterError: { print("Intercepted after error:", $0) }, onCompleted: { print("Completed") }, afterCompleted: { print("After completed") }) .subscribe(onNext: { print($0) }) .disposed(by: disposeBag) ``` 打印 ``` Intercepted: 🍎 🍎 Intercepted after: 🍎 Intercepted: 🍐 🍐 Intercepted after: 🍐 Intercepted: 🍊 🍊 Intercepted after: 🍊 Intercepted: 🍋 🍋 Intercepted after: 🍋 Completed After completed ```