RxSwift学习笔记7：buffer/window/map/flatMap/flatMapLatest/flatMapFirst/concatMap/scan/groupBy

1.buffer的基本使用

     let publishSubject = PublishSubject<String>()
        //buffer 方法作用是缓冲组合，第一个参数是缓冲时间，第二个参数是缓冲个数，第三个参数是线程。
        //该方法简单来说就是缓存 Observable 中发出的新元素，当元素达到某个数量，或者经过了特定的时间，它就会将这个元素集合发送出来。
        
        publishSubject.buffer(timeSpan: 1, count: 3, scheduler: MainScheduler.instance).subscribe {
            print("($0)")
            }.disposed(by: disposeBag)
        
        publishSubject.onNext("a")
        publishSubject.onNext("b")
        publishSubject.onNext("c")
        publishSubject.onNext("d")
        publishSubject.onNext("e")
        publishSubject.onNext("f")
        
        publishSubject.onNext("1")
        publishSubject.onNext("2")
        publishSubject.onNext("3")
        
        /*
         =====count: 5
         next(["a", "b", "c", "d", "e"])
         next(["f", "1", "2", "3"])
         next([])
         next([])
         ........
         
         =====count: 3
         next(["a", "b", "c"])
         next(["d", "e", "f"])
         next(["1", "2", "3"])
         next([])
         next([])
         ........
         */

2.Window的基本使用

   // window基本介绍
        // window 操作符和 buffer 十分相似。不过 buffer 是周期性的将缓存的元素集合发送出来，而 window 周期性的将元素集合以 Observable 的形态发送出来。
        // 同时 buffer 要等到元素搜集完毕后，才会发出元素序列。而 window 可以实时发出元素序列。
        publishSubject.window(timeSpan: 1, count: 3, scheduler: MainScheduler.instance)
            .subscribe {[weak self] (observable) in
                print(observable)
                observable.element?.asObservable().subscribe{
                    print($0)
                    }.disposed(by: self!.disposeBag)
            }.disposed(by: disposeBag)
        
        publishSubject.onNext("a")
        publishSubject.onNext("b")
        publishSubject.onNext("c")
        
        publishSubject.onNext("1")
        publishSubject.onNext("2")
        publishSubject.onNext("3")
        
        /*
         next(RxSwift.AddRef<Swift.String>)
         next(a)
         next(b)
         next(c)
         completed
         next(RxSwift.AddRef<Swift.String>)
         next(1)
         next(2)
         next(3)
         completed
         next(RxSwift.AddRef<Swift.String>)
         completed
         next(RxSwift.AddRef<Swift.String>)
         ...
         */

        publishSubject.window(timeSpan: 1, count: 3, scheduler: MainScheduler.instance).subscribe( onNext: {[weak self] in
            print($0)
            $0.asObservable().subscribe(onNext:{
                print($0)
            }).disposed(by: self!.disposeBag)
        }).disposed(by: disposeBag)
        
        
        publishSubject.onNext("a")
        publishSubject.onNext("b")
        publishSubject.onNext("c")
        
        publishSubject.onNext("1")
        publishSubject.onNext("2")
        publishSubject.onNext("3")
        
        /*
         RxSwift.AddRef<Swift.String>
         a
         b
         c
         RxSwift.AddRef<Swift.String>
         1
         2
         3
         RxSwift.AddRef<Swift.String>
         RxSwift.AddRef<Swift.String>
         RxSwift.AddRef<Swift.String>
         ...
         */

3.map的基本使用：

//map:该操作符通过传入一个函数闭包把原来的 Observable 序列转变为一个新的 Observable 序列。
        Observable.of(1,2,3).map { (int) -> Int in
            return int*10
            }.subscribe(onNext: {
                print($0)
            }).disposed(by: disposeBag)
        //简写
        Observable.of(1,2,3).map { $0*10 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        print("===============")

4.flatmap基本使用：

//flatMap: ??
        //map 在做转换的时候容易出现“升维”的情况。即转变之后，从一个序列变成了一个序列的序列。
        //而 flatMap 操作符会对源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。
        //然后将这些 Observables 的元素合并之后再发送出来。即又将其 "拍扁"（降维）成一个 Observable 序列。
        //这个操作符是非常有用的。比如当 Observable 的元素本生拥有其他的 Observable 时，我们可以将所有子 Observables 的元素发送出来。
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
        let variable = Variable(subject1)
        
        variable.asObservable()
            .flatMap { $0 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        subject1.onNext("B")
        variable.value = subject2
        subject2.onNext("2")
        subject1.onNext("C")
        
        /*
         A
         B
         1
         2
         C
         */

5.flatMaplatest的基本使用：

//flatMapLatest: ??
        //flatMapLatest 与 flatMap 的唯一区别是：flatMapLatest 只会接收最新的 value 事件。
        variable.asObservable()
            .flatMapLatest { $0 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        subject1.onNext("B")
        variable.value = subject2
        subject2.onNext("2")
        subject1.onNext("C")
        
        /*
         A
         B
         1
         2
         */

6.groupBy的基本使用：

//groupBy:
        //groupBy 操作符将源 Observable 分解为多个子 Observable，然后将这些子 Observable 发送出来。
        //也就是说该操作符会将元素通过某个键进行分组，然后将分组后的元素序列以 Observable 的形态发送出来。
        Observable<Int>.of(0, 1, 2, 3, 4, 5)
            .groupBy(keySelector: { (element) -> String in
                return element % 2 == 0 ? "偶数" : "基数"
            })
            .subscribe { (event) in
                switch event {
                case .next(let group):
                    group.asObservable().subscribe({ (event) in
                        print("key：(group.key) event：(event)")
                    })
                        .disposed(by: self.disposeBag)
                default:
                    print("")
                }
            }
            .disposed(by: disposeBag)
        
        /*
         key：偶数 event：next(0)
         key：基数 event：next(1)
         key：偶数 event：next(2)
         key：基数 event：next(3)
         key：偶数 event：next(4)
         key：基数 event：next(5)
         key：偶数 event：completed
         key：基数 event：completed
         */