Ignoring

ignoreElements

• Event 중, .next(value)인 element들을 무시하고, .error 혹은 .completed만 허용한다.

let disposeBag = DisposeBag()
let subject = PublishSubject<String>()
subject
    .ignoreElements()
    .subscribe {
        print("🟢", $0)
    }.disposed(by: disposeBag)

subject.on(.next("1"))
subject.on(.next("2"))
subject.on(.next("3"))
subject.on(.error(CustomError.error))
subject.on(.next("After error"))

elementAt

• input번째 element들만 허용하도록 한다.

Observable.from(1...5)
.elementAt(2)
.subscribe {
    print("🟢", $0)
}

filter

• input의 요구사항에 대한 element들만 허용하도록 한다.

Observable.from(1...5)
.filter { $0 % 2 == 0 }
.subscribe {
    print("🟢", $0)
}

Skipping

skip

• 0..<n 범위의 element를 skip하도록 한다.

Observable.from(1...5)
.skip(2)
.subscribe {
    print("🟢", $0)
}

skipWhile

• input의 요구사항이 true인 동안에는 element를 skip한다.
• false가 된 이후로는 element를 skip하지 않는다.

Observable.from(1...5)
.skipWhile { $0 < 3 }
.subscribe {
    print("🟢", $0)
}

skipUntil

• 다른 observable이 event를 방출하기 전까지, element를 skip한다.

let disposeBag = DisposeBag()

let subject = PublishSubject<String>()
let trigger = PublishSubject<Int>()

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

subject.on(.next("A"))
subject.on(.next("B"))

trigger.on(.next(0))

subject.on(.next("C"))
trigger.on(.next(1))

Taking

take

• 0..<n까지의 element를 취하도록 한다.

Observable.from(1...5)
.take(2)
.subscribe {
    print("🟢", $0)
}

takeWhile

• input의 요구사항이 true인 동안에는 element를 취하도록 한다.
• false가 된 이후로는 element를 취하지 않는다.

Observable.from(1...5)
.takeWhile { $0 < 3 }
.subscribe {
    print("🟢", $0)
}

takeUntil

• 다른 observable이 event를 방출하기 전까지, element를 취한다.

let disposeBag = DisposeBag()

let subject = PublishSubject<String>()
let trigger = PublishSubject<Int>()

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

subject.on(.next("A"))
subject.on(.next("B"))

trigger.on(.next(0))

subject.on(.next("C"))
trigger.on(.next(1))

Distinct

distinctUntilChanged

• input의 요구사항에 따라, 중복해서 이어지는 element를 방출하지 않는다.

Observable.of(1, 1, 2, 3, 4, 4, 5)
.enumerated()
.distinctUntilChanged { $0.element == $1.element }
.subscribe {
    print("🟢", $0)
}