RxSwift（一）Creating and Subscribing to Observables 创建和订阅观察者

0、Observable

在ReactiveX中，一个观察者(Observer)订阅一个可观察对象(Observable)。观察者对 Observable发射的数据或数据序列作出响应。这种模式可以极大地简化并发操作，因为它创建了一个处于待命状态的观察者哨兵，在未来某个时刻响应Observable的通知，不需要阻塞 等待Observable发射数据。

Observable

1、初始化playground

• 初始化项目工程，pod引入RxSwift
• 创建playground
• 在playground\Sources下创建 support.swift文件 填写下面代码
• Demo地址github.com/RockyAo/RxS….或者直接看官方的demo

import Foundation

public func exampleOf(description:String, action:  @escaping ()->Void)  {
    
    print("\n------exampleOf:\(description)------")
    
    action()
    
}

import PlaygroundSupport

public func playgroundShouldContinueIndefinitely() {
    PlaygroundPage.current.needsIndefiniteExecution = true
}

复制代码

• 在playground中导入RxSwift,RxCocoa

2、never

创建一个不发射任何数据的Observable

exampleOf(description:"never"){

    let disposeBag = DisposeBag()
    
    let neverSequence = Observable<String>.never()
    
    neverSequence.subscribe{ _ in
    
        print("永远不会执行")
        
    }.disposed(by: disposeBag)
}
复制代码

3、empty

创建一个什么都不做直接通知完成的Observable.它只发送 .Completed 消息。

exampleOf(description: "empty"){

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

复制代码

4、just:

将一个或多个对象转换成发射这个或这些对象的一个Observable,just 是只包含一个元素的序列，它会先发送 .Next(value) ，然后发送 .Completed 。

exampleOf(description: "just"){

    Observable.just("我是对象")
        .subscribe{ event in
            
    
            print(event)
    }.addDisposableTo(DisposeBag())
}
复制代码

5、of

可以把一系列元素转换成事件序列

exampleOf(description: "of"){

    Observable.of(1,2,3)
    .subscribe(onNext: { (event) in
        print(event)
    }, onError: { (error) in
        print(error)
    }, onCompleted: {
        print("信号完成")
    }, onDisposed: { 
        print("信号序列释放")
    }).disposed(by: DisposeBag())
}
复制代码

6、from

from 是通过 asObservable() 方法把 Swift 中的序列 (SequenceType) 转换成事件序列。例如:将一个数组转换成一个Observable

exampleOf(description: "from"){

    Observable.from(["lily","lilei","sb"])
    .subscribe(onNext: {
        
        print($0)
        
    }).disposed(by: DisposeBag())
    
}
复制代码

7、create

使用一个函数闭包从头创建一个Observable,通过 .on(e: Event) 添加事件。

exampleOf(description: "create"){

    
    let myJust = { (element:String) -> Observable<String> in
    
        return Observable.create{ observable in
            
            observable.on(.next(element))
            
            observable.on(.completed)
            
            return Disposables.create()
        }
    }
    
    myJust("?")
        .subscribe{
    
            print($0)
    }.disposed(by: DisposeBag())
}

复制代码

8、range

创建一个发射特定整数序列的Observable

exampleOf(description: "range"){

    Observable.range(start: 1,count:10)
        .subscribe{
    
            print($0)
    }.disposed(by: DisposeBag())
}
复制代码

9、repeatElement

创建一个重复发射指定数据或数据序列的Observable，

exampleOf(description: "repeatElement" ){

    Observable.repeatElement("?")
        .take(3)//只发射3次
        .subscribe{print($0)}
        .disposed(by: DisposeBag())
}
复制代码

10、generate

发射所有条件为真的值的响应序列(这个是我猜的，有不同意见欢迎留言)

exampleOf(description: "generate"){

    Observable.generate(initialState: 0, condition: { (T) -> Bool in
        
        T < 3
        
    }, iterate: {  $0 + 1})
        .subscribe{
    
          print($0)
    }.addDisposableTo(DisposeBag())
}
复制代码

11、deferred

deferred 会等到有订阅者的时候再通过工厂方法创建 Observable 对象，每个订阅者订阅的对象都是内容相同而完全独立的序列。

exampleOf(description: "deferred"){

    var count = 1
    
    let disposeBag = DisposeBag()
    
    let deferredSequence = Observable.deferred({ () -> Observable<String> in
        
        print("creat---\(count)")
        
        return Observable.create{ observable in
        
            print("发射~~~~...")
            observable.onNext("?")
            observable.onNext("?")
            observable.onNext("?")
            return Disposables.create()
        }
    })
    
    //第一个订阅者
    
    deferredSequence.subscribe{
    
        print("第一个订阅者--------")
        print($0)
    }.disposed(by: disposeBag)
    
    
    //第二个订阅者
    deferredSequence.subscribe{
    
        print("第二个订阅者")
        print($0)
    }.disposed(by: disposeBag)
}


复制代码

12、error

创建一个什么都不做直接通知错误的Observable

exampleOf(description: "error"){

    enum testError:Error{
    
        case bigError
    }
    
    Observable<Int>.error(testError.bigError).subscribe{
    
        print($0)
    }
}
复制代码

13、doOn

doOn 可以监听事件，并且在事件发生之前调用。

exampleOf(description: "doOn") { 
    
    Observable.of(1,2,3,4).do(onNext: { (event) in
        print(event)
    }, onError: { (error) in
        print(error)
    }, onCompleted: {
        print("完成")
    }, onSubscribe: {
        print("订阅")
    }, onDispose: { 
        print("释放")
    }).subscribe{
        
        print($0)
    }.disposed(by: DisposeBag())
}
复制代码