let dispose = DisposeBag()

just()

通过传入默认值初始化，Observable泛型，指定类型和不指定类型都无所谓，swift会自动推断类型被订阅之后，会一次性输出事件的全部内容

let justFunc = Observable.just(1)
//        let justFunc = Observable.just([1, 2, 3, 4])
//        let justFunc = Observable.just("string")
//        let justFunc = Observable.just(["abc", 1, ["a", "b"], ["key1" : "value1", "key2" : "value2"]])

        justFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

of()

通过传入默认值初始化，Observable泛型，指定类型和不指定类型都无所谓，swift会自动推断类型，但是类型必须相同被订阅之后，会逐个输出事件的内容

let ofFunc = Observable.of(1, 2, 3, 4, 5, 6)
//        let ofFunc = Observable.of([1, 2, 3, 4, 5, 6], [1, 2, 3, 4], [4, 5, 6])

        ofFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

from()

通过传入默认值初始化，且必须是数组类型，被订阅之后，事件中数组的内容会逐个输出

let fromFunc = Observable.from([1, 2, 3, 4, 5, 6])
//        let fromFunc = Observable.from([1, 2, "3", 4, 5, 6])

        fromFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

empty()

创建一个空的Observable

let emptyFunc = Observable.empty()

never()

创建一个永远都不会发出事件的Observable

let neverFunc = Observable.never()

error()

创建一个发送错误error的Observable，Error是个enum类型

let errorFunc = Observable.error(NSError(domain: "local", code: 0, userInfo: nil))

range()

创建一个以start值为起始，count值为个数的Observable，且start的值和count的值必须为integer

let rangeFunc = Observable.range(start: 1, count: 9)

        rangeFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

repeatElement()

通过传入默认值初始化，创建一个以默认值为准的无线发送事件的Observable

let repeatElementFunc = Observable.repeatElement(1)

        repeatElementFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

generate()

创建一个通过传入初始值，在满足条件下循环执行的Observable

let generateFunc = Observable.generate(initialState: 2, condition: {
            $0 <= 10
        }, iterate: {
            $0 + 2
        })

        generateFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

create()

创建一个Observable

let observable = Observable.create{observer in
            //对订阅者发出了.next事件，且携带了一个数据"hangge.com"
            observer.onNext("hangge.com")
            //对订阅者发出了.completed事件
            observer.onCompleted()
            //因为一个订阅行为会有一个Disposable类型的返回值，所以在结尾一定要returen一个Disposable
            return Disposables.create()
        }

        //订阅测试
        observable.subscribe {
            print($0)
        }.disposed(by: dispose)

deferred()

创建一个输出Observable的Observable

let deferredFunc = Observable.deferred {
            return Observable.of(1)
        }

        deferredFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

interval()

创建一个在主线程(MainScheduler.instance)中，没隔一定的时间发送一个事件的Observable

let intervalFunc = Observable.interval(RxTimeInterval.seconds(1), scheduler: MainScheduler.instance)

        intervalFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

timer()

有两个API
第一种：创建一个在指定时间后，发送一次事件的Observable

let timerFunc = Observable.timer(RxTimeInterval.seconds(1), scheduler: MainScheduler.instance)


        timerFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

第二种：创建一个在指定时间后，每隔一个指定的时间发送一次事件的Observable

let timerFunc = Observable.timer(RxTimeInterval.seconds(1), period: RxTimeInterval.seconds(2), scheduler: MainScheduler.instance)


        timerFunc.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

buffer()

在指定的线程(scheduler)中，设置一个时间段(timeSpan)，缓存指定个数(count)的事件。
在该时间段内，如果缓存个数提前达到要求，则立即以集合的形式发送出去；如果该时间段内没有达到缓存个数要求，时间一到也立即把已经缓存到的事件以集合的形式发送出去。

let subject = PublishSubject()
        
        subject.buffer(timeSpan: RxTimeInterval.seconds(2), count: 3, scheduler: MainScheduler.instance).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        subject.onNext("1")
        subject.onNext("2")
        subject.onNext("3")
        subject.onNext("4")
        subject.onNext("5")
        subject.onNext("6")
        subject.onNext("7")
        subject.onNext("8")
        subject.onNext("9")

window()

在指定的线程(scheduler)中，设置一个时间段(timeSpan)，缓存指定个数(count)的Observable。
在该时间段内，实时的将缓存到的Observable发送出去。

let subject = PublishSubject()
        
        subject.window(timeSpan: RxTimeInterval.seconds(2), count: 3, scheduler: MainScheduler.instance).subscribe(onNext: { (content) in
            print("content = \(content)")
            content.subscribe { (event) in
                print("event = \(event)")
            }.disposed(by: self.dispose)
        }).disposed(by: dispose)
        
        subject.onNext("1")
        subject.onNext("2")
        subject.onNext("3")
        subject.onNext("4")
        subject.onNext("5")
        subject.onNext("6")
        subject.onNext("7")
        subject.onNext("8")

map()

将Observable的每个元素通过一个函数转换成一个新的Observable。

// RxSwift的map
        let array = Observable.of(1, 2, 3, 4, 5)
        
        array.map { item in
            item * 10
        }.subscribe { (item) in
            print("item = \(item)")
        }.disposed(by: dispose)
        
        // 系统的map
        let sysArrayMap = [1, 2, 3, 4, 5].map { item in
            item * 10
        }
        print(sysArrayMap)

flatMap()

将所有的Observable的每个元素压缩成一个Observable，再逐一发送出来。

let disposeBag = DisposeBag()
         
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
        let subject3 = BehaviorSubject(value: "a1")
         
        let relay = BehaviorRelay(value: subject1)
        
        relay.flatMap {
            $0
        }.subscribe(onNext: { (content) in
            print("content = \(content)")
            }).disposed(by: disposeBag)

        subject1.onNext("B")
        
        relay.accept(subject2)
        
        subject2.onNext("2")
        subject1.onNext("C")
        
        relay.accept(subject3)
        
        subject3.onNext("b2")
        subject3.onNext("c3")
        
        subject2.onNext("3")
        subject1.onNext("D")

flatMapLatest()

和flatMap用法相同，区别是只会处理最后一个赋值的Observable，之前赋值过的Observable再发送事件不会被接收。

let disposeBag = DisposeBag()
         
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
        let subject3 = BehaviorSubject(value: "a1")
         
        let relay = BehaviorRelay(value: subject1)
        
        relay.flatMapLatest {
            $0
        }.subscribe(onNext: { (content) in
            print("content = \(content)")
            }).disposed(by: disposeBag)

        subject1.onNext("B")
        
        relay.accept(subject2)
        
        subject2.onNext("2")
        subject1.onNext("C")
        
        relay.accept(subject3)
        
        subject3.onNext("b2")
        subject3.onNext("c3")
        
        // subject2和subject1的事件不会被接收
        subject2.onNext("3")
        subject1.onNext("D")
        
        subject3.onNext("d4")

flatMapFirst()

只会处理第一个赋值的Observable，后面所有再被赋值的Observable一律你接收。

scan()

初始化时指定一个值，遍历整个Observable，将所有参数通过一个函数逐一处理一遍，最后的结果再和初始值通过该函数处理。

let obser = Observable.of(1, 3, 5, 7, 9)
        
        obser.scan(2) { a,b in
            a * b
        }.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

groupBy()

将原Observable中的元素，按照指定的规则分成多个子Observable发送出来。

let obser = Observable.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
        
        obser.groupBy { (index) -> String in
            return index % 2 == 0 ? "偶数" : "奇数"
        }
        .subscribe { (event) in
            
//            print("event = \(event)")
            
            let key: String = event.element?.key ?? ""
            
            event.element?.subscribe(onNext: { (content) in
                print("key = \(String(describing: key)) content = \(content)")
            }).disposed(by: self.dispose)
            
        }.disposed(by: dispose)

filter()

将Observable中的元素，按照指定的条件发送出来。

let obser = Observable.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
        
        obser.filter { index in
            index > 5
        }.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        // 系统方法
        let array = [1, 2, 3, 4, 5]

        let result = array.filter { index in
            index > 3
        }

        print(result)

distinctUntilChanged()

过滤掉Observable中连续重复出现的元素。

let obser = Observable.of(1, 2, 1, 2, 3, 4, 1, 2, 1, 1, 1, 5)

        obser.distinctUntilChanged().subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

single()

筛选出Observable中符合条件的第一个元素并输出，如果满足条件的元素大于1或者Observable中元素没有满足条件的，将输出一个error。

let obser = Observable.of(1, 2, 1, 2, 3, 4, 1, 2, 1, 1, 1, 5)

        obser.single { item in
            item == 2
        }.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

elementAt()

创建时需要一个默认值，只输出Observable中指定位置的事件。

let obser = Observable.of(1, 2, 1, 2, 3, 4, 1, 2, 1, 1, 1, 5)

        obser.elementAt(2).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

ignoreElements()

获取Observable事件输出completed的状态。

let obser = Observable.of(1, 2, 1, 2, 3, 4, 1, 2, 1, 1, 1, 5)

        obser.ignoreElements().subscribe({ (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

take()

创建时需要一个默认值n，只输出Observable前n个事件，然后自动completed。

let obser = Observable.of(1, 2, 1, 2, 3, 4, 1, 2, 1, 1, 1, 5)

        obser.take(4).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

takeLast()

和take()相反，只输出Observable后n个事件。

skip()

和take()类似，跳过Observable中前n个事件，然后再逐一发送剩余的事件。

sample()

让ObservableA监听另一个ObservableB，当被监听的ObservableB有事件发出(不包括error)，ObservableA将发出最新产生的事件。

let source = PublishSubject()
        let notifier = PublishSubject()
         
        source
            .sample(notifier)
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)
         
        source.onNext(1)
         
        //让源序列接收接收消息
        notifier.onNext("A")
         
        source.onNext(2)
         
        //让源序列接收接收消息
        notifier.onNext("B")
        notifier.onNext("C")
         
        source.onNext(3)
        source.onNext(4)
         
        //让源序列接收接收消息
        notifier.onNext("D")
//        notifier.onError(NSError(domain: "local", code: 0, userInfo: nil))
         
        source.onNext(5)
         
        //让源序列接收接收消息
        notifier.onCompleted()

debounce()

在指定时间间隔内只输出Observable高频产生的最后一个时间。

let times = [
            [ "value": 1, "time": 0.1 ],
            [ "value": 2, "time": 1.1 ],
            [ "value": 3, "time": 1.2 ],
            [ "value": 4, "time": 1.2 ],
            [ "value": 5, "time": 1.4 ],
            [ "value": 6, "time": 2.1 ]
        ]
        
        //生成对应的 Observable 序列并订阅
        Observable.from(times)
            .flatMap { item in
                return Observable.of(Int(item["value"]!))
                    .delaySubscription(RxTimeInterval.seconds(Int(item["time"]!)), scheduler: MainScheduler.instance)
        }
            .debounce(RxTimeInterval.seconds(Int(0.5)), scheduler: MainScheduler.instance)
            .subscribe(onNext: { (content) in
                print("content = \(content)")
            })
            .disposed(by: dispose)

amb()

同时监听多个Observable，只输出第一个产生事件的Observable，剩余其他的Observable忽略。

        let subject1 = PublishSubject()
        let subject2 = PublishSubject()
        let subject3 = PublishSubject()
         
        subject1
            .amb(subject2)
            .amb(subject3)
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)
         
        subject2.onNext(1)
        subject1.onNext(20)
        subject2.onNext(2)
        subject1.onNext(40)
        subject3.onNext(0)
        subject2.onNext(3)
        subject1.onNext(60)
        subject3.onNext(0)
        subject3.onNext(0)

takeWhile()

根据条件，输出Observable陆续产生的满足条件的事件。

let obser = Observable.of(1, 2, 3, 4, 5, 6)
        
        obser.takeWhile { item in
            item < 4
        }.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

takeUntil()

让ObservableA监听另一个ObservableB，ObservableA持续发出事件，当被监听的ObservableB有事件发出，ObservableA将自动执行completed。

let source = PublishSubject()
        let notifier = PublishSubject()
         
        source
            .takeUntil(notifier)
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)
         
        source.onNext("a")
        source.onNext("b")
        source.onNext("c")
        source.onNext("d")
         
        //source停止接收消息
        notifier.onNext("z")
         
        source.onNext("e")
        source.onNext("f")
        source.onNext("g")

skipWhile()

输出Observable中，不满足条件的所有事件。

let obser = Observable.of(2, 3, 4, 5, 6)
            
        obser.skipWhile { $0 < 4 }
        .subscribe(onNext: { print($0) })
        .disposed(by: dispose)

skipUntil()

和takeUntil()类似，让ObservableA监听另一个ObservableB，ObservableA持续发出事件，但是全部被忽略，不被接收，当被监听的ObservableB有事件发出，ObservableA发出的事件才会被接收。

let source = PublishSubject()
        let notifier = PublishSubject()
         
        source
            .skipUntil(notifier)
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)
         
        source.onNext(1)
        source.onNext(2)
        source.onNext(3)
        source.onNext(4)
        source.onNext(5)
         
        //开始接收消息
        notifier.onNext(0)
         
        source.onNext(6)
        source.onNext(7)
        source.onNext(8)
         
        //仍然接收消息
        notifier.onNext(0)
         
        source.onNext(9)

startWith()

创建需要传入默认值，在预先知道Observable元素类型的前提下，提前对Observable插入一些默认值，当Observable有事件输出时，会先输出默认值。

let obser = Observable.of(1, 2, 3, 4, 5)
        
        obser.startWith(99, 88, 77).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

merge()

合并两个及以上的Observable，合成一个新的Observable，并输出所有事件。

let subject1 = PublishSubject()
        let subject2 = PublishSubject()
        
        let obser = Observable.of(subject1, subject2)
        
        obser.merge().subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        subject1.onNext(20)
        subject1.onNext(40)
        subject1.onNext(60)
        subject2.onNext(1)
        subject1.onNext(80)
        subject1.onNext(100)
        subject2.onNext(1)

zip()

合并两个及以上的Observable，合成一个新的Observable，并会自动合成一个元祖，且以最小count数的Observable的元素个数为准组合完成后再发出事件。

let subject1 = PublishSubject()
        let subject2 = PublishSubject()
        let subject3 = PublishSubject()
        
        let obser = Observable.zip(subject1, subject2, subject3)
        
        obser.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        subject1.onNext(20)
        subject3.onNext("40")
        subject1.onNext(60)
        subject2.onNext(1)
        subject1.onNext(80)
        subject1.onNext(100)
        subject2.onNext(1)
        subject3.onNext("abc")

combineLatest()

合并两个及以上的Observable，合成一个新的Observable，并会自动合成一个元祖，与zip不同的是，combineLatest会以"先到先组合"的规则将最新产生的元素合成并输出。

let subject1 = PublishSubject()
        let subject2 = PublishSubject()
        let subject3 = PublishSubject()
        
        let obser = Observable.combineLatest(subject1, subject2, subject3)
        
        obser.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        subject1.onNext(20)
        subject3.onNext("40")
        subject1.onNext(60)
        subject2.onNext(1)
        subject1.onNext(80)
        subject1.onNext(100)
        subject2.onNext(1)
        subject3.onNext("abc")

withLatestFrom()

ObservableA依赖ObservableB，当ObservableA自身有元素产生的时候，会输出ObservableB产生的最新的元素。

let subject1 = PublishSubject()
        let subject2 = PublishSubject()
        
        subject1.withLatestFrom(subject2).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        subject1.onNext(20)
        subject1.onNext(60)
        subject2.onNext("Aa")
        subject1.onNext(80)
        subject2.onNext("Bb")
        subject1.onNext(90)
        subject1.onNext(10)

switchLatest()

切换监听对象，切换后前一个被监听的Observable所有产生事件将不会被接收。

let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
         
        let replay = BehaviorRelay(value: subject1)
         
        replay.asObservable()
            .switchLatest()
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)
         
        subject1.onNext("B")
        subject1.onNext("C")
         
        //改变事件源
        replay.accept(subject2)
        subject1.onNext("D")
        subject2.onNext("2")
         
        //改变事件源
        replay.accept(subject1)
        subject2.onNext("3")
        subject1.onNext("E")

toArray()

将Observable中的所有元素整合成一个单一的事件并发送。

let obser = Observable.of(1, 2, 3, 4, 5)
        
        obser.toArray().subscribe { (content) in
            print("content = \(content)")
        }.disposed(by: dispose)

reduce()

创建时设置一个默认值，和一个运算符，将Observable中的所有元素用给定的运算符逐渐操作，最后结果再与默认值进行操作，输出最后的事件。

let obser = Observable.of(1, 2, 3, 4, 5)
        
        obser.reduce(2, accumulator: *).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

concat()

串联多个Observable，并在前一个Observable发送completed之后输出后一个Observable在赋值之后的所有的事件。

let sub1 = BehaviorSubject(value: 1)
        let sub2 = BehaviorSubject(value: 2)
        
        let relay = BehaviorRelay(value: sub1)
        
        relay.asObservable().concat().subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        sub1.onNext(1)
        sub1.onNext(1)
        sub2.onNext(2)
        
        // 重新赋值
        relay.accept(sub2)
        
        sub2.onNext(3)
        sub1.onCompleted()
        
        sub2.onNext(4)
        sub2.onNext(5)
        sub2.onNext(6)

publish()和connect()

publish()是将一个普通的Observable转换成一个可连接的Observable，一个可连接的Observable才能被connect()，一个可连接的Observable在被订阅之后不会立即发送事件，只有调用了connect()之后才会发送事件。

    let interval = Observable.interval(RxTimeInterval.seconds(1), scheduler: MainScheduler.instance).publish()
                 
        //第一个订阅者（立刻开始订阅）
        _ = interval
            .subscribe(onNext: { print("订阅1: \($0)") })
        
        // 开始连接
        interval.connect().disposed(by: dispose)
         
        //第二个订阅者（延迟5秒开始订阅）
        delay(5) {
            _ = interval
                .subscribe(onNext: { print("订阅22222: \($0)") })
        }
        
    func delay(_ delay: Double, closure: @escaping () -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
            closure()
        }
    }

replay()

replay()和publish()相同都是将一个普通的Observable转换成一个可连接的Observable，不同的是replay()创建需要一个默认值n，用于订阅后接收前一个Observable的最近的n个事件。

     let interval = Observable.interval(RxTimeInterval.seconds(1), scheduler: MainScheduler.instance).replay(2)
                 
        //第一个订阅者（立刻开始订阅）
        _ = interval
            .subscribe(onNext: { print("订阅1: \($0)") })
        
        // 开始连接
        interval.connect().disposed(by: dispose)
         
        //第二个订阅者（延迟5秒开始订阅）
        delay(5) {
            _ = interval
                .subscribe(onNext: { print("订阅22222: \($0)") })
        }
        
    func delay(_ delay: Double, closure: @escaping () -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
            closure()
        }
    }

multicast()

multicast()和publish()相同都是将一个普通的Observable转换成一个可连接的Observable，不同的是multicast()可以传入一个subject，当Observable被订阅之后，subject会跟着发送自己的事件。

    func someFuncTest() {
        
        //每隔1秒钟发送1个事件
        let subject = PublishSubject()
        
        subject.subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)
        
        let interval = Observable.interval(RxTimeInterval.seconds(1), scheduler: MainScheduler.instance).multicast(subject)
                 
        //第一个订阅者（立刻开始订阅）
        _ = interval
            .subscribe(onNext: { print("订阅1: \($0)") })
        
        // 开始连接
        interval.connect().disposed(by: dispose)
         
        //第二个订阅者（延迟5秒开始订阅）
        delay(5) {
            _ = interval
                .subscribe(onNext: { print("订阅22222: \($0)") })
        }
    }
        
    func delay(_ delay: Double, closure: @escaping () -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
            closure()
        }
    }

refCount()

将一个可连接的Observable转换成一个普通的Observable。

//每隔1秒钟发送1个事件
        let interval = Observable.interval(RxTimeInterval.seconds(1), scheduler: MainScheduler.instance).publish().refCount()
                 
        //第一个订阅者（立刻开始订阅）
        _ = interval
            .subscribe(onNext: { print("订阅1: \($0)") })
         
        //第二个订阅者（延迟5秒开始订阅）
        delay(5) {
            _ = interval
                .subscribe(onNext: { print("订阅22222: \($0)") })
        }

share()

share创建需要一个默认值n，共享Observable的事件，并从前一个订阅者的最近的n个事件开始发送事件。

//每隔1秒钟发送1个事件
        let interval = Observable.interval(RxTimeInterval.seconds(1), scheduler: MainScheduler.instance).share(replay: 1)
                 
        //第一个订阅者（立刻开始订阅）
        _ = interval
            .subscribe(onNext: { print("订阅1: \($0)") })
         
        //第二个订阅者（延迟5秒开始订阅）
        delay(5) {
            _ = interval
                .subscribe(onNext: { print("订阅22222: \($0)") })
        }
        
        //第三个订阅者
        delay(8) {
            _ = interval.subscribe(onNext: { (content) in
                print("content = \(content)")
            })
        }

delay()

创建时需要一个默认时间值n，当Observable被订阅后，Observable所有产生的事件将在延迟时间后发送。

let obser = Observable.of(1, 2, 3, 4, 5, 6)
        
        obser.delay(RxTimeInterval.seconds(3), scheduler: MainScheduler.instance).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

delaySubscription()

创建时需要一个默认时间值n，当经过该延迟时间后，Observable才会被订阅。

let obser = Observable.of(1, 2, 3, 4, 5, 6)
        
        obser.delaySubscription(RxTimeInterval.seconds(3), scheduler: MainScheduler.instance).subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

materialize()

将Observable的事件转化成元素，再发送出去。

let obser = Observable.of(1, 2, 3, 4, 5, 6)
        
        obser.materialize().subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

dematerialize()

和materialize()相反，将元素还原回事件，再发送出去。

timeout()

创建时设置一个默认的超时时间，当Observable在超时时间内没有元素发出将会产生一个超时的error事件。

//定义好每个事件里的值以及发送的时间
        let times = [
            [ "value": 1, "time": 0 ],
            [ "value": 2, "time": 0.5 ],
            [ "value": 3, "time": 1.5 ],
            [ "value": 4, "time": 4 ],
            [ "value": 5, "time": 5 ]
        ]
         
        //生成对应的 Observable 序列并订阅
        Observable.from(times)
            .flatMap { item in
                return Observable.of(Int(item["value"]!))
                    .delaySubscription(RxTimeInterval.seconds(Int(item["time"]!)),
                                       scheduler: MainScheduler.instance)
            }
            .timeout(RxTimeInterval.seconds(2), scheduler: MainScheduler.instance) //超过两秒没发出元素，则产生error事件
            .subscribe(onNext: { element in
                print(element)
            }, onError: { error in
                print(error)
            })
            .disposed(by: dispose)

catchErrorJustReturn()

捕获Observable发出的error事件。

let sequenceThatFails = PublishSubject()
         
        sequenceThatFails
            .catchErrorJustReturn("错误")
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)
         
        sequenceThatFails.onNext("a")
        sequenceThatFails.onNext("b")
        sequenceThatFails.onNext("c")
        sequenceThatFails.onError(MyError.A)
        sequenceThatFails.onNext("d")

catchError()

捕获Observable发出的error事件，并返回一个Observable。

let sequenceThatFails = PublishSubject()
        let recoverySequence = Observable.of("1", "2", "3")
         
        sequenceThatFails
            .catchError {
                print("Error:", $0)
                return recoverySequence
            }
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)
         
        sequenceThatFails.onNext("a")
        sequenceThatFails.onNext("b")
        sequenceThatFails.onNext("c")
        sequenceThatFails.onError(MyError.A)
        sequenceThatFails.onNext("d")

retry()

创建时需要传入一个默认值n，表示重试次数，不设置默认一次。

var count = 1
         
        let sequenceThatErrors = Observable.create { observer in
            observer.onNext("a")
            observer.onNext("b")
             
            //让第一个订阅时发生错误
            if count == 1 {
                observer.onError(MyError.A)
                print("Error encountered")
                count += 1
            }
             
            observer.onNext("c")
            observer.onNext("d")
            observer.onCompleted()
             
            return Disposables.create()
        }
         
        sequenceThatErrors
            .retry(2)  //重试2次（参数为空则只重试一次）
            .subscribe(onNext: { print($0) })
            .disposed(by: dispose)

debug()

创建时可以传入一个标记值，也可以传空，用于打印事件输出时的信息。

let obser = Observable.of(1, 2, 3, 4, 5, 6, 7)
        
        obser.startWith(0, 0, 0).debug().subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

single()

只发出Observable产生的一个元素并发出一个error事件，如果Observable的元素大于1或没有元素，single将发出一个error事件。

let obser = Observable.of(1, 2)
        
        obser.single().subscribe(onNext: { (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

asSingle()

将一个普通的Observable转化成single类型，如果Observable只有一个元素，只发出钙元素，如果Observable的元素大于1或没有元素，single将发出一个error事件。

let obser = Observable.of(1)
        
        obser.asSingle().subscribe({ (content) in
            print("content = \(content)")
        }).disposed(by: dispose)

RxSwift 操作符

just()

of()

from()

empty()

never()

error()

range()

repeatElement()

generate()

create()

deferred()

interval()

timer()

buffer()

window()

map()

flatMap()

flatMapLatest()

flatMapFirst()

scan()

groupBy()

filter()

distinctUntilChanged()

single()

elementAt()

ignoreElements()

take()

takeLast()

skip()

sample()

debounce()

amb()

takeWhile()

takeUntil()

skipWhile()

skipUntil()

startWith()

merge()

zip()

combineLatest()

withLatestFrom()

switchLatest()

toArray()

reduce()

concat()

publish()和connect()

replay()

multicast()

refCount()

share()

delay()

delaySubscription()

materialize()

dematerialize()

timeout()

catchErrorJustReturn()

catchError()

retry()

debug()

single()

asSingle()

你可能感兴趣的:(RxSwift 操作符)