本文是示例主要来自于官方的实例代码，可从这里下载 ，实例代码稍有改动。其中的图片来自于reactivex.io/

本文主要的作用是查看实例代码并查看对应实例代码的效果，不需要运行项目

操作符目录

• RxSwift官方使用示例之<创建和订阅Observables>
  • never、empty、just、of、from、create、range、repeatElement、generate、deferred、error、doOn
• RxSwift官方使用示例之<使用Subjects>
  • PublishSubject、ReplaySubject、BehaviorSubject
• RxSwift官方使用示例之<组合操作符>
  • startWith、merge、zip、combineLatest、Array.combineLatest、switchLatest、withLatestFrom
• RxSwift官方使用示例之<转换操作符>
  • map、flatMap 和 flatMapLatest、scan
• RxSwift官方使用示例之<过滤及条件操作符>
  • filter、distinctUntilChanged、elementAt、single、take、takeLast、takeWhile、takeUntil、skip、skipWhile、skipWhileWithIndex、skipUntil
• RxSwift官方使用示例之<数学和聚合操作符>
  • toArray、reduce、concat
• RxSwift官方使用示例之<可连接操作符>
  • interval、publish、replay、multicast
• RxSwift官方使用示例之<错误处理操作符>
  • catchAndReturn、catchError、retry、retry(_:)

debug 操作符会打印所有的 subscriptions, events, disposals

never

示例

创建一个永不终止且永不发出任何事件的序列

let disposeBag = DisposeBag()
let neverSequence = Observable<String>.never()

let neverSequenceSubscription = neverSequence
    .subscribe { _ in
        print("不可能进入这里")
}
neverSequenceSubscription.disposed(by: disposeBag)

无打印

核心源码分析

extension ObservableType {
    static func never() -> Observable<Element> {
        NeverProducer()
    }
}
private final class NeverProducer<Element>: Producer<Element> {
    override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        // `subscribe` 方法什么也没做，只返回了一个 `Disposable`，所以 不可能执行订阅的代码
        Disposables.create()
    }
}

empty

示例

创建一个只发出 Completed 事件的 Observable 序列

let disposeBag = DisposeBag()
    
Observable<Int>.empty()
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)

打印

completed

核心源码分析

extension ObservableType {
    static func empty() -> Observable<Element> {
        EmptyProducer()
    }
}
private final class EmptyProducer<Element>: Producer<Element> {
    override func subscribe<Observer>(_ observer: Observer) -> Disposable where Element == Observer.Element, Observer : ObserverType {
        // 此处只发送了一个Complete事件
        observer.onCompleted()
        return Disposables.create()
    }
}

just

示例

创建一个发送一个元素的 Observable 序列

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<Element> {
        Just(element)
    }
}
private final class Just<Element>: Producer<Element> {
    private let element: Element
    init(_ element: Element) {
        // 保存外面传来的元素
        self.element = element
    }
    override func subscribe<Observer>(_ 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<Element> {
        JustScheduled(element, scheduler: scheduler)
    }
}
// 这个类不用太过关注，可以认为是中间传参用的中间层，实际操作都在 Sink 里
// 这里实际是调用父类 Producer 的 subscribe 后会执行到 run 方法中，主要逻辑都在 run 方法中
// 而 run 方法的主要逻辑是：1 传递参数；2 调用 Sink 的 run 方法
private final class JustScheduled<Element>: Producer<Element> {
    fileprivate let scheduler: ImmediateSchedulerType
    fileprivate let element: Element
    
    init(_ element: Element, scheduler: ImmediateSchedulerType) {
        self.scheduler = scheduler
        self.element = element
    }
    override func run<Observer: ObserverType>(_ 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<Observer: ObserverType>: Sink<Observer> {
    typealias Parent = JustScheduled<Observer.Element>
    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<Element>: Observable<Element> {
    override init() {
        super.init()
    }
    
    private func sinkDisposer<Observer: ObserverType>(_ 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: ObserverType>(_ 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: ObserverType>(_ 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<Element> {
        ObservableSequence(elements: elements, scheduler: scheduler)
    }
}
private final class ObservableSequence<Sequence: Swift.Sequence>: Producer<Sequence.Element> {
    fileprivate let elements: Sequence
    fileprivate let scheduler: ImmediateSchedulerType
    
    init(elements: Sequence, scheduler: ImmediateSchedulerType) {
        self.elements = elements
        self.scheduler = scheduler
    }
    
    override func run<Observer: ObserverType>(_ 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<Sequence: Swift.Sequence, Observer: ObserverType>: Sink<Observer> where Sequence.Element == Observer.Element {
    typealias Parent = ObservableSequence<Sequence>
    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 序列

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 序列

let disposeBag = DisposeBag()
        
Observable<String>.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<Element>) -> Disposable) -> Observable<Element> {
        AnonymousObservable(subscribe)
    }
}

private final class AnonymousObservableSink<Observer: ObserverType>: Sink<Observer>, ObserverType {
    typealias Element = Observer.Element
    typealias Parent = AnonymousObservable<Element>
    
    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<Observer.Element>) {
        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<Element>: Producer<Element> {
    typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable
    let subscribeHandler: SubscribeHandler
    
    init(_ subscribeHandler: @escaping SubscribeHandler) {
        // 1. 外面传进来的闭包
        self.subscribeHandler = subscribeHandler
    }
    
    override func run<Observer: ObserverType>(_ 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 序列

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<Element> {
        RangeProducer(start: start, count: count, scheduler: scheduler)
    }
}
// 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注
private final class RangeProducer<Element: RxAbstractInteger>: Producer<Element> {
    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: ObserverType>(_ 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<Observer: ObserverType>: Sink<Observer> where Observer.Element: RxAbstractInteger {
    typealias Parent = RangeProducer<Observer.Element>
    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 序列

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<Element> {
        RepeatElement(element: element, scheduler: scheduler)
    }
}
// 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注
private final class RepeatElement<Element>: Producer<Element> {
    fileprivate let element: Element
    fileprivate let scheduler: ImmediateSchedulerType
    
    init(element: Element, scheduler: ImmediateSchedulerType) {
        self.element = element
        self.scheduler = scheduler
    }
    
    override func run<Observer: ObserverType>(_ 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<Observer: ObserverType>: Sink<Observer> {
    typealias Parent = RepeatElement<Observer.Element>
    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<Element> {
        Generate(initialState: initialState, condition: condition, scheduler: scheduler, iterate: iterate)
    }
}
// 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注
private final class Generate<Element>: Producer<Element> {
    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: ObserverType>(_ 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<Observer: ObserverType>: Sink<Observer> {
    typealias Parent = Generate<Observer.Element>
    
    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 序列

let disposeBag = DisposeBag()
var count = 1

let deferredSequence = Observable<String>.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<Element>) -> Observable<Element> {
        Deferred(observableFactory)
    }
}
// 1. 这个类可以见到的理解为传递参数用以及方法中转用的，不用特别关注
private final class Deferred<Source: ObservableType>: Producer<Source.Element> {
    typealias Factory = () throws -> Source
    
    fileprivate let observableFactory: Factory
    
    init(_ observableFactory: @escaping Factory) {
        self.observableFactory = observableFactory
    }
    
    override func run<Observer: ObserverType>(_ 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<Source: ObservableType, Observer: ObserverType>: Sink<Observer>, ObserverType where Source.Element == Observer.Element {
    typealias Element = Observer.Element
    typealias Parent = Deferred<Source>
    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<Element>) {
        // 6. 转发给真正的 订阅者
        forwardOn(event)
        switch event {
        case .next: break
        default: dispose()
        }
    }
}

error

示例

创建一个立即发送 error 的 Observable 序列

enum TestError: Error {
    case test
}
let disposeBag = DisposeBag()
        
Observable<Int>.error(TestError.test)
    .subscribe { print($0) }
    .disposed(by: disposeBag)

打印

error(test)

核心源码

extension ObservableType {
    static func error(_ error: Swift.Error) -> Observable<Element> {
        ErrorProducer(error: error)
    }
}

private final class ErrorProducer<Element>: Producer<Element> {
    private let error: Swift.Error
    
    init(error: Swift.Error) {
        self.error = error
    }
    
    override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Element == Observer.Element {
        // 订阅时直接发送 error 事件
        observer.on(.error(error))
        return Disposables.create()
    }
}

doOn

示例

为每个发出的事件调用副作用操作并返回原始事件

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