最近开始看RxSwift ,将自己的学习过程记录下来。

在ReactiveCocoa 中，所有的数据都是以signal流的形式传递，其实在Rx中也是如此，本质并没有改变，改变的是形式。ReactiveCocoa 中的signal 对应Rx 的Observable

• 创建信号
• 常见方法的使用

常见方法的使用

RxCocoa 中的UI类

number: UITextField! 无需通过添加任何操作，只要subscribeNext 操作就会执行打印输出

number1.rx_text.subscribeNext{ (text) -> Void in
            print(" --- text \(text)");
            }

combinLatest(...)

将多个信号整合成一个信号，任何一个信号的改变均会触发操作

Observable.combineLatest(number1.rx_text, number2.rx_text, number3.rx_text) { textValue1, textValue2, textValue3 -> Int in
                return (Int(textValue1) ?? 0) + (Int(textValue2) ?? 0) + (Int(textValue3) ?? 0)
            }
            .map {
                print("value = \($0)");
                return $0.description // $0 代表第一个参数
            
            }
            .bindTo(result.rx_text)
            .addDisposableTo(disposeBag)

map

信号映射转换。例如 将一个String 转换为 Int

bindTo

值绑定，将一个信号与另外一个信号绑定

常见方法

create

 func createSequence(){
        
        let myCreate = { (element: Int) -> Observable<Int> in
            return Observable.create { observer in
                observer.on(.Next(element))
                observer.on(.Completed)
                return NopDisposable.instance
            }
        }
        let subscription5 = myCreate(1).subscribe { event in
            print(event)
            /*
            Next(1)
            Completed
            */
        }
    }

of

func ofSequence(){
        let sequenceElements = Observable.of(1, 2, 3, 4)
        let _ = sequenceElements.subscribe { event in
            print(event)
        }
        /*
        Next(1)
        Next(2)
        Next(3)
        Next(4)
        Completed
        */    
    }

deferred

 func deferSquence(){
        let deferredSequence: Observable<Int> = Observable.deferred {
            print("creating")
            return Observable.create { observer in
                print("emmiting")
                observer.on(.Next(0))
                observer.on(.Next(1))
                observer.on(.Next(2))
                
                return NopDisposable.instance
            }
        }
        
        _ = deferredSequence
            .subscribe { event in
                print(event)
        }
        
        _ = deferredSequence
            .subscribe { event in
                print(event)
        }
    }

Subject 既可以作为Observer, 也可以作为Observable，作为observer，可以订阅一个或者多个observables，作为observable，可以传递其观察的item

PublishSubject

只有在subscribe之后才会接收输出结果，如果subscribe之后没有数据的发送，则也不会有输出。这里的on 如同ReactiveCocoa 的Signal.sendNext()方法

func publishSubject(){
        
        //let disposeBag = DisposeBag()
        
        let subject = PublishSubject<String>()
         subject.on(.Next("0"))
        subject.subscribe { event in
            print("1->\(event)")
        }
       
        subject.on(.Next("a"))
        subject.on(.Next("b"))
        subject.subscribe { event in
            print("2->\(event)")
        }
        subject.subscribeNext { (vc) -> Void in
            print("3->\(vc)")
        }
        subject.on(.Next("c"))
        subject.on(.Next("d"))
        
        subject.addDisposableTo(DisposeBag());
        /*
        不会缓存数据
        1->Next(a)
        1->Next(b)
        
        1->Next(c)
        2->Next(c)
        3 c
        
        1->Next(d)
        2->Next(d)
        3 d
        */
}

publishsubject.png

replaySubject

每次subscribe 之后会先输出缓冲的数据，可以先发送数据然后再subscribe。(这与ReactiveCocoa 的replaySubject 原理应该是一样的，都是有数据缓冲池，所有发送过的数据都不会消失)。 可以设置缓冲大小。

  func replaySubject(){
        let disposeBag = DisposeBag()
        // 会缓存数据
        let subject = ReplaySubject<String>.create(bufferSize: 1)// 设置缓冲的大小
        subject.on(.Next("0"))
        subject.subscribeNext { (vc) -> Void in
            print("1->\(vc)")
        }
       
        subject.on(.Next("a"))
        subject.on(.Next("b"))
        subject.subscribeNext { (vc) -> Void in
            print("2->\(vc)")// 当subscribeNext 后，会先输出缓冲的数据
        }
        subject.on(.Next("c"))
        subject.on(.Next("d"))
        subject.addDisposableTo(disposeBag);
        /*
        1->0
        1->a
        1->b
        
        2->b // 缓冲为1 所以输出最新的一个
        
        1->c
        2->c
        
        1->d
        2->d
        */
        
    }

replaysubject.png

BehaviorSubject

When an observer subscribes to a BehaviorSubject, it begins by emitting the item most recently emitted by the source Observable (or a seed/default value if none has yet been emitted) and then continues to emit any other items emitted later by the source Observable(s).

 func behavirSubject(){
        let subject = BehaviorSubject(value: "z")
        subject.on(.Next("0"))
        subject.on(.Next("1"))
        subject.subscribe { event in
            print("1->\(event)")
        }
        subject.on(.Next("a"))
        subject.on(.Next("b"))
        subject.subscribe { event in
            print("2->\(event)")
        }
        subject.on(.Next("c"))
        subject.on(.Completed)
        
        /*
        1->Next(z)// 如果没有默认值 则使用初始化的默认值，如果已经在subscribe 之前设置，则使用最新的
        1->Next(a)
        1->Next(b)
        2->Next(b)
        1->Next(c)
        2->Next(c)
        1->Completed
        2->Completed
        
        */
    }

behaviorsubject.png

Variable

Variable wraps BehaviorSubject. Advantage of using variable over BehaviorSubject is that variable can never explicitly complete or error out, and BehaviorSubject can in case Error or Completed message is send to it. Variable will also automatically complete in case it's being deallocated.

func varibaleSequence(){
        let disposeBag = DisposeBag()
        let variable = Variable("z")
        variable.asObservable().subscribeNext { (vc) -> Void in
            print("1->\(vc) ")
        }
      //  writeSequenceToConsole("1", sequence: variable.asObservable()).addDisposableTo(disposeBag)
        variable.value = "a"
        variable.value = "b"
        variable.asObservable().subscribeNext { (vc) -> Void in
            print("2->\(vc) ")
        }
       // writeSequenceToConsole("2", sequence: variable.asObservable()).addDisposableTo(disposeBag)
        variable.value = "c"
        variable.value = "d"
        
    /*
    Varibale 是BehaviorSubject 的包装器，较于BehaviorSubject 不会显示输出 complete 或 error
        Variable 在释放后会自动 complete
        1->z
        
        1->a
        1->b
        
        2->b
        
        1->c 
        2->c 
        
        1->d 
        2->d
        */
    }