Filter

过滤操作符（Filter）

• ignoreElements

过滤掉所有的.next事件

let strikes = PublishSubject()
let disposeBag = DisposeBag()
strikes.ignoreElements().subscribe { _ in
    print("You're out!")
}
.disposed(by: disposeBag)

• elementAt

只取elementAt指定的一个事件，其他事件全部忽略

let strikes = PublishSubject()
let disposeBag = DisposeBag()
strikes.elementAt(2).subscribe(onNext: { _ in
    print("You're out!")
})
.disposed(by: disposeBag)

• filter

只取满足filter条件的

let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4, 5, 6).filter { integer in
      integer % 2 == 0
}.subscribe(onNext: {
      print($0)
})
.disposed(by: disposeBag)

跳过操作符（Skip）

• skip

跳过前面几个事件

let disposeBag = DisposeBag()
Observable.of("A", "B", "C", "D", "E", "F").skip(3).subscribe(onNext: {
  print($0) 
})
.disposed(by: disposeBag)

• skipWhile

跳过所有满足条件的事件，直到碰到一个不满足条件的事件，发送这个不满足条件的事件，及后面所有的事件。

let disposeBag = DisposeBag()
Observable.of(2, 2, 3, 4, 4)
.skipWhile { integer in
  integer % 2 == 0
}.subscribe(onNext: {
  print($0)
})
.disposed(by: disposeBag)

• skipUntil

同时监听另外一个Observerable，只有这个Observerable发送了next事件，才会接收本身的事件

let disposeBag = DisposeBag()
let subject = PublishSubject()
let trigger = PublishSubject()
subject.skipUntil(trigger).subscribe(onNext: {
  print($0) 
})
.disposed(by: disposeBag)

取操作符（Take）

和Skip事件相反

• take

取前面几个事件

let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4, 5, 6).take(3).subscribe(onNext: {
  print($0) 
})
.disposed(by: disposeBag)

• takeWhile

取所有满足条件的事件，直到碰到一个不满足条件的事件，这个不满足条件的事件，及后面所有的事件都忽略

let disposeBag = DisposeBag()
Observable.of(2, 2, 4, 4, 6, 6)
  .enumerated()
  .takeWhile { index, integer in
    integer % 2 == 0 && index < 3
  }
  .subscribe(onNext: {
    print($0) 
    })
  .disposed(by: disposeBag)

.enumerated()的作用是，给序列生成索引index

• takeWhile

同时监听另外一个Observerable，只有这个Observerable发送了next事件，才停止接收本身的事件

let disposeBag = DisposeBag()
let subject = PublishSubject()
let trigger = PublishSubject()
subject.takeUntil(trigger).subscribe(onNext: {
  print($0) 
})
  .disposed(by: disposeBag)

变化操作符（Distinct）

• distinctUntilChanged

过滤掉连续一样的事件，注意是连续，例如"A", "A", "B", "B", "A"，那么过滤后的事件是"A", "B", "A"。

let disposeBag = DisposeBag()
Observable.of("A", "A", "B", "B", "A")
  .distinctUntilChanged()
  .subscribe(onNext: {
    print($0) 
    })
  .disposed(by: disposeBag)

事件是不是“一样“的判断，默认是根据Equatable协议判断。也可以直接设定条件。

.distinctUntilChanged {
  // 判断条件，返回bool值
}