RxSwift 深入浅出(一)RxSwift初探

前段时间一直在玩RxSwift ,现在记录一下这个牛逼,让人欲罢不能的框架.RxSwift看我就够了

RxSwift 宝图镇博,咔咔点赞~~~~

RxSwift 深入浅出(一)RxSwift初探_第1张图片
Rxswift
  • RxSwift 深入浅出(一)RxSwift初探

  • RxSwift 深入浅出(二)高阶函数

  • RxSwift 深入浅出(三)Subject

  • RxSwift 深入浅出(四)控件应用

  • RxSwift 深入浅出(五)tableView应用

  • RxSwift 深入浅出(六)RxDataSources

  • RxSwift 深入浅出(七)网络封装

  • RxSwift 深入浅出(八)开发总结

RxSwift 深入浅出(一)RxSwift初探_第2张图片
RxSwift

现在RxSwift的的成绩非常不错,一看就知道是大牛框架

start

ReactiveX这个家族非常牛逼,写了很多框架:

  • RxJava

  • IxJS

  • rxdart

  • RxSwift

  • RxJava

  • rxjs

.....

今天我们就来看看RxSwift
RxSwift的导入和编译自行百度,

import RxSwift
import RxCocoa

class ViewController: UIViewController{

    lazy var tableView: UITableView = UITableView()
    let reuserId:String = "cell"//重用标识
    let infoViewModel: InfoViewModel = InfoViewModel()//数据viewmodel
    //DisposeBag:作用是 Rx 在视图控制器或者其持有者将要销毁的时候,自动释法掉绑定在它上面的资源。它是通过类似“订阅处置机制”方式实现(类似于 NotificationCenter 的 removeObserver)。
    let disposeBag = DisposeBag()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        
        //rx.items(cellIdentifier:):这是 Rx 基于 cellForRowAt 数据源方法的一个封装。传统方式中我们还要有个 numberOfRowsInSection 方法,使用 Rx 后就不再需要了(Rx 已经帮我们完成了相关工作)。
        
        infoViewModel.infoArray.bind(to: tableView.rx.items(cellIdentifier: reuserId)){
            row,model,cell in
            cell.textLabel?.text = "\(model.name) age == \(model.age) row = \(row)"
        }.disposed(by: disposeBag)
        
        
        //rx.modelSelected: 这是 Rx 基于 UITableView委托回调方法 didSelectRowAt 的一个封装。
        tableView.rx.modelSelected(InfoModel.self).subscribe(onNext: { (model) in
            print("点击了 \(model.name) age==\(model.age)")
        }).disposed(by: disposeBag)
        
    }
}

//MARK: 设置UI相关
extension ViewController{
  
    func setupUI(){
        view.addSubview(tableView)
        tableView.frame = view.bounds
        tableView.backgroundColor = UIColor.white
        tableView .register(UITableViewCell.self, forCellReuseIdentifier: reuserId)
    }
}


//MARK: model
struct InfoModel {
    let name:String //名字
    let age:Int //年纪
    init(name:String,age:Int) {
        self.name = name
        self.age = age
    }
 }
//MARK: 方便输出打印
extension InfoModel:CustomStringConvertible{
    var description:String{
        return "name==\(name),age==\(age)"
    }
}

struct InfoViewModel {
    //MARK: 模拟假数据
    let infoArray = Observable.just([
        InfoModel(name: "Cooci", age: 19),
        InfoModel(name: "CC", age: 18),
        InfoModel(name: "James", age: 17),
        InfoModel(name: "Gavin", age: 16),
        InfoModel(name: "Dean", age: 15),
        ])
}

看了上面的代码是不是感觉贼爽,代码量大大精简,思路更加清晰,简直完美,优秀,还有~谁

import UIKit
import RxSwift
import RxCocoa

class ViewController: UIViewController {

    let disposeB = DisposeBag()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        //通过指定的方法实现来自定义一个被观察的序列。
        //订阅创建
        let myOb = Observable.create { (observ) -> Disposable in
            observ.onNext("cooci")
            observ.onCompleted()
            return Disposables.create()
        }
        //订阅事件
        myOb.subscribe { (even) in
            print(even)
        }.disposed(by: disposeB)//销毁

        //各种观察者序列产生方式
        
        //该方法通过传入一个默认值来初始化。
        Observable.just("just")
            .subscribe { (event) in
            print(event)
        }
            .disposed(by: disposeB)
        
        //该方法可以接受可变数量的参数(必需要是同类型的)
        Observable.of("o","f","of").subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
        //该方法需要一个数组参数。
        Observable.from(["f","r","o","m"]).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
        //该方法创建一个永远不会发出 Event(也不会终止)的 Observable 序列。
        Observable.never().subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
        //该方法创建一个空内容的 Observable 序列。 //会打印complete
        Observable.empty().subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
        //该方法创建一个不做任何操作,而是直接发送一个错误的 Observable 序列。
        let myError = MyError.A
//        print(myError.errorType)
        Observable.error(myError).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
        //该方法通过指定起始和结束数值,创建一个以这个范围内所有值作为初始值的Observable序列。
        Observable.range(start: 1, count: 6).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
        //该方法创建一个可以无限发出给定元素的 Event的 Observable 序列(永不终止)。
//        Observable.repeatElement("Cooci").subscribe { (event) in
//            print(event)
//        }.disposed(by: disposeB)
        
        //该方法创建一个只有当提供的所有的判断条件都为 true 的时候,才会给出动作的 Observable 序列。
        //第一个参数:初始化的数值  第二个 条件  第三也是一个条件 0 + 2 <= 10 依次循环下去,iterate:重复执行
        Observable.generate(initialState: 0, condition: {$0<=10}, iterate: {$0+2}).subscribe { (event) in
            print(event)
            }.disposed(by: disposeB)
        
        //上面和下面的效果一样
        Observable.of(0,2,4,6,8,10).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
        //该个方法相当于是创建一个 Observable 工厂,通过传入一个 block 来执行延迟 Observable序列创建的行为,而这个 block 里就是真正的实例化序列对象的地方。
        var isOdd = true
        let factory: Observable = Observable.deferred { () -> Observable in
            
            isOdd = !isOdd
            if isOdd{
                return Observable.of(0,2,4,6,8)
            }else{
                return Observable.of(1,3,5,7,9)
            }
        }
        
        factory.subscribe { (event) in
            print("\(isOdd)",event)
        }.disposed(by: disposeB)
        
        factory.subscribe { (event) in
            print("\(isOdd)",event)
        }.disposed(by: disposeB)
        
        
        //这个方法创建的 Observable 序列每隔一段设定的时间,会发出一个索引数的元素。而且它会一直发送下去。
        
//        Observable.interval(1, scheduler: MainScheduler.instance).subscribe { (event) in
//            print(event)
//        }.disposed(by: disposeB)
        
        //这个方法有两种用法,一种是创建的 Observable序列在经过设定的一段时间后,产生唯一的一个元素。
//        Observable.timer(1, scheduler: MainScheduler.instance).subscribe{(event) in
//            print("123",event)
//        }.disposed(by: disposeB)
//
//
        //另一种是创建的 Observable 序列在经过设定的一段时间后,每隔一段时间产生一个元素。
        Observable.timer(5, period: 1, scheduler: MainScheduler.instance).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)
        
    }
    
    enum MyError:Error {
        case A
        case B
        var errorType:String {
            switch self {
            case .A:
                return "i am error A"
            case .B:
                return "BBBB"
            }
        }
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

}

上面这段代码是介绍的 Observable的序列产生,也是非常简单,轻量化

你可能感兴趣的:(RxSwift 深入浅出(一)RxSwift初探)