RxSwift笔记七其他操作符

236 阅读1分钟

简介

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

subscribe

订阅,是连接观察者和被观察者的操作符.

public func subscribe(on: (event: RxSwift.Event<Self.E>) -> Void) -> Disposable 就是说我们接收到的是事件,在这里一般通过 switch case 获取对应结果。

let sequenceOfInts = PublishSubject<Int>()

_ = sequenceOfInts
    .subscribe {
        print($0)
}

sequenceOfInts.on(.Next(1))
sequenceOfInts.on(.Completed)

subscribeNext

指订阅next事件.

public func subscribeNext(onNext: (Self.E) -> Void) -> Disposable 因为只有一种事件,这里的 API 传入的就是事件中包含的具体的值了。

let sequenceOfInts = PublishSubject<Int>()

_ = sequenceOfInts
    .subscribeNext {
        print($0)
}

sequenceOfInts.on(.Next(1))
sequenceOfInts.on(.Completed)

subscribeCompleted / subscribeError

只订阅完成/错误事件.

subscribeOnnextOnErrorOnCompleted

public func subscribe(onNext onNext: (Self.E -> Void)? = default, onError: (ErrorType -> Void)? = default, onCompleted: (() -> Void)? = default, onDisposed: (() -> Void)? = default) -> Disposable

takeUntil

当另一个序列开始发射值时,忽略原序列发射的值。

let originalSequence = PublishSubject<Int>()
let whenThisSendsNextWorldStops = PublishSubject<Int>()

_ = originalSequence
    .takeUntil(whenThisSendsNextWorldStops)
    .subscribe {
        print($0)
}

originalSequence.on(.Next(1))
originalSequence.on(.Next(2))
originalSequence.on(.Next(3))

whenThisSendsNextWorldStops.on(.Next(1))

originalSequence.on(.Next(4))

takeWhile

跟filter类似,filter 和 takeWhile 什么时候更能清晰表达你的意思,就用哪个。

let sequence = PublishSubject<Int>()

_ = sequence
    .takeWhile { $0 < 4 }
    .subscribe {
        print($0)
}

sequence.on(.Next(1))
sequence.on(.Next(2))
sequence.on(.Next(3))
sequence.on(.Next(4))
sequence.on(.Next(5))

amb

处理多个序列,只会关心多个序列中最先发送数据的序列,其他序列会被忽略.

let intSequence1 = PublishSubject<Int>()
let intSequence2 = PublishSubject<Int>()
let intSequence3 = PublishSubject<Int>()

let _ = [intSequence1, intSequence2, intSequence3].amb()
    .subscribe {
    print($0)
}

intSequence2.onNext(10) // intSequence2 最先发射
intSequence1.onNext(1)
intSequence3.onNext(100)
intSequence1.onNext(2)
intSequence3.onNext(200)
intSequence2.onNext(20)

let intSequence1 = PublishSubject<Int>()
let intSequence2 = PublishSubject<Int>()

let _ = intSequence1.amb(intSequence2).subscribe { // 只用于比较两个序列
    print($0)
}

intSequence2.onNext(10) // intSequence2 最先发射
intSequence1.onNext(1)
intSequence1.onNext(2)
intSequence2.onNext(20)

concat

将两个序列合并成一个序列,当一个序列中的所有元素成功发射完成之后,才会发射另一个序列中的元素。 在第一个序列发射完成之前,第二个序列发射的事件都会被忽略,但会接收第一个序列发射完成前第二个序列发射的最后一个事件。

如有侵权,请告知删除.