RxSwift 정리 1 - Observable 생성

RxSwift 메모 용도 정리입니다.

 

 

RxSwift Reactive Progreamming with Swift 

책을 기준으로 작성되었습니다.

 

Observable(sequence) 생성

        let one = 1,two = 2,three = 3

 

1개요소만 생성 : .just()

let observable1 = Observable.just(one,scheduler: MainScheduler.instance)

scheduler: MainScheduler.instance

요소 생성시에도 스레드를 선택해줄수 있습니다. 종류는 다음에 설명,

 

여러 요소 생성 : .of()       

let observable2 = Observable.of(one,two,three) //Observable<Int>
let observable3 = Observable.of([one,two,three]) //Observable<[Int]>

 

배열 형태만 사용하여 요소 생성 : .from()     

let observable4 = Observable.from([one,two,three]) //Observable<Int>
let observable5 = Observable.from(one,two,three) //error

         [one,two,three] 를 .of와 .from 각각생성해보면 타입이 다르게 생성된다.

 

다양한 요소 생성 : .create()

let observable6 = Observable<String>.create({ (observer) -> Disposable in
    observer.onNext("test")
    observer.onCompleted()
    observer.onNext("do this?")
    return Disposables.create()
})
observable6.subscribe{(event) in
    print(event)
    // next(1)
    // completed
}

 

텅빈 요소 생성 : .empty()

let observable = Observable<Void>.empty()     
     observable.subscribe(         
         onNext: { (element) in
             print(element)
	     },onCompleted: {
             print("Completed")
     	 })
// Completed

아무것도 없으니 Completed 만 출력.

 

아무것도 하지 않는 요소 생성 : .never()

let observable = Observable<Any>.never()
     observable.subscribe(
             onNext: { (element) in
                 print(element)
         }, onCompleted: {
                 print("Completed")
         })

Completed 도 하지 않는다.

 

범위값으로 생성 : .range()

let observable = Observable<Int>.range(start: 1, count: 3)
    observable.subscribe(onNext: { (i) in
        print(i)
    }) // 1, 2, 3

Int만 됩니다.

 

 

요소 중단 : .dispose()

let observable = Observable.of("A", "B", "C")
let subscription = observable.subscribe({ (event) in
   print(event)
}) // A, B, C
subscription.dispose()

구독을 중단시킬때

 

 

subscribe의 리턴값을 담는 객체 : .disposed(by:)

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

메모리 관리를 해줍니다.

 

error 발생시

enum MyError: Error {
     case anError
}
let disposeBag = DisposeBag()
Observable<String>.create({ (observer) -> Disposable in
   observer.onNext("1")
   observer.onError(MyError.anError)
   observer.onCompleted()
   observer.onNext("2")
   return Disposables.create()
})
   .subscribe(
       onNext: { print($0) },
       onError: { print($0) },
       onCompleted: { print("Completed") },
       onDisposed: { print("Disposed") }
    ).disposed(by: disposeBag) // 1, anError, Disposed

Complete는 발생하지 않고, Disposed 발생

 

 

늦게 생성되는 요소 : .deferred()

var flag = false
let observable: Observable<Int> = Observable.deferred(){
    if flag {
        return Observable.of(1,2,3)
    } else {
        return Observable.of(4,5,6)
    }}
flag = true
observable.subscribe(onNext: {
    print($0, terminator: "")
})
.disposed(by: disposeBag)

flag 를 처음 false 고 observable를 .deferred() 로 생성(예약?)

flag 를 바꾸고 subscribe를 하면 이때서야 생성됩니다.

 

요소 참조가 필요 없고 성공 실패/결과만 필요할때

Traits - Single, Completable, Maybe

let single = Single<Any>.create { single in
    let disposable = Disposables.create()
    //single(.success("done"))
    single(.failure(MyError.error1))
    return disposable
}
single.subscribe{
    switch $0 {
    case .success(let string):
      print(string)
    case .failure(let error):
      print(error)
    }}.disposed(by: disposeBag)

1회성 작업에 유용하다.

Single : 성공 실패 + 결과

Completable : 성공 실패만 있습니다.

Maybe : 성공 실패 + 결과 (Single보다 기능이 더 간략합니다)

 

 

 

 

 

내용이 변경