SwiftiOS猛码计划Ios开发

RxSwift 个人学习笔记记录

2017-05-25  本文已影响2320人  奥卡姆剃须刀

文章目录

一 什么是RxSwift

二 RxSwift做了什么?

2-1 简单介绍观察者设计模式
2-2 RxSwift做了什么?
image.png
2-3 简单理解Observable&Observer
image.png

三RxSwift初级操作

3-1 监听事件

        // 1 监听按钮点击
        // 要用局部的按钮 方便提示  之所以在这里备用一个局部按钮 是因为RxSwift 有什么提示很不好 局部变量就可以解决这个问题
        // let button = UIButton();
        btn1.rx.tap.subscribe { (event : Event<()>) in
            print("我是按钮我被点击了")
        }.addDisposableTo(bag)

3-2 监听文本输入框的文字改变
  // 2.1 第一种方式
        
        textFlied.rx.text.subscribe { (event : Event<String?>) in
            // element 取出这个元素  取出来的是可选类型中的可选类型 可以解包两次
            print(event.element!!)
        }.addDisposableTo(bag)
        
        // 2.1 第二种方式 onNext
        textFlied.rx.text.subscribe(onNext: { (str : String?) in
            print(str!)
        }).addDisposableTo(bag)

3-3 绑定数据赋值操作
// 老套的做法
        textFlied.rx.text.subscribe(onNext: { (str : String?) in
            self.label.text = str!            
        }).addDisposableTo(bag)

//  RxSwift推荐的做法 .bind(to: <#T##ObserverType#>) observerType 是一个协议  而UIbindObser遵守了这个协议
    textFlied.rx.text.bind(to: label.rx.text).addDisposableTo(bag)

3-4 KVO
// KVO 传统的做法
  // 1 监听属性
  lbl.addObserver(self, forKeyPath: "text", options: .new, context: nil)
// 2 代理方法
    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        print((change?[NSKeyValueChangeKey.newKey])!)
    }


// RxSwift 的做法

        label.rx.observe(String.self, "text").subscribe(onNext: { (str : String?) in            
            print(str!)            
        }).addDisposableTo(bag)        
        label.rx.observe(CGRect.self, "frame").subscribe(onNext: { (frame : CGRect?) in            
            print(frame!)            
        }).addDisposableTo(bag)

四 RxSwift常见操作

4-1 never的obserable
// 创建一个naver的obserable 从来不执行
        let neverO = Observable<String>.never()
        neverO.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)
        
4-2 empty的Obserable 只发出complete事件
        // 创建一个empty的Obserable 只能发出一个complete事件
        let empty = Observable<String>.empty()
        empty.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)

4-3 just

// just是创建一个sequence只能发出一种特定的事件 能正常结束
        let just = Observable.just("10")
        just.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)

4-4 of
//创建一个sequence 能发出很多事件信号
        let of = Observable.of("a","b","c")
        of.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)
4-5 from
 // from就是从数组中创建sequence
        let from = Observable.from(["1","2","3"])
        from.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)

4-6 create 自定义事件 开发中常用
//  create 创建一个自定义的disposable  实际开发中常用的  会在自定义很多事件来监听的

        let create = createObserable()
        create.subscribe { (event : Event<Any>) in
            print(event)
        }.addDisposableTo(bag)

// 方法
    func createObserable() -> Observable<Any> {        
        return Observable.create({ (observer : AnyObserver<Any>) -> Disposable in            
            observer.onNext("奥卡姆剃须刀")
            observer.onNext("18")
            observer.onNext("65")
            observer.onCompleted()
            
            return Disposables.create()
        })
    }


// 自定义just
let myJust = myJustObservable(element: "奥卡姆剃须刀")        
        myJust.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)


// 方法
    func myJustObservable(element:String) -> Observable<String> {        
        return Observable.create({ (observer : AnyObserver<String>) -> Disposable in            
            observer.onNext(element)            
            observer.onCompleted()            
            return Disposables.create()            
        })
    }


4-7 range 这个作用不是很大

        let range = Observable.range(start: 1, count: 10)
        range.subscribe { (event : Event<Int>) in
            print(event)
        }.addDisposableTo(bag)

4-8 repeat

        let repeatLL = Observable.repeatElement("奥卡姆剃须刀")
        // 重复次数
        repeatLL.take(5).subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)

五 RxSwift中的Subjects

5-1 Subjects 是什么?

Subjects 是Observable 和 Observer 之间的桥梁, 一个subject 既是一个Obserable 也是一个 Observer 他既可以发出事件,也可以监听事件

5-2 PublishSubject

当你订阅PublishSubject的时候,你只能接受订阅他之后发生的事件,subject.onNext() 发出onNext事件,对应的还有onError() 和onCompleted() 事件

        // 1 publishSubject 订阅者只能接受,订阅之后的事件 也就是必须先订阅 再发送事件
        let publishSub = PublishSubject<String>()        
        publishSub.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)        
        publishSub.onNext("奥卡姆剃须刀")
5-3 ReplySubject

ReplySubject 当你订阅ReplySubject 的时候,你可以接收到订阅他之后的事件,但也可以接收订阅他之前发出的事件 ,接收几个事件取决于bufferSize的大小 会接收最后发送的信号

     
// 限制两个信号         
//      let replySub  = ReplaySubject<String>.create(bufferSize: 2)
        // 没有限制的replySubject
        let replySub = ReplaySubject<String>.createUnbounded()
        
        replySub.onNext("1")
        replySub.onNext("2")
        replySub.onNext("3")
        replySub.onNext("4")
        
        replySub.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)
        
        replySub.onNext("5")

5-4 BehaviorSubject

当你订阅了BehaviorSubject 你就会接收到订阅之前的最后一个事件 可以初始化的时候就给一个订阅值
这个用的是最多的 一般用法是初始的时候给一个默认数据 然后进行刷新加载更多数据

        let behaviorSub = BehaviorSubject(value: "10")        
        behaviorSub.onNext("a")
        // 只能订阅到 b
        behaviorSub.onNext("b")        
        behaviorSub.subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)        
        behaviorSub.onNext("11")
        behaviorSub.onNext("12")
        behaviorSub.onNext("13")

5-5 Variable

1 Variable 是BehaviorSubject 一个包装箱 就像是一个箱子一样 使用的时候需要调用asObservable() 拆箱,里面的Value 是一个BehaviorSubject
2 如果 Variable 打算发出事件 直接修改对象的Value即可
3 当事件结束的时候 Variable 会自动发出complete事件

        let variable = Variable("a")        
        // 要是想修改值 直接修改value就好
        variable.value = "b"        
        variable.asObservable().subscribe { (event : Event<String>) in
            print(event)
        }.addDisposableTo(bag)        
        // 也能发出事件
        variable.value = "c"
        variable.value = "d"

六 RxSwift中的变换操作

6-1 map

通过传入一个函数闭包把原来的sequence转变为一个新的sequence的操作


    //  1 swift中map的使用
        let array = [1,2,3,4]
        
        let arr2 = array.map { (num : Int) -> Int in
            return num * num
        }
        
        print(arr2)
  //    2  swift的函数式编程  用的还是比较少的 还是习惯于面向对象的方式
        let arr3 = array.map({ $0 * $0 })
        
        print(arr3)
        
 //    3 rxswift 中map函数的使用
        Observable.of(10,11,12,13)
            .map { (num : Int) -> Int in
                return num * num
            }.subscribe { (event : Event<Int>) in
                print(event)
            }.addDisposableTo(bag)

6-2 flatmap

将一个sequence转换成sequences。 当你接受一个sequence事件,你还想接受其他sequence发出的事件的话 可以使用flatmap,他会将每一个sequence事件进行处理后 然后再以一个sequence形式发出事件

// 1  先定义一个结构体

// RxSwift的思想  让任何一个变量都是可以监听的
struct Student {
    var score : Variable<Double>    
}


        // 3 flatmap 的使用  映射 Observable的
        let stu1 = Student(score: Variable(100))
        let stu2 = Student(score: Variable(99))
        let stu3 = Student(score: Variable(98))
        
        
        //   链式编程思维
        let studentVariable = Variable(stu1)
        //  这个方法会把所有的是都监听到 都打印 但常常我们只关心最新的一个订阅
//        studentVariable.asObservable().flatMap { (stu : Student) -> Observable<Double> in
//            return stu.score.asObservable()
//            }.subscribe { (event : Event<Double>) in
//            print(event)
//        }.addDisposableTo(bag)
        
        // 常用的是这一个方法  会先打印一下初始化的数据  只会关心最新订阅值的改变
        studentVariable.asObservable().flatMapLatest { (stu : Student) -> Observable<Double> in
            return stu.score.asObservable()
            }.subscribe { (event : Event<Double>) in
                print(event)
            }.addDisposableTo(bag)
        
        studentVariable.value = stu2
        stu2.score.value = 0
        // 这样的话每一个值的改变都会发送信号
        
        //  我已经不关心你的值的改变 我只关心最新的订阅的值的变化
        stu1.score.value = 1000;

七 资源的释放

7-1 dispose
7-2 Dispose Bags
    // 2 DisposeBag
    fileprivate lazy var bag : DisposeBag = DisposeBag()

    let subject = BehaviorSubject(value: "a")
    subject.subscribe { (event : Event<String>) in
        print(event)
    }.addDisposableTo(bag)

八 RxSwift下的UITableView的使用


// VC 中的代码

        //1.创建UITableView(跟OC几乎一样)
        let tabV = UITableView(frame: view.bounds, style: UITableViewStyle.plain)
        tableView = tabV
        
        
        //2.注册Cell
        tableView.register(UITableViewCell.self, forCellReuseIdentifier: cellID)
        
        self.view.addSubview(tableView)
        
        //  负责数据绑定  传回来row  model  和 cell  自行复制
        viewModel.modelObserable.asObservable()
            .bind(to: tableView.rx.items(cellIdentifier: cellID,
                 cellType: UITableViewCell.self)){ row, model, cell in
                 cell.textLabel?.text = model.name
        }.addDisposableTo(bag)                

        // 监听点击cell 获取index
        tabV.rx.itemSelected.subscribe(onNext: { (index : IndexPath) in            
//            点击cell就刷新数据
//            self.reloadData()            
        }).addDisposableTo(bag)        

        // 监听点击cell 获取Model
        tabV.rx.modelSelected(RxModel.self).subscribe(onNext: { (model : RxModel) in            
            print(model.name)            
        }).addDisposableTo(bag)

VIewModel中的代码
var modelObserable : Variable<[RxModel]> = {        
        var models : [RxModel] = [RxModel]()        
        for i in 0..<20 {            
            let model = RxModel()
            model.name = "我是小\(i)"
            models.append(model)
        }        
        return Variable(models)        
    }()

本文代码Demo

《多次更新完结》

上一篇下一篇

猜你喜欢

热点阅读