RxSwift笔记三组合序列

简介

git地址: https://github.com/ReactiveX/RxSwift
    参考资料:http://t.swift.gg/d/2-rxswift
    
    ReactiveX是通过可观察的流实现异步编程的一种API，它结合了观察者模式、迭代器模式和函数式编程的精华，RxSwift 是 ReactiveX 编程思想的一种实现。
复制代码

startWith

let subscription = Observable.of(4, 5, 6, 7, 8, 9)
    .startWith(3)
    .startWith(2)
    .subscribe {
        print($0)
}
///打印:2,3,4, 5, 6, 7, 8, 9
复制代码

combineLatest

当两个序列任意一个发送数据时,combineLatest会结合并整理每个序列发射的最近数据项。
复制代码

let intOb1 = PublishSubject<String>()
let intOb2 = PublishSubject<Int>()

_ = Observable.combineLatest(intOb1, intOb2) {
    "(\($0) \($1))"
    }
    .subscribe {
        print($0)
}

intOb1.on(.Next("A"))
intOb2.on(.Next(1))
intOb1.on(.Next("B"))
intOb2.on(.Next(2))

///输出:(A 1) (B 1) (B 2)
复制代码

• 我们都要去传入 resultSelector 这个参数，一般我们做尾随闭包，这个是对两（多）个序列值的处理方式，上面的例子就是将序列一和二的值变成字符串，中间加个空格，外面再包一个() .
• Rx 在 combineLatest 上的实现，只能结合 8 个序列。再多的话就要自己去拼接了。

let intOb1 = Observable.just(2)
let intOb2 = ReplaySubject<Int>.create(bufferSize: 1)
intOb2.onNext(0)
let intOb3 = Observable.of(0, 1, 2, 3, 4)
intOb2.onNext(1)
    
_ = Observable.combineLatest(intOb1, intOb2, intOb3) {
    "\($0) \($1) \($2)"
    }
    .subscribe {
        print($0)
}
intOb2.onNext(2)
intOb2.onNext(3)

///输出: "210","211","212","213","214","224","234"
复制代码

let intOb1 = Observable.just(2)
let intOb2 = Observable.of(0, 1, 2, 3)
let intOb3 = Observable.of(0, 1, 2, 3, 4)

_ = [intOb1, intOb2, intOb3].combineLatest { intArray -> Int in
    Int((intArray[0] + intArray[1]) * intArray[2])
    }
    .subscribe { (event: Event<Int>) -> Void in
        print(event)
    }
    
    next(2)
    next(2)
    next(3)
    next(4)
    next(6)
    next(8)
    next(11)
    next(14)
    completed
复制代码

zip

zip 与 combineLatest 的区别是每当所有序列都发射一个值时， zip 才会发送一个值。它会等待每一个序列发射值，发射次数由最短序列决定。结合的值都是一一对应的。

let intOb1 = Observable.of(0, 1)
let intOb2 = Observable.of(0, 1, 2, 3)
let intOb3 = Observable.of(0, 1, 2, 3, 4)

_ = Observable.zip(intOb1, intOb2, intOb3) {
    ($0 + $1) * $2
    }
    .subscribe {
        print($0)
    }
复制代码

merge

merge是将多个序列合并成一个序列,序列发送的数据按照先后顺序合并,merge合并的是序列,也就是说序列发送序列才能使用merge.
复制代码

let subject1 = PublishSubject<Int>()
let subject2 = PublishSubject<Int>()

_ = Observable.of(subject1, subject2)
    .merge(maxConcurrent: 2)
    .subscribe {
        print($0)
}
subject1.on(.Next(20))
subject1.on(.Next(40))
subject1.on(.Next(60))
subject2.on(.Next(1))
subject1.on(.Next(80))
subject1.on(.Next(100))
subject2.on(.Next(1))
复制代码

switchLatest

switchLatest 和 merge 有一点相似，都是用来合并序列的。然而这个合并并非真的是合并序列。事实是每当发射一个新的序列时，丢弃上一个发射的序列.
复制代码

let var1 = Variable(0)
    
let var2 = Variable(200)
    
// var3 是一个 Observable<Observable<Int>>
let var3 = Variable(var1.asObservable())
    
let d = var3
    .asObservable()
    .switchLatest()
    .subscribe {
        print($0)
    }

var1.value = 1
var1.value = 2
var1.value = 3
var1.value = 4

var3.value = var2.asObservable() // 我们在这里新发射了一个序列
    
var2.value = 201
    
var1.value = 5 // var1 发射的值都会被忽略
var1.value = 6
var1.value = 7
复制代码

转载于:https://juejin.im/post/5ab0b97a6fb9a028d3753bec