RxSwift笔记 - Transforming Observables

map

该操作符通过传入一个函数闭包把原来的 Observable 序列转变为一个新的 Observable 序列

Observable.of(1, 3, 5, 7, 9)
    .map({ $0 * 10 })
    .subscribe(onNext: { value in
    print(value)
}).disposed(by: disposeBag)

/*
 10
 30
 50
 70
 90
 */

---

flatMap

将 Observable 的元素转换成其他的 Observable, 然后将这些 Observable 合并

let first = BehaviorSubject(value: "1")
let second = BehaviorSubject(value: "A")
let variable = Variable(first)

variable.asObservable()
    .flatMap({ $0 })
    .subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

first.onNext("2")
variable.value = second

second.onNext("B")
first.onNext("3")

/*
 1
 2
 A
 B
 3
 */

---

flatMapLatest

将 Observable 的元素转换成其他的 Observable，然后取这些 Observables 中最新的一个

一旦转换出一个新的 Observable，就只发出它的元素，旧的 Observables 的元素将被忽略掉

flatMapLatest 与 flatMap 的唯一区别是：flatMapLatest 只会接收最新的 value 事件

---

concatMap

它类似于最简单版本的flatMap，但是它按次序连接而不是合并那些生成的Observables，然后产生自己的数据序列

---

scan

scan 就是先给一个初始化的数，然后不断的拿前一个结果和最新的值进行处理操作。
持续的将 Observable 的每一个元素应用一个函数，然后发出每一次函数返回的结果

Observable<Int>.of(0, 1, 2, 3, 4, 5).scan(0) { (aggregateValue, newValue) in
    aggregateValue + newValue
    }.subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

/*
 0
 1
 3
 6
 10
 15
 */

---

groupBy

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

// 通过 **值大于10** 添加进行分组
Observable<Int>.of(1, 3, 5, 29, 55, 7, 88, 9).groupBy(keySelector: { (num) -> Bool in
    return num > 10
}).subscribe({ (event) in
    switch event {
    case .next(let group):
        group.asObservable().subscribe({ event in
            print("key: \(group.key)  event: \(event)")
        }).disposed(by: disposeBag)
    default:
        break
    }
}).disposed(by: disposeBag)

// 将奇数偶数分成两组
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: disposeBag)
        default:
            print("")
        }
    }.disposed(by: disposeBag)

---

buffer

缓存元素，然后将缓存的元素集合，周期性的发出来

buffer 方法作用是缓冲组合，第一个参数是缓冲时间，第二个参数是缓冲个数，第三个参数是线程。

该方法简单来说就是缓存 Observable 中发出的新元素，当元素达到某个数量，或者经过了特定的时间，它就会将这个元素集合发送出来。

let bufferID = Observable<Int>.create { (observer) -> Disposable in
    observer.onNext(1)
    observer.onNext(2)
    observer.onNext(3)
    observer.onNext(4)
    observer.onNext(5)
    observer.onNext(6)
    observer.onNext(7)
    observer.onCompleted()
    return Disposables.create()
}

bufferID.buffer(timeSpan: 0, count: 3, scheduler: MainScheduler.instance)
    .subscribe(onNext: { (nums) in
    print(nums)
}).disposed(by: disposeBag)

/*
 [1, 2, 3]
 [4, 5, 6]
 [7]
 */

window

将 Observable 分解为多个子 Observable，周期性的将子 Observable 发出来

window 操作符和 buffer 十分相似。不过 buffer 是周期性的将缓存的元素集合发送出来，而 window 周期性的将元素集合以 Observable 的形态发送出来。

Observable<Int>.of(0, 1, 2, 3, 4, 5).window(timeSpan: 1, count: 3, scheduler: MainScheduler.instance).asObservable().subscribe(onNext: { (observable) in
    observable.subscribe(onNext: { value in
        print(value)
    }).disposed(by: disposeBag)
}, onCompleted: {
    print("completed")
}, onDisposed: {
    print("disposed")
}).disposed(by: disposeBag)