iOS开发进阶 - RxSwift: Filter相关方法

前言

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

从本篇开始接下来几篇文章会详细学习 RxSwift 中 Operators，作为 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/// 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

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/// 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

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

raywenderlich.com

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
/// 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
2
3
4
5
6
7
8
9
10
11
12
13
14
/// 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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/// 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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/// 以上都是静态的条件过滤元素，如果想基于其他序列动态过滤元素怎么办？
/// 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

1
2
3
4
5
6
7
8
9
10
11
12
13
/// 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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/// 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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/// 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
2
3
4
5
6
7
8
9
10
11
12
13
/// 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(_:)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/// 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)
}