[RxSwift] Operators - 필터링(3)

소스 Observable에서 선택적으로 항목을 배출하는 연산자들 - Debounce, Distinct, ElementAt, Filter, First, IgnoreElements, Sample, Skip, Take

 

안녕하세요 ◠‿◠ 고고입니다.

 

1. Debounce

• Debounce — Observable의 시간 흐름이 지속되는 상태에서 다른 항목들은 배출하지 않고 특정 시간 마다 그 시점에 존재하는 항목 하나를 Observable로부터 배출한다

구현부

public func debounce(_ dueTime: RxTimeInterval, scheduler: SchedulerType)
        -> Observable<Element> {
            return Debounce(source: self.asObservable(), dueTime: dueTime, scheduler: scheduler)
    }

 

- Throttle

public func throttle(_ dueTime: RxTimeInterval, latest: Bool = true, scheduler: SchedulerType)
        -> Observable<Element> {
        Throttle(source: self.asObservable(), dueTime: dueTime, latest: latest, scheduler: scheduler)
    }

 

debounce vs throttle 참고 링크 : [RxSwift] 5. throttle, debounce

 

2. Distinct

• Distinct — Observable이 배출하는 항목들 중 중복을 제거한 항목들을 배출한다

구현부

public func distinctUntilChanged()
        -> Observable<Element> {
        self.distinctUntilChanged({ $0 }, comparer: { ($0 == $1) })
    }

예시

let test = ["a","a","b","c","c","c"]

let source = Observable.from(test).distinctUntilChanged()

source.subscribe{ print($0) }

// next(a)
// next(b)
// next(c)
// completed

 

3. ElementAt

• ElementAt — Obserable에서 n번째 항목만 배출한다

구현부

public func element(at index: Int)
        -> Observable<Element> {
        ElementAt(source: self.asObservable(), index: index, throwOnEmpty: true)
    }

예시

let test = ["a","a","b","c","c","c"]

let source = Observable.from(test).element(at: 2)

source.subscribe{ print($0) }

// next(b)
// completed

 

4. Filter

• Filter — 테스트 조건을 만족하는 항목들만 배출한다

구현부

public func filter(_ predicate: @escaping (Element) throws -> Bool)
        -> Observable<Element> {
        Filter(source: self.asObservable(), predicate: predicate)
    }

예시

let test = ["a","a","b","c","c","c"]

let source = Observable.from(test).filter { $0 == "a" }

source.subscribe{ print($0) }

// next(a)
// next(a)
// completed

 

5. First

• First — 맨 첫 번째 항목 또는 조건을 만족하는 첫 번째 항목만 배출한다

구현부

public func first() -> Single<Element?> {
        PrimitiveSequence(raw: First(source: self.asObservable()))
    }

 

6. IgnoreElements

• IgnoreElements — 항목들을 배출하지는 않고 종료 알림은 보낸다

구현부

public func ignoreElements()
        -> Observable<Never> {
        self.flatMap { _ in Observable<Never>.empty() }
    }

 

7. Sample

• Sample — 특정 시간 간격으로 최근에 Observable이 배출한 항목들을 배출한다

구현부

public func sample<Source: ObservableType>(_ sampler: Source, defaultValue: Element? = nil)
        -> Observable<Element> {
            return Sample(source: self.asObservable(), sampler: sampler.asObservable(), defaultValue: defaultValue)
    }

예시

let source = Observable<Int>.interval(0.1, scheduler: MainScheduler.instance)

source
	.sample(Observable<Int>.interval(0.5, scheduler: MainScheduler.instance))
	.subscribe{ print($0) }
    
// next(4)
// next(9)
// next(14)
// next(19)
// next(24)

 

8. Skip

• Skip — Observable이 배출한 처음 n개의 항목들을 숨긴다

구현부

public func skip(_ count: Int)
        -> Observable<Element> {
        SkipCount(source: self.asObservable(), count: count)
    }

예시

let test = ["a","a","b","c","c","c"]

let source = Observable.from(test).skip(2)

source.subscribe{ print($0) }

// next(b)
// next(c)
// next(c)
// next(c)
// completed

 

- skipWhile

구현부

public func skip(while predicate: @escaping (Element) throws -> Bool) -> Observable<Element> {
        SkipWhile(source: self.asObservable(), predicate: predicate)
    }

예시

let test = ["a","a","b","c","c","c"]

let source = Observable.from(test).skip { $0 != "c" }

source.subscribe{ print($0) }

// next(c)
// next(c)
// next(c)
// completed

 

- skipUntil

구현부

public func skip<Source: ObservableType>(until other: Source)
        -> Observable<Element> {
        SkipUntil(source: self.asObservable(), other: other.asObservable())
    }

예시

let source = Observable<Int>.interval(0.1, scheduler: MainScheduler.instance)

source
	.skipUntil(Observable<Int>.interval(0.5, scheduler: MainScheduler.instance))
	.subscribe{ print($0) }
    
// next(5)
// next(6)
// next(7)
// next(8)
// ...

 

9. Take

• Take — Observable이 배츨한 처음 n개의 항목들만 배출한다

구현부

public func take(_ count: Int)
        -> Observable<Element> {
        if count == 0 {
            return Observable.empty()
        }
        else {
            return TakeCount(source: self.asObservable(), count: count)
        }
    }

예시

let test = ["a","a","b","c","c","c"]

let source = Observable.from(test).take(2)

source.subscribe{ print($0) }

// next(a)
// next(a)
// completed

 

- take with duration

구현부

public func take(for duration: RxTimeInterval, scheduler: SchedulerType)
        -> Observable<Element> {
        TakeTime(source: self.asObservable(), duration: duration, scheduler: scheduler)
    }

예시

let source = Observable<Int>.interval(0.1, scheduler: MainScheduler.instance)

source
	.take(0.3, scheduler: MainScheduler.instance)
	.subscribe{ print($0) }
    
// next(0)
// next(1)
// completed

 

 

- takeLast

구현부

public func takeLast(_ count: Int)
        -> Observable<Element> {
        TakeLast(source: self.asObservable(), count: count)
    }

예시

let test = ["a","a","b","c","c","c"]

let source = Observable.from(test).takeLast(2)

source.subscribe{ print($0) }

// next(c)
// next(c)
// completed

 

 

출처 : http://reactivex.io/documentation/ko/operators.html

ReactiveX - Operators