Rxswift Basic Use (i)

Note: This article refers to the blog post [RxSwift into the pit interpretation-you need to know the various concepts] (http://www.codertian.com/2016/11/27/RxSwift-ru-keng-ji-read-document/), Rxswift Basic use for personal study and notes required for special records

Concept

Observable: observable, event source

Observer: observers, observers need to subscribe to observable in order to receive the events they emit

disposebag: equivalent to the arc in iOS, will destroy the observer at the appropriate time, automatically to release resources

If you need to manually destroy the observer directly call the Dispose () method, for example:
Observable.empty (). Subscribe {(str:event) in
Print ("Empty:", str)
}.dispose ()

Subscribe: subscriber for subscribing to events emitted by sequence

Basic use Never

Never is to create a sequence, but does not emit any event signals

let bag = DisposeBag()Observable.never().subscribe { (str :Event<String>) in    print("never:",str) //无}.addDisposableTo(bag)

Note: For convenience, the code for creating the bag variable in the following example will be omitted

Empty

Empty creates a null sequence, but only one completed event is emitted

Observable.empty().subscribe { (str :Event<String>) in    print("empty:",str)}.addDisposableTo(bag)//empty: completed

Just

Just creates a sequence, but can only emit a specific event that ends normally

Observable.just("just").subscribe { (str :Event<String>) in    print("just:",str)}.addDisposableTo(bag)//just:next(just) //just:completed

Of

Creating a sequence can emit many kinds of event signals.

Observable.of("1","2","3").subscribe { (str) in    print("of:",str)}.addDisposableTo(bag)    /** of: next(1) of: next(2) of: next(3) of: completed */ //subscribe onNext 直接取值 Observable.of("1","2","3").subscribe(onNext: { (str) in print("of2:",str) }).addDisposableTo(bag) /** of2: 1 of2: 2 of2: 3 */

From

From creates a sequence, such as an array, dictionary, or set, from a collection.

    Observable.from([10,100,1000]).subscribe(onNext: { (num) in        print("from:",num)    }).addDisposableTo(bag)    /** from: 10 from: 100 from: 1000 **/

Create

Create custom observable sequence

    //create 自定义可观察的sequence    let myObservable = Observable.create { (observer:AnyObserver<Any>) -> Disposable in        observer.onNext("12")        observer.onNext("21")        observer.onNext("123")        observer.onCompleted()        return Disposables.create() } myObservable.subscribe { (e:Event<Any>) in print("myObservable:",e) }.addDisposableTo(bag) /** myObservable: next(12) myObservable: next(21) myObservable: next(123) myObservable: completed **/

Range

Range creates a sequence that emits all events in this range

    1, count: 5).subscribe(onNext: { (num) in        print("range:",num)    }).addDisposableTo(bag)    /**     range: 1     range: 2     range: 3     range: 4     range: 5     **/

Repeatelement

Create a sequence, emit a specific event n times

Observable.repeatElement("LouKit").take(3).subscribe { print($0)}.addDisposableTo(bag)    //重复发出3次，如果没有take 就无限次    /** next(LouKit) next(LouKit) next(LouKit) completed **/

Generate

Generate is to create an observable sequence, and when the condition of initialization is true, he will emit the corresponding event

    10, condition: {$0 < 15}, iterate: {$0 + 1}).subscribe(onNext: {print("generate",$0)}).addDisposableTo(bag) /** generate 10 generate 11 generate 12 generate 13 generate 14 **/

Deferred

Deferred will create a new observable sequence for each Subscriber observer

Varindex =1 Let deferred = observable<string>.deferred{Print"Index:",IndexIndex + =1Return observable.create{Observer in Observer.onnext ("1") Observer.onnext ("2") observer.oncompleted ()Return Disposables.create ()}} deferred.subscribe {Print"Call 1:",$0)}. Adddisposableto (bag) deferred.subscribe {print ( "Call 2:", $0)}.adddisposableto (bag)/** index : 1 call  1: next ( 1) call  1: next ( 2) call 1:completed index: 2 call  2: next (1) call Span class= "Hljs-number" > 2: next (2) call 2:completed **/         

Do

Primarily used to call before onnext,onerror,oncompleted in subscribe

Observable.just ("00").Do (onNext: {print ("doonnext:")},onerror: {print ("Doonerror:", $)},oncompleted: {  Print ("dooncompleted:")}). Subscribe (onNext: {(str) in print ("OnNext:", str)}, OnError: {(  Error)  in print ("OnError")}, oncompleted: { print ("oncompleted")}). Adddisposableto (Bag) /** doonnext:00 onnext:00 dooncompleted:oncompleted **/         

Subjects

Subjet is a bridge between observable and observer, a subject can either act as a obserable or act as a observer, that is, it can emit events or listen to events

Publishsubject

When you subscribe to an event with Publishsubject, you can only receive 订阅他之后 events that occur

    let publicSubject = PublishSubject<String>()    publicSubject.onNext("A")    publicSubject.onNext("B")    publicSubject.subscribe(onNext: {print("publicSubject:",$0)}) .addDisposableTo(bag)    publicSubject.onNext("C") publicSubject.onNext("D") /** publicSubject: C publicSubject: D **/

Replaysubject

Can receive a subscription to 之后以及之前 the event that he has occurred, for a few previous events depending on the size of the buffersize setting

Let Replaysubject = Replaysubject<string>.create (buffersize:2) Replaysubject.onnext ("A") Replaysubject.onnext ("B") Replaysubject.onnext ("C") Replaysubject.onnext ("D") Replaysubject.subscribe (onNext: {print ("Replaysubject:", $0)}). Adddisposableto (bag) replaysubject.onnext ( "E") Replaysubject.onnext ( "F") Replaysubject.onnext ( "G") /** replaysubject:c replaysubject:d replaysubject:e replaysubject:f replaysubject:g **///Accept all events Let ReplaySubject2 = replaysubject<string>.createunbounded () Replaysubject2.onnext ( "A") Replaysubject2.onnext ( "B") Replaysubject2.subscribe (onNext: {print ( "E") Replaysubject2.onnext ( "F") /** replaysubject2:a replaysubject2:b replaysubject2:e replaySubject2 : F **/            

Behaviorsubject

With Behaviorsubject subscription events, you receive the 订阅之前的最后一个事件 as well 订阅之后所有事件 .

    "behavior")    behavior.onNext("A")    behavior.onNext("B")    behavior.subscribe(onNext: {print("behavior:",$0)}).addDisposableTo(bag) behavior.onNext("C") behavior.onNext("D") /** behavior: B behavior: C behavior: D **/

Variable

Variable is a packing for Behaviorsubject;

Variable as obserable, let subscribers subscribe, need asobserable turn into obserable;

Variable issue events, directly modify the object's value can be;

When the event ends, variable automatically issues the completed event

 let variable = variable (" variable ") variable. Value =  "A" variable. Value =  "B" variable.asobservable (). Subscribe {(event:event <String>) in print ( "variable:", Event)}. Adddisposableto (bag) variable. Value =  "C" variable. Value =  "D" /** variable:next (B) variable:next (C) variable:next (D) variable:completed **/            

Federated operations

Joint operation is to synthesize multiple observable streams into a single observable stream

Startwith

A specific event message is emitted before the event message is emitted.

    Observable.of(1,2).startWith(3).subscribe(onNext: {print($0)}).addDisposableTo(bag)    /**     3     1     2     **/

Merge

Synthesize multiple observable streams into a single observable stream, and then 任何一个Observable emit events that can be received

    let sub1 = PublishSubject<String>()    let sub2 = PublishSubject<String>()    Observable.of(sub1,sub2).merge().subscribe(onNext: { print($0) }).addDisposableTo(bag)    sub1.onNext("sub1-1")    sub1.onNext("sub1-2")    sub2.onNext("sub2-1")    sub1.onNext("sub1-2") sub2.onNext("sub2-2") /** sub1-1 sub1-2 sub2-1 sub1-2 sub2-2 **/

Zip

Multiple observable streams are synthesized into a single observable stream, and the 多个Observable流同时 compressed stream event is triggered only when an event is emitted and multiple observable streams are 内容 merged into one 元组 .

    let zip1 = PublishSubject<String>()    let zip2 = PublishSubject<String>()    Observable.zip(zip1,zip2){ zip1,zip2 in        "\(zip1) \(zip2)"        }.subscribe(onNext: { print($0) })        .addDisposableTo(bag)    zip1.onNext("zip1-1")    zip1.onNext("zip1-2")    zip2.onNext("zip2-1") zip2.onNext("zip2-2") /** zip1-1 zip2-1 zip1-2 zip2-2 **/

Note: Merge and zip can synthesize multiple observable streams into a single observable stream, but any one of the observable emitted events can be received after merging, which must be received when multiple streams emit events simultaneously

Combinelatest

Merge multiple observable streams and get the latest values for each of the streams, that is, each merged signal 至少 一次onNext will trigger the merged stream

    let ps1 = PublishSubject<String>()    let ps2 = PublishSubject<String>()    Observable.combineLatest(ps1, ps2) { element1, element2 in        "\(element1) \(element2)"        }        .subscribe(onNext: { print($0) })        .addDisposableTo(bag)    ps1.onNext("ps1-01")    ps1.onNext("ps1-02")    ps2.onNext("ps2-01") /** ps1-02 ps2-01 **/

Switchlatest

Used to convert the event stream, that is, the content in a observable or observable. (Personal understanding)

    "1")    let bs2 = BehaviorSubject(value: "A")    let variable = Variable(bs1)    variable.asObservable().switchLatest().subscribe(onNext: {print($0)}).addDisposableTo(bag)    bs1.onNext("2")    variable.value = bs2    bs1.onNext("3") bs2.onNext("B") /** 1 2 A B **/

Rxswift Basic Use (i)