美文网首页
RxSwift - 理论篇01 - Observables

RxSwift - 理论篇01 - Observables

作者: XDLee | 来源:发表于2017-07-31 12:31 被阅读22次

首先，了解一下下面的代码:

public func example(of description: String, action: () -> Void) {
    print("\n--- Example of:", description, "---")
    action()
}

我们将使用这个 方法 来封装不同的示例。

一、 Creating observables(创建可观察者)

1、just

（1）含义:

Creates an Observable sequence with a single element.
创建一个序列，这个序列只能发出一个特定的事件，并且可以正常结束（会发出 completed 事件）

在所有 Observable 对象的创建方法中，最简单的就是 just。
（2）图解:

just.png
（3）Code: 
// MARK: - just
example(of: "just") {
    // 1
    let one = 1
    let two = 2
    let three = 3
    // 2
    let observable: Observable<Int> = Observable<Int>.just(one)
}

以下是上面的代码所做的操作:

  1. 定义一些您将在以下示例中使用的整数常量。
  2. 使用 just 方法携带一个 integer 的值，创建一个 Int 类型的可观察序列。

恰如其名，它所做的就是创建一个只包含一个元素的 observable(可观察者序列)。just 是 Observable 的一个类型方法，但是，在 Rx 中，方法被称为 operators(操作符)。

2、of

（1）含义:

Creates an Observable sequence with a fixed number of elements.
创建一个序列，这个序列可以发出很多事件。

（2）图解:
（3）Code:

// MARK: - of
example(of: "of") {
    // 1
    let one = 1
    let two = 2
    let three = 3
    // 2
    let observable2 = Observable.of(one, two, three)
}

这次我们没有明确指定数据类型，你可能会认为，因为我们给它传了几个整数，所以 observable2 的类型是 Observable<[Int]> 。这个时候，通过按住 Option 键单击 observable2，以显示它的推断类型，我们发现 observable2 的类型是 Observable<Int>，而不是一个数组类型 Observable<[Int]>。

Observable<Int>.png

如果我们想创建一个可观察的数组，我们可以传递一个数组给 of 操作符。

    let observable3 = Observable.of([one, two], [three])

同样的，我们可以看一下 observable3 的推断类型，如下:

Observable[Int].png

这就说明，just 操作符也可以将数组作为单个元素。这个时候，数组作为单个元素，而不是数组中的内容。

3、from

（1）含义:

Creates an Observable sequence from a Sequence, such as an Array, Dictionary, or Set.
创建一个序列，这个序列中的 element 可以来自Array、Dictionary 或
Set。

（2）图解:
（3）Code:

// MARK: - "from"
example(of: "from") {
    
    // 1
    let one = 1
    let two = 2
    let three = 3
    
    // 2
    let observable4 = Observable.from([one, two, three])
}

from 从常规的元素数组中创建一个单个类型的实例。
查看 observable4 的推断类型，如下:

from - Observable<Int>.png
元素数组为 [Int] 类型，from 创建出来的 observable4 是 Observable<Int> 类型，而不是 Observable[Int]。

二、 Subscribing to observables(订阅可观察者)

在上面的示例中，我们会发现，所有的示例在控制台中都没有任何打印输出，除了 example 的 header。接下来，我们就需要通过订阅可观察者来实现相关的打印输出。

1、subscribe

(1) 含义
在日常 iOS 编程中，通知模式可以说是使用频率相当高的一个设计模式。我们通过 NotificationCenter 实现消息的广播和订阅。下面是一个典型的通知模式代码用于处理 UIKeyboardDidChangeFrame 消息：

let observer = NotificationCenter.default.addObserver( 
    forName: .UIKeyboardDidChangeFrame, 
    object: nil, 
    queue: nil ) { notification in 
    // 闭包
}

RxSwift 中的订阅操作也非常简单，只需要调用 subscribe 方法就行了。不过与 NotificationCenter 机制不同的是，RxSwift 中每一个订阅都是唯一的并没有一个类似 default 这样的全局单例对象。

更为重要的是，在没有订阅者的时候 Observable 对象不会发送事件。
(2) Code

// MARK: - subscribe
example(of: "subscribe") {
    
    // 1
    let one = 1
    let two = 2
    let three = 3
    
    // 2
    let observable = Observable.of(one, two, three)
    
    // 3
    observable
        .subscribe({ event in
            print(event)
        })
}

(3) 结果

--- Example of: subscribe ---
next(1)
next(2)
next(3)
completed

(4) 打印元素
如果想在控制台打印元素，可以通过以下代码:

    // 4
    observable
        .subscribe({ event in
            if let element = event.element {
                print(element)
            }
        })

输出结果为:

--- Example of: subscribe ---
1
2
3

(5) 通过 onNext 闭包取值

Observable.of(one, two, three)
        .subscribe(onNext: { (element) in
            print(element)
        })

这里，我们只处理了 .next 事件的元素而忽略了其它所有事件。onNext 闭包接收 .Next 事件的元素作为参数，所以我们不必像之前那样从事件中去检索该元素。

输出结果:

--- Example of: subscribe ---
1
2
3

2、empty

（1）含义:

Creates an empty Observable sequence that only emits a Completed event.
创建一个空的序列，这个序列可以正常结束（只会发出 completed 事件）

（2）图解:

empty.png

（3）Code:

// MARK: - empty
example(of: "empty") {

    let observable = Observable<Any>.empty()
    observable
        .subscribe(onNext: { (element) in
            print(element)
        }, onCompleted: {
            print("Completed")
        })
}

（4）结果:

--- Example of: empty ---
Completed

（5） 什么时候使用 empty
当我们需要返回一个会立即终止的 observable 或者 故意零值的 observable 的时候。

3、never

（1）含义:

Creates a sequence that never terminates and never emits any events.
创建一个序列，这个序列永远不会终止，并且永远不会发出任何事件。

（2）图解:

never.png

（3）code:

// MARK: - never
example(of: "never") {

    let observable = Observable<Any>.never()
    observable
        .subscribe(onNext: { (element) in
            print(element)
        }, onCompleted: {
            print("Completed")
        })

（4）结果:

--- Example of: never ---

什么都没打印，除了 example header。甚至没有发出 .completed 事件。

4、range

到目前为止，我们学习的都是具有显式变量的 observables。但是它也可以从一系列值中生成一个 observable。
（1）含义:

Creates an Observable sequence that emits a range of sequential integers and then terminates.
创建一个序列，这个序列会发出给定范围中的从开始到结束的所有事件，可以终止。

（2）图解:

range.png

（3）code:

// MARK: - range
example(of: "range") {

    let observable = Observable.range(start: 1, count: 10)
    observable
        .subscribe(onNext: {
            let n = Double($0)
            let fibonacci = Int(((pow(1.61803, n) - pow(0.61803, n)) /
                2.23606).rounded())
            print(fibonacci)
        })
}

（4）结果:

--- Example of: range ---
0
1
2
3
5
8
13
21
34
55

除了 never() 示例之外，到目前为止，我们一直在使用 observable 自动发出 .completed 事件并自然终止。

三、Disposing and terminating(处理和终止)

1、dispose

（1）含义
请记住，在收到订阅之前，observable不会执行任何操作。 它的触发observable开始发出事件的订阅，直到它发出一个 .error 或 .completed 事件并被终止。 你可以手动导致通过取消订阅来观察终止。
（2）Code

// MARK: - dispose
example(of: "dispose") {

    // 1
    let observable = Observable.of("A", "B", "C")

    // 2
    observable
        .subscribe({ (event) in
            print(event)
        })
        .dispose()
}

（3）输出结果

--- Example of: dispose ---
next(A)
next(B)
next(C)
completed

2、disposeBag

（1）含义
单独管理每个订阅将是乏味的，因此 RxSwift 包括一个DisposeBag类型。一个 DisposeBag 持有 disposables - 通常使用 .disposed(by:) 方法来添加 - 并且当 disposeBag 即将被解除分配时将在每个 disposable 上调用dispose()。
（2）Code

// MARK: - disposeBag
example(of: "disposeBag") {

    // 1
    let disposeBag = DisposeBag()

    // 2
    Observable.of("A", "B", "C")
        .subscribe({
            print($0)
        })
        .disposed(by: disposeBag)
}

（3）输出结果

--- Example of: disposeBag ---
next(A)
next(B)
next(C)
completed

这是您最常使用的模式; 创建和订阅可观察者，并立即将订阅添加到 disposeBag 中。

3、create

（1）含义:

Creates a custom Observable sequence. 
创建一个自定义的序列。

（2）图解:

create.png

（3）code:

// MARK: - create
func demo6() {
    let disposeBag = DisposeBag()
    let observable = { (element: String) -> Observable<String> in
        return Observable.create { observer in
          observer.onNext(element)
          observer.onCompleted()
          return Disposables.create()
        }
    }
      
    observable("123")
        .subscribe { event in
            print(event)    
        }
        .addDisposableTo(disposeBag)
}

（4）结果:

create 执行结果.png

8、repeatElement

（1）含义:

Creates an Observable sequence that emits the given element indefinitely.
创建一个序列，这个序列可以将特定的事件发送多次。

（2）图解:

repeatElement.png

（3）code:

// MARK: - repeatElement
func demo8() {
    let disposeBag = DisposeBag()
    let observable = Observable.repeatElement("🔴")
    observable
        .take(3)
        .subscribe { event in
            print(event)
        }
        .addDisposableTo(disposeBag)
}

（4）结果:

repeatElement 执行结果.png

9、generate

（1）含义:

Creates an Observable sequence that generates values for as long as the provided condition evaluates to true.
创建一个序列，当条件为 true 时，就会发出对应的事件。

（2）图解:
（3）code:

// MARK: - generate
func demo9() {
    let disposeBag = DisposeBag()
    let observable = Observable.generate(
        initialState: 0,
        condition: { $0 < 5 },
        iterate: { $0 + 1 })
    observable
        .subscribe { event in
            print(event)
        }
        .addDisposableTo(disposeBag)
}

（4）结果:

generate 执行结果.png

10、deferred

（1）含义:

Creates a new Observable sequence for each subscriber.
创建一个序列，为每一个订阅者创建一个新的可观察序列。

（2）图解:

deferred.png

（3）code:

// MARK: - deferred
func demo10() {
    let disposeBag = DisposeBag()
    var count = 1
    
    let deferredSequence = Observable<String>.deferred {
        print("Creating \(count)")
        count += 1
        
        return Observable.create { observer in
            print("Emitting...")
            observer.onNext("🐶")
            observer.onNext("🐱")
            observer.onNext("🐵")
            return Disposables.create()
        }
    }
    
    deferredSequence
        .subscribe(onNext: { print($0) })
        .addDisposableTo(disposeBag)
    
    deferredSequence
        .subscribe(onNext: { print($0) })
        .addDisposableTo(disposeBag)
}

（4）结果:

deferred 执行结果.png

11、error

（1）含义:

Creates an Observable sequence that emits no items and immediately terminates with an error.
创建一个序列，不会发出任何正常事件，只会发送 error 事件，并立即终止。

（2）图解:

（3）code:

// MARK: - error
public enum TestError : Error {
    
    case test
}

func demo11() {
    let disposeBag = DisposeBag()
    let observable = Observable<Int>.error(TestError.test)
    observable
        .subscribe {
            print($0)
        }
        .addDisposableTo(disposeBag)
}

（4）结果:

error 执行结果.png

12、doOn

（1）含义:

Invokes a side-effect action for each emitted event and returns (passes through) the original event.
创建一个序列，。

（2）图解:

（3）code:

// MARK: - doOn
func demo12() {
    let disposeBag = DisposeBag()
    let observable = Observable.of("🍎", "🍐", "🍊", "🍋")
    observable
        .do(onNext: {
            print("Intercepted:", $0)
        }, onError: {
            print("Intercepted error:", $0)
        }, onCompleted: { 
            print("Completed")
        })
        .subscribe { event in
            print(event)
        }
        .addDisposableTo(disposeBag)
}

（4）结果:

doOn 执行结果.png

相关文章

网友评论

      本文标题：RxSwift - 理论篇01 - Observables

      本文链接：https://www.haomeiwen.com/subject/ofnllxtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|RxSwift - 理论篇01 - Observables|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！