RxSwift中的take

对于我们使用RxSwift创建的信号，如果想有条件地执行订阅onnext，那么我们可以对创建的信号(Observable)先调用一次take方法，下面我们来了解一下相关的take方法。

一、take相关的方法介绍

1. take(_ count: Int) -> RxSwift.Observable

// 这里建立的信号可观察的序列, 被订阅时，会遍历序列中的元素逐个发送onNext；也可以自己创建别的信号来测试
Observable.of("🐱", "🐰", "🐶", "🐸", "🐷", "🐵")
    .take(2) // 这里使用了take，控制只能发送多少次
    .subscribe(onNext: {
        print($0)
    })
    .disposed(by: disposeBag)

这个方法是用来控制会发送多少次onNext，发送完后自动发送一个onComplete结束订阅，如上面代码只发送两次，执行的结果是：
🐱
🐰

2. take<Source>(until other: Source) -> RxSwift.Observable<Self.Element>

会对第二个信号（即参数other）进行监控，当other发送了onNext或者onError，则解除订阅（other发送onComplete则不会）。一般用于在控制器中订阅，使订阅关系跟随控制器的dealloc自动取消==》 take(until: self.rx.deallocated)

let observable1 = PublishSubject<Int>()
let observable2 = PublishSubject<Void>()
observable1
    .take(until: observable2)
    .subscribe(onNext: { print($0) }, onError: { error in  print("onError")   }, onCompleted: {  print("onCompleted---")  }, onDisposed: {  print("onDisposed---")    })
    .disposed(by: disposeBag)

observable1.onNext(1)
observable2.onNext(())
// observable2.onCompleted()
// observable2.onError(RxError.take)
observable1.onNext(4)

3. take(for duration: RxTimeInterval, scheduler: SchedulerType)

duration时间内订阅有效，过时会自动completed并且dispose。

let observable1 = PublishSubject<Int>()
observable1
    .take(for: .seconds(2), scheduler: MainScheduler.instance)
    .subscribe(onNext: { print($0) }, onError: { error in  print("onError")   }, onCompleted: {  print("onCompleted---")  }, onDisposed: {  print("onDisposed---")    })
    .disposed(by: disposeBag)

observable1.onNext(1)
DispatchQueue.main.asyncAfter(deadline: .now() + 2) {// 此时发送已经没用了
    observable1.onNext(3)
}

4. takeLast(_ count: Int) -> RxSwift.Observable

在一个数组元素中取出最后count个元素, 如下，最后打印出"🐸", "🐷", "🐵"

Observable.of("🐱", "🐰", "🐶", "🐸", "🐷", "🐵")
    .takeLast(3)
    .subscribe(onNext: {
        print($0)
    })
    .disposed(by: disposeBag)

5. take(until predicate: @escaping (Self.Element) throws -> Bool, behavior: RxSwift.TakeBehavior = .exclusive) -> RxSwift.Observable

这个方法的效果跟上述的takeUtil是一样的，只不过判定的方式换成了使用闭包。

Observable.of("🐱", "🐰", "🐶", "🐸", "🐷", "🐵")
    .take(until: { str in
        print("until",str)
        return  str == "🐶" // 遇到"🐶"之后就不再接收onNext
    })
    .subscribe(onNext: {
        print("onNext",$0)
    })
    .disposed(by: disposeBag)

打印：
until 🐱
onNext 🐱
until 🐰
onNext 🐰
until 🐶

6. take(while predicate: @escaping (Self.Element) throws -> Bool, behavior: RxSwift.TakeBehavior = .exclusive) -> RxSwift.Observable

这个方法内部是调用的上述5中的方法来实现的，这里的效果是while中返回为false则不再接收；为true则继续接收。

public func take(while predicate: @escaping (Element) throws -> Bool,
                 behavior: TakeBehavior = .exclusive)
    -> Observable<Element> {
    take(until: { try !predicate($0) }, behavior: behavior)
}

Observable.of("🐱", "🐰", "🐶", "🐸", "🐷", "🐵")
    .take(while: { str in
        print("while", str)
        return str == "🐰"// 当条件返回true则接收信号，返回false则不再接收信号
    })
    .subscribe(onNext: {
        print("onNext",$0)
    })
    .disposed(by: disposeBag)

打印：
while 🐰
onNext 🐰
while 🐰
onNext 🐰
while 🐶