RXswif的使用

Rxswift的个人理解

新项目需要使用到RXswift 所以来整理一下

先来看看基础描述：

RxSwift的核心思想是 Observable
sequence，Observable表示可监听或者可观察，也就是说RxSwift的核心思想是可监听的序列。
并且，Observable sequence可以接受异步信号，也就是说，信号是可以异步给监听者的
Observable(ObservableType) 和 SequenceType类似
ObservableType.subscribe 和 SequenceType.generate类似
由于RxSwift支持异步获得信号，所以用ObservableType.subscribe，这和indexGenerator.next()类似
其中SequenceType是Swift(2.3以前版本,之后的版本没有该协议)中的一个协议，比如Swift中的Array就遵循这个协议，通过这个协议，你可以这样的去操作一个Array

来简单操作体验一下 UIbutton

创建一个新工程然后把下面方法拷贝进去

    fileprivate lazy var Dbag = DisposeBag()
    func setupConstraints() {
        let button1 = UIButton(frame: CGRect(x: 50, y: 100, width: 300, height: 40))
        button1.setTitle("button1", for: .normal)
        button1.backgroundColor = .yellow
        button1.addTarget(self, action: #selector(button1Method), for: .touchUpInside)
        
        /** Rxswift init button*/
        let button2 = UIButton(frame: CGRect(x: 50, y: 150, width: 300, height: 40))
        button2.JSSetTileAndBColor(title: "button2", state: .normal, backgroundColor: .purple)
        button2.rx.tap.subscribe{(event) in
            print("999")
        }.disposed(by: Dbag)
        
        self.view.addSubview(button1)
        self.view.addSubview(button2)
    }
    @objc func button1Method(){
        print("888");
    }

 extension UIButton{
        func JSSetTileAndBColor(title:String,
                                state:UIControl.State,
                                backgroundColor:UIColor) -> UIButton {
          self.setTitle(title, for: state)
          self.backgroundColor = backgroundColor
          return self
     }

UITextfile

接下来新建两个textfile通过rxswift 分别用on和onNext去做观察，同时更新label的text属性：

 let textfile1 = UITextField(frame: CGRect(x: 50, y: 200, width: 150, height: 40))
        textfile1.backgroundColor = .white
        let textfile2 = UITextField(frame: CGRect(x: 210, y: 200, width: 150, height: 40))
            textfile2.backgroundColor = .white
        let label1 = UILabel(frame: CGRect(x: 50, y: 240, width: 500, height: 40))
        
        textfile1.rx.text.subscribe { (event:Event<String?>) in
            label1.text = event.element!
        }.disposed(by: Dbag)
        
        textfile2.rx.text.subscribe { (text:String!) in
            label1.text = text!
        }.disposed(by: Dbag)
        self.view.addSubview(textfile1)
        self.view.addSubview(label1)
        self.view.addSubview(textfile2)

效果图
因为添加了观察所以每当我updatetextfile都能直接作用到label上。

UIScrollerView

import Foundation
import UIKit
import RxSwift
class JScrollerViewController: UIViewController{
    fileprivate let bag = DisposeBag()
    fileprivate let _scrollerview = UIScrollView()
    override func viewDidLoad() {
        super.viewDidLoad()
        self.view.addSubview(_scrollerview)
        _scrollerview.frame = self.view.frame;
        _scrollerview.contentSize = CGSize(width: self.view.width, height: self.view.height*2);
        _scrollerview.rx.contentOffset.subscribe{(_point:CGPoint? )in
            print("contentoff.y:\(_point!.y)")
        }.disposed(by: bag)
    }
    
    
}

这里可以说一下如果subscribe的disposed 不传disposeBag则只会调用一次回调，在拷贝的时候可以试下

然后再试下给struct添加观察

    func testRxswiftNever(){
       Observable<String>.never().subscribe { (_) in
            print("never show")
        }.disposed(by: Dbag)  //该语句不会执行
    }

never就是创建一个sequence,不发出任何事件信号

    func testRxswiftEmpty(){
        Observable<Int>.empty().subscribe{(event)in
            print(event)
        }.disposed(by: Dbag)
    }

empty就是创建一个空的sequence,只能发出一个complected事件
event 的类型就是Competed

    func testRxswiftJust(){
        Observable<Int>.just(3).subscribe{(event)in
            print("just:\(event)")
        }.disposed(by: Dbag)
    }

just是创建一个sequence只能发出一种特定的事件，能正常结束
这里会输出2次 ： just:next(3) / just:compete

    func testRxswiftOf(){
        Observable.of("1","3","5","7").subscribe(onNext: {
            print("of\($0)")
        }).disposed(by: Dbag)
    }

of是创建一个sequence能发出很多种事件信号,分别输出of:1，of:3，of:5，of:7

我们也可以自定义可观察的sequence，那就是使用create

create操作符传入一个观察者observer，然后调用observer的onNext，onCompleted和onError方法。返回一个可观察的obserable序列

    fileprivate func myobserable() -> Observable<Any> {
        return Observable.create({ (observal: AnyObserver<Any>) -> Disposable in        
        	observal.onNext("1")
         	observal.onNext("2")
            observal.onCompleted()
            return Disposables.create()
        })
    }

range(给定范围, 依次显示)

        Observable<Int>.range(start: 1, count: 4).subscribe {
        (event: Event<Int>) in
            print(event)
            
        }.disposed(by:Dbag)

range就是创建一个sequence，他会发出这个范围中的从开始到结束的所有事件Observable,必须指定数据类型: 输出next（0）～next（3）还有compete

repeatElement(重复执行)

创建一个sequence，发出特定的事件n次

    func Rxswift(){
        Observable.repeatElement("1").take(3).subscribe(onNext: {
            print($0)
        }).disposed(by: Dbag)
    }

这样就会输出三次1，并且没有compete

generate(类似于for循环)

generate是创建一个可观察sequence，当初始化的条件为true的时候，他就会发出所对应的事件

    func RxswiftGenerate(){
        _=Observable.generate(initialState: 1, condition: {$0<5}, iterate: {$0+1}).subscribe({
            print("generate\($0)")
        }).disposed(by: Dbag)
    }

打印输出：
generatenext(1)
generatenext(2)
generatenext(3)
generatenext(4)
generatecompleted

未完待续