RXSwift 入坑记

以前一直都是命令式编程，这个view干嘛，那个label干嘛，这样的代码写了几个世纪了，实在是疲劳了而且重复使用率很差。其实我是很早就知道这个RXSwift了，就是感觉很复杂会拖项目进度，一直不敢进坑。最近公司不忙，充实一下自己，为以后的项目铺好路子，捡起了响应式编程。如果哪里不对的，请各位指正，不懂的也可以评论，大家一起提高。废话说的太多了，下面开始：

为什么要使用

我们编写的绝大部分代码都涉及到外部事件的响应。当一个用户操作控制的时候，我们需要写一个@IBAction来处理。我们需要观察通知来监测键盘如何更改位置。URL回话响应数据时，我们需要用闭包来执行。我们使用KVO来监听变量的改变。所有这些不同的系统都让我们的代码不必要的复杂。如果有一个一致统一的系统来处理这些呼叫／响应，那岂不是很好。RX就是这样一个系统。

概念

所有Observable实例只是一个队列。

Observable队列比swift队列的好处就是他可以异步接受元素。这是RXSwift的核心，所有扩展都是在这个概念基础上的。

• Observable(ObservableType)跟Sequence一样
• ObservableType.subscribe(_:)和Sequence.makeIterator()类似
• ObservableType.subscribe(_:)拥有一个观察者对象(ObserverType)的参数，这个对象将被订阅自动接受队列事件和Observable所发出的元素，而不是手动的调用next()

如果一个Observable发出一个next事件Event.next(Element)，她可以继续发出更多的事件。当然如果发出一个error事件Event.error(ErrorType)或者一个完成事件Event.completed,Observable队列不会再给订阅者发送额外的事件。源代码里是一个递归枚举

public enum Event<Element> {

    /// Next element is produced.
    case next(Element)

    /// Sequence terminated with an error.
    case error(Error)

    /// Sequence completed successfully.
    case completed
}

Observables and observers

Observables不会执行订阅的闭包除非有一个订阅者。下面的例子中，Observable的订阅闭包不会执行，因为她并没有订阅者。她只是一个可被订阅者。

 _ = Observable<String>.create { observerOfString -> Disposable in
     print("This will never be printed")
     observerOfString.on(.next("😬"))
     observerOfString.on(.completed)
     return Disposables.create
  }

下面这种情况，当调用subscribe(_:)方法了，闭包就会被执行了

_ = Observable<String>.create { observerOfString in
         print("Observable created")
         observerOfString.on(.next("😉"))
         observerOfString.on(.completed)
         return Disposables.create()
     }
     .subscribe { event in
         print(event)
}

subscribe(_:)这个方法返回Disposable实例。这种类型以后会讨论。就是一个可以被释放的类型，需要释放。

构建和订阅Observables

有很多方法来构建和订阅Observables

never

构建一个从不终止和发出任何事件的队列

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

empty

构建一个空的Observable队列，只发出完成事件

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

just

构建一个只有一个元素的Observable队列

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

of

构建一个拥有固定数量元素的Observable序列

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

subscribe(_:)方法接受事件参数，下面这个例子接受元素参数

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

from

从序列中创建可观察到的序列，如数组、字典或集合。

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

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)

range

创建一个可观察序列，该序列释放一系列连续整数，然后终止

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

repeatElement

创建一个可观察到的序列，它无限地释放给定的元素

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

generate

创建一个可观察的序列，只要所提供的条件求值为true，就生成值。

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

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)

error

创建一个没有任何元素的可观察序列，并立即以错误结束。

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

doOn

为每个发出的事件调用副作用动作并返回（传递）原始事件。

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

限于篇幅，过长我自己都懒的会去看，关于Subjects的部分在下文详细记录。>>>>>Subjects