精华内容
下载资源
问答
  • Observable

    2018-11-11 10:57:13
    ②订阅 ObservableObservable 事件监听 ④Observable 的Dispose ①可被监听的序列-概念 ❶Observable理解 Observable<T> 类用于描述元素异步产生的序列,既可观察序列,是 Rx 框架的基础 作用是:异步...

    ①可被监听的序列-概念

    ❶Observable理解

    • Observable<T> 类用于描述元素异步产生的序列,既可观察序列,是 Rx 框架的基础

    • 作用是:异步地产生一系列的 Event(事件),即一个 Observable<T>对象会随着时间推移不定期地发出 event(element : T)

    • Event 还可以携带数据,它的泛型<T> 就是用来指定这个 Event 携带的数据的类型

    • 每一个Observable的实例都是一个序列

    • Observable序列相比于Swift序列的关键优势点在于它能够异步地接收元素

    • 有可观察序列,还需要一个 Observer(订阅者)来订阅它,这个订阅者才能收到 Observable<T>不时发出的 Event

    Observable(ObservableType) 等效于Sequence
    observableType.subscribe(_:) 方法等效于Sequence.makeIterator()
    ObservableType.subscribe(_:) 接收一个观察者ObserverType参数,它将被订阅自动接收由可观察到的序列事件和元素,而不是在返回的生成器上手动调用next()
    • 如果一个Observable发出一个next事件(Event.next(Element)),它还能够继续发出更多的事件
    • 如果一个Observable发出一个error事件(Event.error(ErrorType))或者一个completed事件(Event.completed),那么这个Observable序列就不能给订阅者发送其他的事件了

    ❷创建序列

    框架已经创建好了许多常用的序列。例如:button的点击,textField的当前文本,switch的开关状态,slider的当前数值等等

    一些自定义的序列是需要自己创建的

    • 创建序列最直接的方法就是调用 Observable.create

    创建一个 [0, 1, ... 4] 的序列

    • 调用 Observable.create,在构建函数里面描述元素的产生过程

    • observer.onNext(0)就代表产生了一个元素,他的值是 0

    • 又产生 4个元素分别是 1, 2, ... 4

    • 最后,用 observer.onCompleted() 表示元素已经全部产生,没有更多元素了

    let numbers: Observable<Int> = Observable.create { observer -> Disposable in
          observer.onNext(0)  
          observer.onNext(1)
          observer.onNext(2)
          observer.onNext(3)
          observer.onNext(4)
          observer.onCompleted()
         return Disposeable.create()
      }
    复制代码

    可以用这种方式来封装功能组件,例如:闭包回调

    • 在闭包回调中,如果任务失败,就调用 observer.onError(error!)
    • 如果获取到目标元素,就调用 observer.onNext(jsonObject)
    • 由于这个序列只有一个元素,所以在成功获取到元素后,就直接调用 observer.onCompleted() 来表示任务结束
    • 最后 Disposables.create { task.cancel() } 说明如果数据绑定被清除(订阅被取消)的话,就取消网络请求。
    typealias JSON = Any
    let json: Observable<JSON> = Observable.create { (observer) -> Disposable in
        let task = URLSession.shared.dataTask(with: ...) { data, _, error in
            guard error == nil else {
                observer.onError(error!)
                return
            }
            guard let data = data,
                let jsonObject = try? JSONSerialization.jsonObject(with: data, options: .mutableLeaves)
                else {
                observer.onError(DataError.cantParseJSON)
                return
            }
            observer.onNext(jsonObject)
            observer.onCompleted()
        }
        task.resume()
        return Disposables.create { task.cancel() }
    }
    复制代码

    以上就将传统的闭包回调转换成序列。然后用 subscribe 方法来响应这个请求的结果

    json.subscribe(
        onNext: { json in
            print("取得 json 成功: \(json)")}, 
        onError: { error in
            print("取得 json 失败 Error: \(error.localizedDescription)")},
        onCompleted: {
            print("取得 json 任务成功完成")}
        )
        .disposed(by: disposeBag)
    复制代码

    ❸Event

    事件 Event 的定义

    • Event 就是一个枚举,一个 Observable 是可以发出 3 种不同类型的 Event 事件
    public enum Event<Element>{
        case next(Element)
        case error(Swift.Error)
        case completed
    }
    复制代码

    next

    • next 事件就是那个可以携带数据 的事件,可以说它就是一个“最正常”的事件
    1--2--3--->
    复制代码

    error

    • error 事件表示一个错误,它可以携带具体的错误内容,一旦 Observable 发出了 error event,则这个 Observable 就等于终止了,以后它再也不会发出 event 事件了
    -------1-----2------ x  
    复制代码

    completed

    • completed:completed 事件表示 Observable 发出的事件正常地结束了,跟 error 一样,一旦 Observable 发出了 completed event,则这个 Observable 就等于终止了,以后它再也不会发出 event 事件了
    ------1 ------2--------3-------|
    复制代码

    ❹Observable 与 Sequence比较

    • 可以把每一个 Observable 的实例想象成于一个 Swift 中的 Sequence

    • 即一个 Observable(ObservableType)相当于一个序列 Sequence(SequenceType)

    • ObservableType.subscribe(_:) 方法其实就相当于 SequenceType.generate()

    区别

    • Swift 中的 SequenceType 是同步的循环,而 Observable 是异步的
    • Observable 对象会在有任何 Event 时候,自动将 Event 作为一个参数通过 ObservableType.subscribe(_:) 发出,并不需要使用 next 方法

    ②订阅 Observable

    • 有了Observable,还要用 subscribe() 方法来订阅它,接收它发出的 Event

    订阅方法1

    ❶使用 subscribe() 订阅一个 Observable 对象

    • 该方法的 block 的回调参数就是被发出的 event 事件,将其直接打印出来
    let observable = Observable.of("A","B","C")
    observable.subscribe { event in
                         print(event)}
    //print
    next(A)
    next(B)
    next(C)
    completed
    复制代码

    ❷如果获取到事件里的数据,通过 event.element

    let observable = Observable.of("A","B","C")
    observable.subscribe{ event in
                        print(eventt.element)}????????????
    //print
    Optional("A")
    Optional("B")
    Optional("C")	q
    nil
    复制代码

    订阅方法2

    RxSwift还提供另一个subscribe 方法,它可以把 event 进行分类

    • 通过不同的 block 回调处理不同类型的 event(其中 onDisposed 表示订阅行为被 dispose 后的回调)
    • 同时会把 event 携带的数据直接解包出来作为参数,方便我们使用
    let observable = Observable("A","B","C")
    observable.subscribe(
        onNext:{ element in
                  print(element) },
        onError:{error in
                print(error)},
        onCompleted:{
            print("completed")},
        onDisposed:{
            print("disposed")
        }
    )
    //print
    A
    B
    C
    completed
    disposed
    复制代码
    • subscribe() 方法的 onNext、onError、onCompleted 和 onDisposed 这四个回调 block 参数都是有默认值的,即它们都是可选的。我们可以只处理 onNext 而不管其他的情况
    let observable = Observable.of("A","B","C")
    observable.subscribe(
       onNext:{element in
              print(element)}
    )
    //print
    A
    B
    C
    复制代码

    ③Observable 事件监听

    监听事件的生命周期

    doOn 介绍

    使用 doOn 方法来监听事件的生命周期,它会在每一次事件发送前被调用

    同时它和 subscribe 一样,可以通过不同的 block 回调处理不同类型的 event

    • do(onNext:) 方法就是在 subscribe(onNext:) 前调用
    • 而 do(onCompleted:) 方法则会在 subscribe(onCompleted:) 前面调用

    栗子

    let observable = Observable.of("A","B","C")
    observable.do(
                onNext: { element in 
                        print("Intercepted Next:", element)},
                onError: {error in
                           print("Intercepted Error:", error)},
                onCompleted: {
                     print("Intercepted Completed")
                },
                onDispose: {
                    print("Intercepted Disposed")
                }
                )
               .subscribe(
               onNext: {element in
                       print(element)},
                   onError: {error in
                            print(error)},
                   onCompleted:{
                       print("completed")},
                   onDisposed:{
                       print("disposed")
                   }
               )
    复制代码

    ④Observable 的Dispose

    ❶Observable 从创建到终结流程

    一个 Observable 序列被创建出来后它不会马上就开始被激活从而发出 Event,而是要等到它被某个人订阅了才会激活它 而Observable序列激活之后要一直等到它发出了 .error 或者 .completedevent后,它才被终结

    ❷dispose() 方法

    除了 dispose() 方法之外,更经常用 DisposeBag 的对象来管理多个订阅行为的销毁

    • 以把一个DisposeBag对象看成一个垃圾袋,把用过的订阅行为都放进去,感觉有点像OC释放池
    • 而这个DisposeBag就会在自己快要dealloc的时,对它里面的所有订阅行为都调用 dispose() 方法
    let disposeBag = DisposeBag()
    //第1个Observable,和订阅
    let observable1 = Observable.of("A","B","C")
    observable1.subscribe{ event in
                         print(event)}
               .disposed(by: disposeBag)
    //第2个Observable,和订阅
    let observable2 = Obserable.of(1,2,3)
    observable2.subscribe{event in
                         print(event)}
               .disposed(by: disposeBag)
    复制代码

    转载于:https://juejin.im/post/5be80ac4e51d457844615d24

    展开全文
  • Observable

    2016-03-21 08:29:24
    Observable 概述 在ReactiveX中,一个观察者(Observer)订阅一个可观察对象(Observable)。观察者对Observable发射的数据或数据序列作出响应。这种模式可以极大地简化并发操作,因为它创建了一个处于待命状态的...

    Observable

    概述

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

    这篇文章会解释什么是响应式编程模式(reactive pattern),以及什么是可观察对象(Observables)和观察者(observers),其它几篇文章会展示如何用操作符组合和改变Observable的行为。

    Observable

    相关参考:

    • Single - 一个特殊的Observable,只发射单个数据。

    背景知识

    在很多软件编程任务中,或多或少你都会期望你写的代码能按照编写的顺序,一次一个的顺序执行和完成。但是在ReactiveX中,很多指令可能是并行执行的,之后他们的执行结果才会被观察者捕获,顺序是不确定的。为达到这个目的,你定义一种获取和变换数据的机制,而不是调用一个方法。在这种机制下,存在一个可观察对象(Observable),观察者(Observer)订阅(Subscribe)它,当数据就绪时,之前定义的机制就会分发数据给一直处于等待状态的观察者哨兵。

    这种方法的优点是,如果你有大量的任务要处理,它们互相之间没有依赖关系。你可以同时开始执行它们,不用等待一个完成再开始下一个(用这种方式,你的整个任务队列能耗费的最长时间,不会超过任务里最耗时的那个)。

    有很多术语可用于描述这种异步编程和设计模式,在在本文里我们使用这些术语:一个观察者订阅一个可观察对象 (An observer subscribes to an Observable)。通过调用观察者的方法,Observable发射数据或通知给它的观察者。

    在其它的文档和场景里,有时我们也将Observer叫做SubscriberWatcherReactor。这个模型通常被称作Reactor模式

    创建观察者

    本文使用类似于Groovy的伪代码举例,但是ReactiveX有多种语言的实现。

    普通的方法调用(不是某种异步方法,也不是Rx中的并行调用),流程通常是这样的:

    1. 调用某一个方法
    2. 用一个变量保存方法返回的结果
    3. 使用这个变量和它的新值做些有用的事

    用代码描述就是:

    // make the call, assign its return value to `returnVal`
    returnVal = someMethod(itsParameters);
    // do something useful with returnVal

    在异步模型中流程更像这样的:

    1. 定义一个方法,它完成某些任务,然后从异步调用中返回一个值,这个方法是观察者的一部分
    2. 将这个异步调用本身定义为一个Observable
    3. 观察者通过订阅(Subscribe)操作关联到那个Observable
    4. 继续你的业务逻辑,等方法返回时,Observable会发射结果,观察者的方法会开始处理结果或结果集

    用代码描述就是:

    
    // defines, but does not invoke, the Subscriber's onNext handler
    // (in this example, the observer is very simple and has only an onNext handler)
    def myOnNext = { it -> do something useful with it };
    // defines, but does not invoke, the Observable
    def myObservable = someObservable(itsParameters);
    // subscribes the Subscriber to the Observable, and invokes the Observable
    myObservable.subscribe(myOnNext);
    // go on about my business
    

    回调方法 (onNext, onCompleted, onError)

    Subscribe方法用于将观察者连接到Observable,你的观察者需要实现以下方法的一个子集:

    • onNext(T item)

      Observable调用这个方法发射数据,方法的参数就是Observable发射的数据,这个方法可能会被调用多次,取决于你的实现。

    • onError(Exception ex)

      当Observable遇到错误或者无法返回期望的数据时会调用这个方法,这个调用会终止Observable,后续不会再调用onNext和onCompleted,onError方法的参数是抛出的异常。

    • onComplete

      正常终止,如果没有遇到错误,Observable在最后一次调用onNext之后调用此方法。

    根据Observable协议的定义,onNext可能会被调用零次或者很多次,最后会有一次onCompleted或onError调用(不会同时),传递数据给onNext通常被称作发射,onCompleted和onError被称作通知。

    下面是一个更完整的例子:

    
    def myOnNext     = { item -> /* do something useful with item */ };
    def myError      = { throwable -> /* react sensibly to a failed call */ };
    def myComplete   = { /* clean up after the final response */ };
    def myObservable = someMethod(itsParameters);
    myObservable.subscribe(myOnNext, myError, myComplete);
    // go on about my business
    

    取消订阅 (Unsubscribing)

    在一些ReactiveX实现中,有一个特殊的观察者接口Subscriber,它有一个unsubscribe方法。调用这个方法表示你不关心当前订阅的Observable了,因此Observable可以选择停止发射新的数据项(如果没有其它观察者订阅)。

    取消订阅的结果会传递给这个Observable的操作符链,而且会导致这个链条上的每个环节都停止发射数据项。这些并不保证会立即发生,然而,对一个Observable来说,即使没有观察者了,它也可以在一个while循环中继续生成并尝试发射数据项。

    关于命名约定

    ReactiveX的每种特定语言的实现都有自己的命名偏好,虽然不同的实现之间有很多共同点,但并不存在一个统一的命名标准。

    而且,在某些场景中,一些名字有不同的隐含意义,或者在某些语言看来比较怪异。

    例如,有一个onEvent命名模式(onNext, onCompleted, onError),在一些场景中,这些名字可能意味着事件处理器已经注册。然而在ReactiveX里,他们是事件处理器的名字。

    Observables的”热”和”冷”

    Observable什么时候开始发射数据序列?这取决于Observable的实现,一个”热”的Observable可能一创建完就开始发射数据,因此所有后续订阅它的观察者可能从序列中间的某个位置开始接受数据(有一些数据错过了)。一个”冷”的Observable会一直等待,直到有观察者订阅它才开始发射数据,因此这个观察者可以确保会收到整个数据序列。

    在一些ReactiveX实现里,还存在一种被称作Connectable的Observable,不管有没有观察者订阅它,这种Observable都不会开始发射数据,除非Connect方法被调用。

    用操作符组合Observable

    对于ReactiveX来说,Observable和Observer仅仅是个开始,它们本身不过是标准观察者模式的一些轻量级扩展,目的是为了更好的处理事件序列。

    ReactiveX真正强大的地方在于它的操作符,操作符让你可以变换、组合、操纵和处理Observable发射的数据。

    Rx的操作符让你可以用声明式的风格组合异步操作序列,它拥有回调的所有效率优势,同时又避免了典型的异步系统中嵌套回调的缺点。

    下面是常用的操作符列表:

    1. 创建操作 Create, Defer, Empty/Never/Throw, From, Interval, Just, Range, Repeat, Start, Timer
    2. 变换操作 Buffer, FlatMap, GroupBy, Map, Scan和Window
    3. 过滤操作 Debounce, Distinct, ElementAt, Filter, First, IgnoreElements, Last, Sample, Skip, SkipLast, Take, TakeLast
    4. 组合操作 And/Then/When, CombineLatest, Join, Merge, StartWith, Switch, Zip
    5. 错误处理 Catch和Retry
    6. 辅助操作 Delay, Do, Materialize/Dematerialize, ObserveOn, Serialize, Subscribe, SubscribeOn, TimeInterval, Timeout, Timestamp, Using
    7. 条件和布尔操作 All, Amb, Contains, DefaultIfEmpty, SequenceEqual, SkipUntil, SkipWhile, TakeUntil, TakeWhile
    8. 算术和集合操作 Average, Concat, Count, Max, Min, Reduce, Sum
    9. 转换操作 To
    10. 连接操作 Connect, Publish, RefCount, Replay
    11. 反压操作,用于增加特殊的流程控制策略的操作符

    这些操作符并不全都是ReactiveX的核心组成部分,有一些是语言特定的实现或可选的模块。

    RxJava

    在RxJava中,一个实现了Observer接口的对象可以订阅(subscribe)一个Observable 类的实例。订阅者(subscriber)对Observable发射(emit)的任何数据或数据序列作出响应。这种模式简化了并发操作,因为它不需要阻塞等待Observable发射数据,而是创建了一个处于待命状态的观察者哨兵,哨兵在未来某个时刻响应Observable的通知。

    展开全文
  • observable

    2017-08-09 15:29:34
    1.observable.partition将输入根据函数分为两部分,前者为符合函数条件的,后者为不符合条件的 例如: let [customerSource, tenantSource] = this.formGroup.valueChanges.partition(type => type !== "hudheud...

    1.observable.partition将输入根据函数分为两部分,前者为符合函数条件的,后者为不符合条件的

    例如: let [customerSource, tenantSource] = this.formGroup.valueChanges.partition(type => type !== "hudheud")

    展开全文
  • <p>It would be good to automate the creation of a domain observable when entering a URL observable as it will save the analyst from having to create the domain observable manually. <p>As auto-creating...
  • 建立Observable

    2020-11-29 15:55:35
    建立Observable : create 建立 Observable 的方法有非常多种,其中 create 是最基本的方法。 var observable = Rx.Observable.create( function(observer){ observer.next('hello'); observer.next('world'); }...

    建立Observable : create

    建立 Observable 的方法有非常多种,其中 create 是最基本的方法。

    var observable = Rx.Observable.create(
        function(observer){
          observer.next('hello');
          observer.next('world');
        }
    );
    
    //订阅
    observable.subscribe(
      function(value){
        console.log(value);
      }
    );
    

    订阅 Observable 跟 addEventListener 在实作上其实有非常大的不同。虽然在行为上很像,但实际上 Observable 根本没有管理一个订阅的清单,这个部份的细节我们留到最后说明!

    这裡有一个重点,很多人认为 RxJS 是在做非同步处理,所以所有行为都是非同步的。但其实这个观念是错的,RxJS 确实主要在处理非同步行为没错,但也同时能处理同步行为,像是上面的程式码就是同步执行的。

    Observable 同时可以处理同步与非同步的行为!

    观察者Observer

    Observable 可以被订阅(subscribe),或说可以被观察,而订阅 Observable 的物件又称为 观察者(Observer)。观察者是一个具有三个方法(method)的物件,每当 Observable 发生事件时,便会呼叫观察者相对应的方法。

    注意这裡的观察者(Observer)跟上一篇讲的观察者模式(Observer Pattern)无关,观察者模式是一种设计模式,是思考问题的解决过程,而这裡讲的观察者是一个被定义的物件。

    观察者的三个方法(method):

    • next:每当 Observable 发送出新的值,next 方法就会被呼叫。

    • complete:在 Observable 没有其他的资料可以取得时,complete 方法就会被呼叫,在 complete被呼叫之后,next 方法就不会再起作用。

    • error:每当 Observable 内发生错误时,error 方法就会被呼叫。

    总结

    Observable 可以同时处理同步跟非同步行为
    Observer 是一个物件,这个物件具有三个方法,分别是 next, error, complete
    订阅一个 Observable 就像在执行一个 function

    展开全文
  • 官方解释: ...observable.deep: 所有 observable 都使用的默认的装饰器。它可以把任何指定的、非原始数据类型的、非 observable 的值转换成 ...observable.ref: 禁用自动的 observable 转换,只是创建一个 observabl...
  • Rxjs Observable

    2020-05-14 16:11:58
    创建Observable: Rx.Observable.create 是 Observable 构造函数的别名,它接收一个参数:subscribe 函数。 例子:每秒推送一个“Hi” Rx.Observable.create(function subscribe(observer){ var i=setInterval(...
  • Observable的分类 Observable 有 Cold 和 Hot 之分。 hot&amp;cold observable.jpg Hot Observable 无论有没有 Subscriber 订阅,事件始终都会发生。当 Hot Observable 有多个订阅者时,Hot Observable 与订阅者...
  • Cold Observable 每次订阅都会产生新的生产者。 例如 const hot$ = Obervable.interval(1000) hot$.subscribe hot$.subscribe 每次都会返回新的数据流 常用的有 interval range  Hot Observable 每次订阅都...
  • Observable入门

    千次阅读 2018-05-24 09:35:16
    1. 什么是Observable和 Observer?1.1 ObservableObservable是能向观察它的人(或外界)在一定时间段内推送值的实体。Observable实体可能会一直推送下去,也可能在某时间点结束,也可能在某时间点抛出error故...
  • Vue observable

    2020-09-14 10:02:53
    observable 官方 用法// <el-button type="primary" @click="onSave">{{state.count}}</el-button> this.state = Vue.observable({ count: 0 }); state: null onSave() { this.state.count++; --...
  • Observable详解

    千次阅读 2018-08-22 10:59:30
    浏览新版,请访问 RxJS Observable 在介绍 Observable 之前,我们要先了解两个设计模式: Observer Pattern - (观察者模式) Iterator Pattern - (迭代器模式) 这两个模式是 Observable 的基础,下面我们先来介绍...
  • <div><p>Is it possible to merge the $.observable of jsViews with the $.observable implemented by jQuery UI team. I think jQuery UI's observable does not have computed properties. jsViews's $....
  • observable Java 8中的CompletableFuture<T>是对T类型的值将来将可用的承诺的高级抽象。 Observable<T>非常相似,但是它承诺将来会出现任意数量的项,从0到无穷大。 异步结果的这两种表示与仅使用一项...
  • <div><p><code>Observable.from</code> currently only checks that the constructor property of the input is equal to the the this object of <code>Observable.from</code>. This seems easy to spoof. It'...
  • <p>When creating an observable, the observable type is fixed. We can not select other types which are not in the list. Ex. host name (not domain name) is not in the list now. <h2>Current Workaround ...
  • HOT Observable Cold Observable 无论有没有观察者进行订阅,事件始终都会发生 只有观察者订阅了,才开始执行发射数据流的的带啊吗 关系 与订阅者们的关系是一对多的关系,可以与多个订阅者共享...
  • Observable讲解

    2017-09-28 11:25:00
    参见这里 总结: Observable是传统观察者+链式模式的函数式实现 Observable官方文档 还是比较喜欢EventBus,简单粗暴,angular-event-service可支持angular4的自定义多事件广播 ...
  • 在Rxjava中Observable 有 Hot 和 Cold之分.  Hot Observable:  Hot Observable无论有没有观察者进行订阅事件始终都会发生. 当Hot Observable 有多个订阅者时(即多个订阅者进行订阅时), Hot Observable与订阅者...
  • <p>Compatibility with <a href="https://redux-observable.js.org/MIGRATION.html">redux-observable v1</a>. Looks like it relates to https://github.com/ioof-holdings/redux-subspace/issues/87</p><p>该提问...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,813
精华内容 5,925
关键字:

observable