empty,它會發送一個 Completed 事件，創建一個不發射任何數據但是正常終止的 Observable

// empty
        let emptySeq: Observable<Int> = empty()
        let subscription = emptySeq.subscribe { event in
            print(event)
        }
        // 輸出Completed

never 不會發送任何事件，創建一個不發射數據也不終止的 Observable

// never 
        let neverSeq: Observable<String> = never()
        let subscription = neverSeq.subscribe { event in
            print(event)
        }
        // 什么都沒用打印

just,會先發送Next(Value)，然后發送 Completed，創建一個發射指定值的 Observable。

Paste_Image.png

// just
        let justSeq = just("RxSwift")
        let subscription = justSeq.subscribe { event in
            print(event)
        }
        // 打印
        // Next(RxSwift)
        // Completed

sequenceOf 把一系列元素轉換為事件

// sequenceOf
        let sequenceElements = sequenceOf(1, 2, 3, 4)
        let subscription = sequenceElements.subscribe { event in
            print(event)
        }

from 通過 asObservable，把其他數據類型轉換為 Observable

Paste_Image.png

// asObservable, 把序列轉換成Observable
        let sequenceFromArray = [1, 2, 3, 4].asObservable()
        let subscription = sequenceFromArray.subscribe { event in
            print(event)
        }
        // 輸出
        // Next(1)
        // Next(2)
        // Next(3)
        // Next(4)
        // Completed

create，通過它重新創建一個Observable,通過.on發射Next和Completed事件

Paste_Image.png

// create創建序列，通過.on添加事件
        let myCreate = { (element: Int) -> Observable<Int> in
            return create { observer in
                observer.on(.Next(element))
                observer.on(.Completed)
                return NopDisposable.instance
            }
        }
        let subscription = myCreate(1).subscribe { event in
            print(event)
        }
        // 輸出
        // Next(1)
        // Completed

failWith

// failWith，只會發送Error事件
        let error = NSError(domain: "error", code: 1001, userInfo: nil)
        let errorSeq: Observable<Int> = failWith(error)
        let subscription = errorSeq.subscribe { event in
            print(event)
        }
        // 輸出
        // Error(Error Domain=error Code=1001 "(null)")

deferred 直到有訂閱者訂閱才創建 Observable，并為每一個訂閱者創建一個新的 Observable,在某些情況下，要等到最后一分鐘才能獲取到最新的數據，就需要這樣做

Paste_Image.png

// deferred 會等到有訂閱者，訂閱它才創建Observable
        let deferredSeq: Observable<Int> = deferred {
            print("create")
            return create { observer in
                observer.on(.Next(0))
                observer.on(.Next(1))
                observer.on(.Next(2))
                return NopDisposable.instance
            }
        }
        deferredSeq.subscribe { event in
            print(event)
        }
        /*
        create
        Next(0)
        Next(1)
        Next(2)
        */

Subjects

PublishSubject

// PublishSubject,會發送從訂閱者，訂閱之后的事件
        let subject = PublishSubject<String>()
        subject.subscribe { event in
            print("1->\(event)")
        }
        subject.on(.Next("a"))
        subject.on(.Next("b"))
        subject.subscribe { event in
            print("2->\(event)")
        }
        subject.on(.Next("c"))
        // 輸出
        /*
        1->Next(a)
        1->Next(b)
        1->Next(c)
        2->Next(c)
        */

Paste_Image.png

BehaviorSubject

// BehaviorSubject 它開始發射原始 Observable 最近發射的數據，然后繼續發送其他來自Observable的數據
        let subject = BehaviorSubject(value: "z")
        subject.subscribe { event in
            print("1->\(event)")
        }
        subject.on(.Next("a"))
        subject.on(.Next("b"))
        subject.subscribe { event in
            print("2->\(event)")
        }
        subject.on(.Next("c"))
        subject.on(.Completed)
        // 輸出
        1->Next(a)
        1->Next(b)
        1->Next(c)
        2->Next(c)

Paste_Image.png

ReplaySubject

// ReplaySubject,當有訂閱者，訂閱了的時候他能重發事件，bufferSize指定重發的次數,補發1次
        let subject = ReplaySubject<String>.create(bufferSize: 1)
        subject.subscribe { event in
            print("1->\(event)")
        }
        subject.on(.Next("a"))
        subject.on(.Next("b"))
        subject.subscribe { event in
            print("2->\(event)")
        }
        subject.on(.Next("c"))
        // 輸出
        /*
        1->Next(a)
        1->Next(b)
        2->Next(b)
        1->Next(c)
        2->Next(c)
        */

Paste_Image.png

Transform

map

Paste_Image.png

// map,通過對Observable發射映射的函數對每一項做轉換
        let originalSeq = sequenceOf(1, 2, 3)
        originalSeq.map { $0 * 2 }.subscribe { print($0) }
        /*
        輸出
        Next(2)
        Next(4)
        Next(6)
        Completed
        */

flatMap

// flatMap將一個發射數據的Observable變換為多個Observables，然后將它們發射的數據合并后放進一個單獨的Observable
        let seqInt = sequenceOf(1, 2, 3)
        let seqString = sequenceOf("a", "b", "c")
        seqInt.flatMap { int in seqString }.subscribe { print($0) }
        /*
        Next(a)
        Next(b)
        Next(c)
        Next(a)
        Next(b)
        Next(c)
        Next(a)
        Next(b)
        Next(c)
        Completed
        */

scan

Paste_Image.png

// scan連續的對序列中的元素應用某一個元素。然后把結果作為下一次的輸入
        let seqToSum = sequenceOf(1, 2, 3, 4)
        seqToSum.scan(0) { (sum, ele) -> Int in
            sum + ele
            }.subscribe { print($0) }
        /*
        輸入
        Next(1)
        Next(3)
        Next(6)
        */

Filtering

Paste_Image.png

// filter,過濾不符合要求的元素
        let seq = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8)
        seq.filter { $0 % 2 == 0 }
            .subscribe { print($0) }
        /*
        輸出
        Next(0)
        Next(2)
        Next(4)
        Next(6)
        Next(8)
        Completed
        */

distinct

// distinct,去掉相鄰的相同元素
        let seq = sequenceOf(1, 2, 2, 2, 3, 1, 1, 4, 1, 4)
        seq.distinctUntilChanged().subscribe { print($0) }
        /*
        輸出
        Next(1)
        Next(2)
        Next(3)
        Next(1)
        Next(4)
        Next(1)
        Next(4)
        Completed
        */

take

// take保留前幾項的數據
        let subscription = sequenceOf(1, 2, 3, 4 , 5).take(3).subscribe { print($0) }
        /*
        Next(1)
        Next(2)
        Next(3)
        Completed
        */

Combining(組合操作)

startWith

// startWith在數據序列前出入指定數據
        let subscription = sequenceOf(2, 3, 4, 5).startWith(1).subscribe { print($0) }
        /*
        Next(1)
        Next(2)
        Next(3)
        Next(4)
        Next(5)
        Completed
        */

combineLatest

Paste_Image.png

// combineLatest，當兩個Observables中任意一個發送了數據，使用一個函數把兩個Observable中最近的數據進行結合
        let stringOb = PublishSubject<String>()
        let intOb = PublishSubject<Int>()
        combineLatest(stringOb, intOb) {
            "\($0) \($1)"
            }.subscribe { print($0) }
        stringOb.on(.Next("A"))
        intOb.on(.Next(1))
        stringOb.on(.Next("B"))
        stringOb.on(.Next("C"))
        /*
        Next(A 1)
        Next(B 1)
        Next(C 1)
        */

zip

Paste_Image.png

// zip它會等到Observable中的數據一一對應結合時，再發送數據
        let stringOb = PublishSubject<String>()
        let intOb = PublishSubject<Int>()
        zip(stringOb, intOb) { "\($0) \($1)" }.subscribe { print($0) }
        stringOb.on(.Next("A"))
        stringOb.on(.Next("B"))
        intOb.on(.Next(1))
        intOb.on(.Next(2))

merge

Paste_Image.png

        // merge，合并對個Observables的發射物
        let subject1 = PublishSubject<Int>()
        let subject2 = PublishSubject<Int>()
        sequenceOf(subject1, subject2).merge().subscribe { print($0) }
        subject1.onNext(1)
        subject2.onNext(2)
        subject1.onNext(3)
        /*
        Next(1)
        Next(2)
        Next(3)
        */

switchLatest

// switchLatest,將一個Observable<Observable<T>>轉為為這樣的Observable,它逐個發射數據的Observable
        let var1 = Variable(0)
        let var3 = Variable(var1)
        let d = var3.switchLatest().subscribe { print($0) }