iOS开发进阶 - RxSwift :Filter相关操作

前言

万丈高楼平地起,前面两篇地基已经建好,现在开始第一层。
示例代码请移步Github
RxSwift 4.4

从本篇开始接下来几篇文章会详细学习 RxSwiftOperators,作为 Rx编程的基石,可以使用它来转换,处理和响应事件。

Operators 分为四个部分:

  • Filtering Operators:过滤
  • Transforming Operators : 转换
  • Combing Operators : 组合
  • Time-Based Operators : 基于时间操作

接下来学习过滤相关的操作。

Filtering Operators

过滤操作分为四类:

分类 主要方法 说明
Ignoring Operators ignoreElements elementAt filter 用于忽略一些元素
Skipping Operators skip skipWhile skipUntil
Taking Operators take takeWhile takeUntil
Distinct Operators distinctUntilChange distinctUntilChanged(_:)

从整体上了解要学习的内容,接下来详细分析各个操作作用,特点及区别联系。

Ignoring Operators

ignoreElements

特点:忽略所有的 .next 事件元素,允许终止事件通过。如:.completed.error。是不是应该想起来什么?ignoreElements 实际上返回一个 Completable

raywenderlich.com

①:表示源序列,可以被订阅
②:表示操作及参数
③:订阅

实例代码:

/// 1. ignoreElements : 忽略所有的 .next 事件元素,允许停止事件通过,如 .completed 和 .error.
/// 也许会发现:ignoreElements 实际上返回一个 Completable
example(of: "ignoreElements") {
    // 1. 创建 subject
    let strikes = PublishSubject<String>()
    let disposeBag = DisposeBag()
    // 2. 添加订阅
    strikes
        .ignoreElements() // 忽略所有元素
        .subscribe{_ in
            print("You are out!")
        }
        .disposed(by: disposeBag)
    
    strikes.onNext("X") // 无输出
    strikes.onNext("Y") // 无输出
    
    strikes.onCompleted() // 输出 You are out!
}

elementAt

特点: 获取指定位置的元素。只要获取到指定位置的元素,订阅就终止。

raywenderlich.com

示例代码:

/// 2. elementAt : 获取指定位置的元素。
/// 只要获取到指定位置的元素,订阅就终止。
example(of: "elementAt") {
    let strikes = PublishSubject<String>()
    let bag = DisposeBag()
    
    strikes
        .elementAt(2) // 获取序列中 index = 2 的元素
        .subscribe(onNext: { element in
            print("\(element) - You are out!")
        })
        .disposed(by: bag)
    strikes.onNext("X") // 无输出
    strikes.onNext("Y") // 无输出
    strikes.onNext("Z") // index = 2 输出
    
    // 输出:Z - You are out!
}

filter

特点:ignoreElementelementAt 过滤序列元素。有时不针对全部或单个元素操作。filter 提供了一个闭包,针对所有的元素,只要满足添加就可以输出。

raywenderlich.com

示例代码:

/// 3. ignoreElement 和 elementAt 过滤序列元素。有时不针对全部或单个元素操作。
/// filter 提供了一个闭包,针对所有的元素,只要满足添加就可以输出。
example(of: "filter") {
    let bag = DisposeBag()
    // 1. 创建一个序列
    Observable.of(1, 2, 3, 4, 5, 6)
        .filter{ $0 % 2 == 0} // 2. 过滤偶数
        .subscribe(onNext: { // 3. 订阅
            print($0)
        })
        .disposed(by: bag)
    // 输出: 2 4 6
}

Transforming Operators

skip

特点: 跳过指定数量的元素。

示例代码:

/// 1. skip() : 跳过指定数量的元素

example(of: "skip") {
    let bag = DisposeBag()
    
    // 1. 序列
    Observable.of("A", "B", "C", "D", "E", "F")
        .skip(3) // 2. 跳过三个元素
        .subscribe( onNext: { // 3. 订阅
            print($0)
        })
        .disposed(by: bag)
    // 输出: D E F
}

skipWhile

/// 2. skipWhile : 像 skip 一样决定哪些元素被忽略。
/// skipWhile 只跳过元素,直到第一个元素被允许通过,然后所有剩余的元素都被允许通过。
/// 闭包 返回 true 对应的元素将被忽略;返回 false 对应的元素通过。
/// 与 filter 操作相反。
example(of: "skipWhile") {
    let bag = DisposeBag()
    
    Observable.of(2, 2, 3, 4, 4) // 1. 序列
        .skipWhile { $0 % 2 == 0} // 2. 跳过 开始时的 偶数
        .subscribe(onNext: {
            print($0)
        })
        .disposed(by: bag)
    // 输出: 3 4 4
}

skipUntil

/// 以上都是静态的条件过滤元素,如果想基于其他序列动态过滤元素怎么办?
/// 3. skipUntil : 它将保持跳过原序列所有元素,直到触发序列发射 .next 事件,开始输出后续元素。
example(of: "skipUntil") {
    let bag = DisposeBag()
    // 1. 一个源序列,一个触发序列
    let subject = PublishSubject<String>()
    let trigger = PublishSubject<String>()
    
    // 2.
    subject
        .skipUntil(trigger) // 直到 trigger 序列有 .next 事件
        .subscribe(onNext: {
            print($0)
        })
        .disposed(by: bag)
    
    subject.onNext("A")
    subject.onNext("B") // 未输出
    trigger.onNext("X") // 触发
    subject.onNext("C")
    
    // 输出:C
}

Taking Operators

take

/// Taking 是与 Skipping 相反的操作。
/// 1. take: 获取几个元素
example(of: "take") {
    let bag  = DisposeBag()
    
    Observable.of(4, 5, 6, 7, 8, 9)
        .take(3) // 获取三个元素
        .subscribe(onNext: {
            print($0)
        })
        .disposed(by: bag)
    // 输出: 4 5 6
}

takeWhile

/// 2. takeWhile: 与 skipWhile 类似,不同点是用 taking 代替 skipping
example(of: "takeWhile") {
    let bag = DisposeBag()
    
    Observable.of(2, 2, 4, 4, 6, 6)
        .enumerated() // 1. 获取元组包含 index 和 element
        .takeWhile({ index, integer in // 2. 直到条件不成立停止
            integer % 2 == 0 && index < 3
        })
        .map { $0.element } // 3. 获取元素,生成只包含元素的序列
        .subscribe(onNext: { // 4. 订阅输出
            print($0)
        })
        .disposed(by: bag)
    
    // 输出: 2 2 4
}

takeUntil

/// 3. takeUntil: 与 skipUntil 类似
/// 持续获取源序列中元素,直到触发序列发送 .next 事件。
example(of: "takeUntil") {
    let bag = DisposeBag()
    // 1.
    let subject = PublishSubject<String>()
    let trigger = PublishSubject<String>()
    
    // 2.
    subject
        .takeUntil(trigger)
        .subscribe(onNext: {
            print($0)
        })
        .disposed(by: bag)
    // 3.
    subject.onNext("A")
    subject.onNext("B")
    trigger.onNext("1") // 触发序列终止源序列
    subject.onNext("C")
    // 输出:A B
    // 思考:是不是可以通过 takeUntil 监控 VC 的销毁。
}

Distinct Operators

distinctUntilChanged

/// 1. distinctUntilChanged : 阻止下一个重复元素
/// 只阻止相邻重复元素。
example(of: "distinctUntilChanged") {
    let bag = DisposeBag()
    
    Observable.of("A", "A", "B", "B", "A")
        .distinctUntilChanged()
        .subscribe(onNext: {
            print($0)
        })
        .disposed(by: bag)
    // 输出:A B A
}

distinctUntilChanged(_:)

/// 2. distinctUntilChanged(_:) 自定义比较
example(of: "distinctUntilChanged(_:)") {
    let bag = DisposeBag()
    // 1
    let formatter = NumberFormatter()
    formatter.numberStyle = .spellOut // 朗读形式,英文,例如:110 ==> ["one", "hundred", "ten"]
    // 2. 序列
    Observable<NSNumber>.of(10, 110, 20, 200, 210, 310)
        // 3
        .distinctUntilChanged { a, b in
            guard let aWords = formatter.string(from: a)?.components(separatedBy: " "),
            let bWords = formatter.string(from: b)?.components(separatedBy: " ")
            else {return false}
            print(aWords, bWords)
            var containsMatch = false
            for aWord in aWords where bWords.contains(aWord) {
                containsMatch = true
                break
            }
            return containsMatch
            /*
             第一次:["ten"] ["one", "hundred", "ten"] ==> true, 跳过 110
             第二次:["ten"] ["twenty"] ==> false
             第三次:["twenty"] ["two", "hundred"] ==> false
             第四次:["two", "hundred"] ["two", "hundred", "ten"] ==> true,跳过 210
             第五次:["two", "hundred"] ["three", "hundred", "ten"] ==> true, 跳过 310
             */
            
        }
        // 订阅
        .subscribe(onNext: {
            print($0)
        })
        .disposed(by: bag)
}

推荐阅读更多精彩内容