RxSwift: Create Operators

Observable를 생성하는 연산자

just

메서드의 리턴형은 Observable<Element>이다.  하나의 element를 갖는 Observable를 생성하는 연산자이다.

public static func just(_ element: Element) -> Observable<Element> {
        Just(element: element)
}

final private class Just<Element>: Producer<Element> {
    private let element: Element

    init(element: Element) {
        self.element = element
    }

    override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        observer.on(.next(self.element))
        observer.on(.completed)
        return Disposables.create()
    }
}

하나의 element를 매개변수로 받아 observer가 subscribe 하면 observer에 element와 completed를 순서대로 방출한다.

Observable.just([1, 2, 3])
    .subscribe { event in print(event) }
    .disposed(by: disposeBag)
/*
결과
next([1, 2, 3])
completed
/*

of

메서드의 리턴형은 Observable <Element>로 하나의 element를 방출하는 연산자.

public static func of(_ elements: Element ..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<Element> {
        ObservableSequence(elements: elements, scheduler: scheduler)
}

just와 차이점은 방출할 element의 개수가 여러 개가 될 수 있다.

Observable.of([1, 2], [3, 4], [5, 6])
    .subscribe { event in print(event) }
    .disposed(by: disposeBag)
/*
결과
next([1, 2])
next([3, 4])
next([5, 6])
completed
*/

from

매개변수로 element 배열을 받아서 순서대로 하나씩 방출하는 연산자.

 

public static func from(_ array: [Element], scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<Element> {
        ObservableSequence(elements: array, scheduler: scheduler)
}

Observable.from([1, 2, 3])
    .subscribe { event in print(event) }
    .disposed(by: disposeBag)
    
/* 
결과
next(1)
next(2)
next(3)
completed
/*

range

정수를 일정한 개수만큼 방출하는 연산자.

start부터 count개를 차례대로 방출한다.

 public static func range(start: Element, count: Element, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<Element> {
        RangeProducer<Element>(start: start, count: count, scheduler: scheduler)
}

generate

initialState: 처음 방출할 element

condition: observable이 completed 될 condition function. 조건을 만족하지 않으면 바로 completed 된다.

iterate: step function.

Observable
    .generate(initialState: 10,
              condition: { $0 >= 0 },
              iterate: { $0 - 2 })
    .subscribe { event in print(event) }
    .disposed(by: disposeBag)
    
/*
결과
next(10)
next(8)
next(6)
next(4)
next(2)
next(0)
completed
*/

Observable
    .generate(initialState: 10,
              condition: { $0 > 10 },
              iterate: { $0 - 2 })
    .subscribe { event in print(event) }
    .disposed(by: disposeBag)
    
/*
 결과
completed
*/

repeatElement

element를 무한 개 방출하는 연산자.

take연산자랑 같이 쓰면 원하는 개수만큼 방출할 수 있다.

Observable.repeatElement("❤️")
    .take(5)
    .subscribe { print($0) }
    .disposed(by: disposeBag)

/*
next(❤️)
next(❤️)
next(❤️)
next(❤️)
next(❤️)
completed
*/

Deferred

특정 조건에 따라 Observable를 생성하는 연산자.

매개변수로 Observable<Element>를 반환하는 클로저를 받는다. 

public static func deferred(_ observableFactory: @escaping () throws -> Observable<Element>)
        -> Observable<Element> {
        Deferred(observableFactory: observableFactory)
}

observer가 factory를 subscribe 하면 deferred 연산자의 매개변수로 보낸 클로저가 실행되어 observer에게 observable이 전달된다.

let disposeBag = DisposeBag()
let animals = ["🐶", "🐱", "🐹", "🐰", "🦊", "🐻", "🐯"]
let fruits = ["🍎", "🍐", "🍋", "🍇", "🍈", "🍓", "🍑"]
var flag = true

let factory: Observable<String> = Observable.deferred {
    flag.toggle()
    if flag {
        return Observable.from(animals)
    } else {
        return Observable.from(fruits)
    }
}

print("--- first subscribe ---")
factory
    .subscribe { print($0) }
    .disposed(by: disposeBag)
    
print("--- second subscribe ---")
factory
    .subscribe { print($0) }
    .disposed(by: disposeBag)
    
/*
--- first subscribe ---
next(🍎)
next(🍐)
next(🍋)
next(🍇)
next(🍈)
next(🍓)
next(🍑)
completed
--- second subscribe ---
next(🐶)
next(🐱)
next(🐹)
next(🐰)
next(🦊)
next(🐻)
next(🐯)
completed
*/

Empty

completed를 방출하는 연산자

observer에 completed만 전달된다.

public static func empty() -> Observable<Element> {
    EmptyProducer<Element>()
}

final private class EmptyProducer<Element>: Producer<Element> {
    override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        observer.on(.completed)
        return Disposables.create()
    }
}