RxSwift基础知识点强化

有备者无患,徐徐以图之。--------新年寄语

一、RX介绍

1、简介
  • ReactiveX(简写: Rx) 是一个可以帮助我们简化异步编程的框架。
  • KVO,异步操作 和 流 全部被统一成抽象序列。这就是为什么 Rx 会如此简单,优雅和强大。
  • RX可以简化异步编程方法,并提供更加优雅的数据绑定。让我们可以时刻响应新的数据同时顺序地处理它们。
2、RX核心角色
  • Observable:负责发送事件(Event)
  • Observer:负责订阅Observable,监听Observable发送的事件(Event)
    Event有三种:
    □ next:携带具体数据。
    □ error:携带错误信息,表明Observable终止,不再发出事件。
    □ completed:表明Observable终止,不再发出事件。
  • Disposable
    □ 每当Observable被订阅时,都会返回一个Disposable实例,当调用Disposable的dispose,就相当于取消订阅。
    □ 在不需要接收事件时,建议取消订阅,释放资源。常见的三种取消订阅的方式:
    observable | BrE əbˈzəːvəbl, AmE əbˈzərvəb(ə)l |
a:立即取消(一次性订阅)
observable.subscribe { event in
    print(event)    
}.dispose()
b:当bag销毁时,会自动调用Disposable的dispose
observable.subscribe { event in
    print(event)    
}.dispose(bag)
c:self销毁时,会自动调用Disposable的dispose
let _ = observable.takeUntil(self.rx.deallocated).subscribe { event in
    print(event)
}

二、Observable

上面遇到的问题就是由于自己对Observable(可观察序列)的意义不明导致的问题。
Observable作为RX的根基,我们就必须对他有最基本的了解。

  • Observable 这个类就是Rx 框架的基础,我们可以称它为可观察序列
  • Observable的作用就是可以一步地产生一系列Event(事件),即一个Observable对象会随着时间推移不定期地发出event(event : T)这样一个事件,并且这些event可以携带数据,它的泛型就是用来指定这个Event携带的数据类型。
  • 有了可观察序列,我们还需要有一个Observer(订阅者)来订阅它,这样这个订阅者才能收到Observable不时发出的Event。
    我们可以通过以下几种方法来创建一个Observable序列。
1、just()方法

该方法通过传入一个默认值来初始化。

所携带的数据必须是Int类型的。
let observable = Observable.just(5)
2、of()方法

该方法可以接受可变数量的参数(必须是同类型的哦~)
由于Swift会自动推断类型,所以我们可以不必显示声明Observable的泛型类型。

let observable = Observable.of("A", "B", "C")
3、from()方法

该方法需要一个数组参数。下面样例中数据里的元素就会被当做这个 Observable 所发出 event携带的数据内容,最终效果同上面饿 of()样例是一样的。

let observable = Observable.from(["A", "B", "C"])
4、empty()方法

该方法创建一个空内容的Observable序列。

let observable = Observable.empty()
5、never()方法

永远不会发出Event(也不会终止)的Observable序列。

let observable = Observable.empty()
6、error()方法

不作任何操作,而是直接发送一个错误的Observable序列。

enum MyError: Error {
    case A
    case B
}
         
let observable = Observable.error(MyError.A)
7、range()方法

方法通过指定起始和结束数值,创建一个以这个范围内所有值作为初始值的Observable序列。下面两种方法创建的Observable序列都是一样的。

//使用range()
let observable = Observable.range(start: 1, count: 5)
 
//使用of()
let observable = Observable.of(1, 2, 3 ,4 ,5)
8、repeatElement()方法

该方法创建一个可以无限发出给定元素的 Event的 Observable 序列(永不终止)

let observable = Observable.repeatElement(1)
9、generate()方法

本方法创建一个只有当提供的所有的判断条件都为true的时候,才会给出动作的Observeable序列。

//使用generate()方法
let observable = Observable.generate(
    initialState: 0,
    condition: { $0 <= 10 },
    iterate: { $0 + 2 }
)
 
//使用of()方法
let observable = Observable.of(0 , 2 ,4 ,6 ,8 ,10)
10、create()方法

该方法接受一个block形式的参数,对每个过来的订阅进行处理。

//这个block有一个回调参数observer就是订阅这个Observable对象的订阅者
//当一个订阅者订阅这个Observable对象的时候,就会将订阅者作为参数传入这个block来执行一些内容
let observable = Observable.create{observer in
    //对订阅者发出了.next事件,且携带了一个数据"hangge.com"
    observer.onNext("hangge.com")
    //对订阅者发出了.completed事件
    observer.onCompleted()
    //因为一个订阅行为会有一个Disposable类型的返回值,所以在结尾一定要returen一个Disposable
    return Disposables.create()
}
 
//订阅测试
observable.subscribe {
    print($0)
}//这个block有一个回调参数observer就是订阅这个Observable对象的订阅者
//当一个订阅者订阅这个Observable对象的时候,就会将订阅者作为参数传入这个block来执行一些内容
let observable = Observable.create{observer in
    //对订阅者发出了.next事件,且携带了一个数据"hangge.com"
    observer.onNext("hangge.com")
    //对订阅者发出了.completed事件
    observer.onCompleted()
    //因为一个订阅行为会有一个Disposable类型的返回值,所以在结尾一定要returen一个Disposable
    return Disposables.create()
}
 
//订阅测试
observable.subscribe {
    print($0)
}

结果:
next(hangge.com)
completed
11、deferred()方法

deferred是创建一个Observable工程,通过传入一个block来执行延迟Observable序列创建的行为,而这个block里就是真正的实例化序列对象的大地方。

//用于标记是奇数、还是偶数
var isOdd = true
 
//使用deferred()方法延迟Observable序列的初始化,通过传入的block来实现Observable序列的初始化并且返回。
let factory : Observable = Observable.deferred {
     
    //让每次执行这个block时候都会让奇、偶数进行交替
    isOdd = !isOdd
     
    //根据isOdd参数,决定创建并返回的是奇数Observable、还是偶数Observable
    if isOdd {
        return Observable.of(1, 3, 5 ,7)
    }else {
        return Observable.of(2, 4, 6, 8)
    }
}
 
//第1次订阅测试
factory.subscribe { event in
    print("\(isOdd)", event)
}
 
//第2次订阅测试
factory.subscribe { event in
    print("\(isOdd)", event)
}
12、interval()方法

创建的 Observable 序列每隔一段设定的时间,会发出一个索引数的元素。而且它会一直发送下去。下面的方法让其每秒发送一次,并且是在主线程发送。

let observable = Observable.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}
13、timer()方法

这个方法有两种用法:
a.创建的Observable序列在经过设定的一段时间之后,产生唯一的一个元素。

//5秒种后发出唯一的一个元素0
let observable = Observable.timer(5, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}
结果:
next(0)
completed

b、创建的Observable序列经过设定的一段时间之后,每隔一段时间产生一个元素。

//延时5秒种后,每隔1秒钟发出一个元素
let observable = Observable.timer(5, period: 1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}
结果:
next(0)
next(1)
......

三、订阅Observable

有了Observable,我们还有使用subscribe()方法来订阅它,接收Observable(可观察序列)发出的Event。

第一种方法:

1、我们使用Observable()订阅了一个Observable对象,该方法的block回调参数就是被发出的event事件,直接打印出来如下:

let observable = Observable.of("张", "三", "丰")
         
observable.subscribe { event in
    print(event)
}

next(张)
next(三)
next(丰)
completed

从打印结果我们可以看到:

  • 初始化Observable序列时的默认值都按顺序通过.next事件发送出来。
  • Observable序列的初始数据都发送完毕,他还会自动发送一个.completed事件出来。
    2、如果要获取事件中的数据,我们要可以通过event.element得到。
第二种方法:

1、RxSwift还提供了另一个subscribe方法,它可以吧event进行分类:

  • 通过不同的block回调处理不同类型的event。(其中OnDisposed标识订阅行为会被dispose后回调)
  • 同时会把event携带的数据直接解包出来作为参数,方便我们使用。
let observable = Observable.of("A", "B", "C")         
observable.subscribe(onNext: { element in
    print(element)
}, onError: { error in
    print(error)
}, onCompleted: {
    print("completed")
}, onDisposed: {
    print("disposed")
})

打印数据:
A
B
C
completed
disposed

2、subscribe()方法的onNext、onError、onCompleted和onDisposed这四个回调block参数都是有默认值的,它们都是可选的。所以我们也可以只处理onNext而删除其他的情况。

let observable = Observable.of("A", "B", "C")         
observable.subscribe(onNext: { element in
    print(element)
})
打印数据:
A
B
C

知识点传送门

你可能感兴趣的:(RxSwift基础知识点强化)