注意：使用本例中的代码首先应该导入头文件，代码如下：

import RxSwift

创建和订阅 Observables

这里有以下几种方法来创建和订阅Observable序列。

never

创建一个不会终止和不会发出任何事件的序列。了解更多

example("never") {
    let disposeBag = DisposeBag()
    let neverSequence = Observable<String>.never()
    let neverSequenceSubscription = neverSequence
         .subscribe { _ in
            print("This will never be printed")
    }
    neverSequenceSubscription.disposed(by: disposeBag)
}

Debug Area 输出：
--- never example ---

empty

创建一个空的Observable序列，这个序列仅仅只发出一个 Completed 事件。了解更多

example("empty") {
    let disposeBag = DisposeBag()

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

Debug Area 输出：
--- empty example ---
completed
注意：这个例子还介绍了创建和订阅一个Observable序列怎样连接在一起使用。

just

创建仅有一个元素的Observable序列。�了解更多

example("just") {
    let disposeBag = DisposeBag()

    Observable.just("🔴")
        .subscribe { event in
            print(event)
        }
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- just example ---
next(🔴)
completed

of

创建具有固定数量元素（参数）的Observable序列。

example("of") {
    let disposeBag = DisposeBag()

    Observable.of("🐶", "🐱", "🐭", "🐹")
        .subscribe(onNext: { element in
            print(element)
        })
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- of example ---
🐶
🐱
🐭
🐹
Tips:这个例子还介绍了怎样使用subscribe(onNext:)便利方法。与subscribe(_:)不同的是，subscribe(_:)方法给所有的事件类型 (Next, Error, Completed) 订阅了一个event（事件）处理者，而subscribe(onNext:)方法则订阅了一个element（元素）处理者，这个element（元素）处理者将会忽略 Error 和 Completed 事件并且只产生 Next 事件元素。还有subscribe(onError:)和subscribe(onCompleted:)便利方法，只要你想订阅这些事件类型。而且还有一个subscribe(onNext:onError:onCompleted:onDisposed:)方法，它允许你对一个或多个事件类型做出反应，而且在单独调用时当因为任何原因，或者被处理，订阅会被终止：

someObservable.subscribe(
    onNext: { print("Element:", $0) },
    onError: { print("Error:", $0) },
    onCompleted: { print("Completed") },
    onDisposed: { print("Disposed") }
)

from

使用一个Sequence类型的对象创建一个Observable序列，比如一个Array，Dictionary，或者Set。

example("from") {
    let disposeBag = DisposeBag()

    Observable.from(["🐶", "🐱", "🐭", "🐹"])
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- from example ---
🐶
🐱
🐭
🐹

注意：这个例子还演示了怎样使用默认参数名$0代替显示命名参数。

create

创建一个自定义的Observable序列。了解更多

example("create") {
    let disposeBag = DisposeBag()

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

Debug Area 输出：
--- create example ---
next(🔴)
completed

range

创建一个在一定范围发出一系列连续的整数序列然后终止的Observable序列。了解更多

example("range") {
    let disposeBag = DisposeBag()

    Observable.range(start: 1, count: 10)
        .subscribe { print($0) }
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- range example ---
next(1)
next(2)
next(3)
next(4)
next(5)
next(6)
next(7)
next(8)
next(9)
next(10)
completed

repeatElement

创建一个不确定次数地发出指定元素的Observable序列。了解更多

example("repeatElement") {
    let disposeBag = DisposeBag()

    Observable.repeatElement("🔴")
        .take(3)
        .subscribe(onNext:  { print($0) })
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- repeatElement example ---
🔴
🔴
🔴
注意：这个例子还介绍了使用take操作从一个序列开始到�指定数量的元素。

generate

创建一个只要条件的值为true就生成值的Observable序列。

example("generate") {
    let disposeBag = DisposeBag()

    Observable.generate(
            initialState: 0,
            condition: { $0 < 3 },
            iterate: { $0 + 1 }
        )
        .subscribe (onNext: { print($0) })
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- generate example ---
0
1
2

deferred

为每一个订阅者创建一个新的Observable序列。了解更多

example("deferred") {
    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) })
        .disposed(by: disposeBag)
    deferredSequence
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- deferred example ---
Creating 1
Emitting...
🐶
🐱
🐵
Creating 2
Emitting...
🐶
🐱
🐵

error

创建一个不会发散出任何事件或元素并且遇到错误就会立即终止的Observable序列。

example("error") {
    let disposeBag = DisposeBag()

    Observable<Int>.error(TestError.test)
        .subscribe { print($0) }
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- error example ---
error(test)

doOn

为每一个被发出的事件调用一个附带动作并且返回(通过)最初的事件。了解更多

example("doOn") {
    let disposeBag = DisposeBag()

    Observable.of("🍎", "🍐", "🍊", "🍋")
        .do(
            onNext: { print("Intercepted", $0) }, 
            onError: { print("Intercepted error:", error) }, 
            onCompleted: { print("Completed") }
        )
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}

Debug Area 输出：
--- doOn example ---
Intercepted: 🍎
🍎
Intercepted: 🍐
🍐
Intercepted: 🍊
🍊
Intercepted: 🍋
🍋
Completed
注意：还有doOnNext(_:),doOnError(_:),和doOnCompleted(_:)拦截特定事件的便利方法，而且doOn(onNext:onError:onCompleted)方法在单独调用时可以拦截一个或多个事件。

下一篇： �四、Working with Subjects(Rx.playground翻译)