RxSwift 深入浅出（二）高阶函数

RxSwift 这个框架看我就够了，这一篇我重点介绍高阶函数,掌握好RxSwift的高阶函数，是你通往成功的捷径。搞RxSwift，我是认真的

RxSwift 宝图镇博,咔咔点赞~~~~

Rxswift

• RxSwift 深入浅出（一）RxSwift初探

• RxSwift 深入浅出（二）高阶函数

• RxSwift 深入浅出（三）Subject

• RxSwift 深入浅出（四）控件应用

• RxSwift 深入浅出（五）tableView应用

• RxSwift 深入浅出（六）RxDataSources

• RxSwift 深入浅出（七）网络封装

• RxSwift 深入浅出（八）开发总结

import Foundation

import RxSwift
import RxCocoa

class FilteringVC: UIViewController {
    
    let disposedB = DisposeBag()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.view.backgroundColor = UIColor.orange
        
//        testFilter()
        testDistinctUntilChanged()
//        testSingle()
//        testElementAt()
//        testIgnoreElements()
//        testTake()
//        testTakeLast()
//        testSkip()
//        testSample()
//        testDebounce()
        
    }
    
    func testFilter(){
        //该操作符就是用来过滤掉某些不符合要求的事件。
        Observable.of(2, 30, 22, 5, 60, 3, 40 ,9)
            .filter {
                $0 > 10
            }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
    
    func testDistinctUntilChanged(){
        //该操作符用于过滤掉连续重复的事件。
        Observable.of(2, 2, 2, 5, 60, 3, 40 ,9)
            .distinctUntilChanged()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
    
    func testSingle(){
//        限制只发送一次事件，或者满足条件的第一个事件。
//        如果存在有多个事件或者没有事件都会发出一个 error 事件。
//        如果只有一个事件，则不会发出 error事件。

        Observable.of(2, 30, 22, 5, 60, 3, 40 ,9)
            .filter {
                $0 > 10
            }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
    
    func testElementAt(){
        //        限制只发送一次事件，或者满足条件的第一个事件。
        //        如果存在有多个事件或者没有事件都会发出一个 error 事件。
        //        如果只有一个事件，则不会发出 error事件。
        Observable.of(1, 2, 3, 4)
            .elementAt(2)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
    
    func testIgnoreElements(){
//        该操作符可以忽略掉所有的元素，只发出 error或completed 事件。
//        如果我们并不关心 Observable 的任何元素，只想知道 Observable 在什么时候终止，那就可以使用 ignoreElements 操作符。
        Observable.of(1, 2, 3, 4)
            .ignoreElements()
            .subscribe{
                print($0)
            }
            .disposed(by: disposedB)
    }
    
    func testTake(){
        //   该方法实现仅发送 Observable 序列中的前 n 个事件，在满足数量之后会自动 .completed。
        Observable.of(1, 2, 3, 4)
            .take(2)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
    
    func testTakeLast(){
        //   该方法实现仅发送 Observable 序列中的前 n 个事件，在满足数量之后会自动 .completed。
        Observable.of(1, 2, 3, 4)
            .takeLast(1)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
    
    func testSkip(){
        //   该方法实现仅发送 Observable 序列中的前 n 个事件，在满足数量之后会自动 .completed。
        Observable.of(1, 2, 3, 4)
            .skip(2)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
    func testSample(){
        //   该方法实现仅发送 Observable 序列中的前 n 个事件，在满足数量之后会自动 .completed。
        let source = PublishSubject<Int>()
        let notifier = PublishSubject<String>()
        source .sample(notifier)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
        source.onNext(1)
        //让源序列接收接收消息
        notifier.onNext("A")
        source.onNext(2)
        //让源序列接收接收消息
        notifier.onNext("B")
        notifier.onNext("C")
        source.onNext(3)
        source.onNext(4)
        //让源序列接收接收消息
        notifier.onNext("D")
        source.onNext(5)
        //让源序列接收接收消息
        notifier.onCompleted()
    
    }
    func testDebounce(){
//        debounce 操作符可以用来过滤掉高频产生的元素，它只会发出这种元素：该元素产生后，一段时间内没有新元素产生。
//        换句话说就是，队列中的元素如果和下一个元素的间隔小于了指定的时间间隔，那么这个元素将被过滤掉。
//        debounce 常用在用户输入的时候，不需要每个字母敲进去都发送一个事件，而是稍等一下取最后一个事件。
//
        //定义好每个事件里的值以及发送的时间
        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(Double(item["time"]!), scheduler: MainScheduler.instance)
            }
            .debounce(0.5, scheduler: MainScheduler.instance) //只发出与下一个间隔超过0.5秒的元素
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
    }
}

上面是经常使用的高阶函数，其实和swift的高阶函数是非常类似的，下面再讲几个有意思的高阶函数

class ViewController: UIViewController {

    let disposedB = DisposeBag()
    
    override func viewDidLoad() {
        super.viewDidLoad()

//        testBuffer()
//        testWindow()
//        testMap()
//        testFlatMap()
//        testConcatMap()
//        testGroupBy()
        
        self.present(FilteringVC(), animated: true, completion: nil)
    }
    
    func testGroupBy(){

//        groupBy 操作符将源 Observable 分解为多个子 Observable，然后将这些子 Observable 发送出来。
//        也就是说该操作符会将元素通过某个键进行分组，然后将分组后的元素序列以 Observable 的形态发送出来。

        Observable<Int>.of(1,2,3,4,5,6,7,8,9)
            .groupBy(keySelector: { (element) -> String in
                return element % 2 == 0 ? "偶数" : "基数"
            })
            .subscribe { (event) in
                switch event{
                case .next(let group):
                    group.asObservable()
                        .subscribe({ (event) in
                        print("event==\(event): \n key = \(group.key)")
                    })
                        .disposed(by:self.disposedB)
                case .completed:
                    print("完成")
                case .error(let myError):
                    print(myError)
                }
                
        }
         .disposed(by:disposedB)
        
        
    }
    
    func testConcatMap(){
        
        //concatMap 与 flatMap 的唯一区别是：当前一个 Observable 元素发送完毕后，后一个Observable 才可以开始发出元素。或者说等待前一个 Observable 产生完成事件后，才对后一个 Observable 进行订阅。
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
        let variable = Variable(subject1) //这里装进去1
        variable.asObservable()
            .concatMap { $0 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
        
        subject1.onNext("B")
        variable.value = subject2 //装进去2
        subject2.onNext("2")
        subject1.onNext("C")
        
        /**
         A
         B
         C ==>发现没有打印 1,2的数据,说明了subject1还没有完成
         */
        subject1.onCompleted()
        /**
         A
         B
         C
         2 //为什么没有打印1 因为在储存订阅的时候,发现1没有订阅,结果被2替换了储存,之后订阅,就能打印了
         */
    }
    
    func testFlatMap(){
//        map 在做转换的时候容易出现“升维”的情况。即转变之后，从一个序列变成了一个序列的序列。
//        而 flatMap 操作符会对源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。 然后将这些 Observables 的元素合并之后再发送出来。即又将其 "拍扁"（降维）成一个 Observable 序列。
//        这个操作符是非常有用的。比如当 Observable 的元素本生拥有其他的 Observable 时，我们可以将所有子 Observables 的元素发送出来。
      
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
        let variable = Variable(subject1) //这里装进去1
        variable.asObservable()
            .flatMap { $0 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposedB)
        
        subject1.onNext("B")
        variable.value = subject2 //装进去2
        subject2.onNext("2")
        subject1.onNext("C")
        //这样12都能打印
   
    }
    
    func testMap(){
    
        //该操作符通过传入一个函数闭包把原来的 Observable 序列转变为一个新的 Observable 序列。
        let subject = PublishSubject<String>()
        subject.map { (str) -> String in
            return str+"hello"
            }
            .subscribe(onNext: { (event) in
                print(event)
            }, onError: nil, onCompleted: {
                print("完成了")
            }) {
                print("销毁了")
            }
            .disposed(by: disposedB)
        
        subject.onNext("Cooci")
        
    }
    
    func testWindow(){
    
//        window 操作符和 buffer 十分相似。不过 buffer 是周期性的将缓存的元素集合发送出来，而 window 周期性的将元素集合以 Observable 的形态发送出来。
//        同时 buffer要等到元素搜集完毕后，才会发出元素序列。而 window 可以实时发出元素序列。
        
        let subject = PublishSubject<String>()
        subject.window(timeSpan: 2, count: 2, scheduler: MainScheduler.instance)
            .subscribe(onNext: { (event) in
                print(event)
            }, onError: nil, onCompleted: {
                print("完成了")
            }) {
                print("销毁了")
            }
            .disposed(by: disposedB)
        
        subject.onNext("111")
        subject.onNext("222")
        subject.onNext("333")
        
        subject.onNext("aaa")
        subject.onNext("bbb")
        subject.onNext("ccc")
        
    }
        
        
    
    func testBuffer(){
        //buffer 方法作用是缓冲组合，第一个参数是缓冲时间，第二个参数是缓冲个数，第三个参数是线程。
        //该方法简单来说就是缓存 Observable 中发出的新元素，当元素达到某个数量，或者经过了特定的时间，它就会将这个元素集合发送出来。
        
        let subject = PublishSubject<String>()
        subject.buffer(timeSpan: 2, count: 2, scheduler: MainScheduler.instance)
            .subscribe(onNext: { (event) in
                print(event)
            }, onError: nil, onCompleted: {
                print("完成了")
            }) {
                print("销毁了")
        }
        .disposed(by: disposedB)
        subject.onNext("111")
        subject.onNext("222")
        subject.onNext("333")

        subject.onNext("aaa")
        subject.onNext("bbb")
        subject.onNext("ccc")
        
        //这里每两秒打印一个事件
        //["111", "222"]
//        ["333", "aaa"]
//        ["bbb", "ccc"]
//        [] 当所有事件完毕,不会有储存事件,就会打印空
    }
    
}