RxSwift 函数式编程/响应式编程

监听相关

添加监听

RxSwift的核心是想是 Observable sequence，Observable表示可监听或者可观察，也就是说RxSwift的核心思想是可监听的序列。并且，Observable sequence可以接受异步信号，也就是说，信号是可以异步给监听者的

ObservableType.subscribe的回调（新的信号到来）一共有三种

enum Event<Element>  {
    case Next(Element)      // 新的信号到来
    case Error(ErrorType)   // 信号发生错误，序列不会再产生信号
    case Completed          // 序列发送信号完成，不会再产生新的信号
}
protocol ObserverType {
    func on(event: Event<Element>) // 监听所有信号
}

取消监听

Observable分为两种

在有限的时间内会自动结束(Complete/Error)，比如一个网络当做一个序列，当网络请求完成的时候，Observable自动结束，资源会自动释放
信号不会自己结束，最简单的比如Timer，每隔一段时间发送一个新的信号过来，这个时候就需要取消监听，来释放相应的资源，又比如label.rac_text是一个Observable，通常需要这样调用 addDisposableTo(disposeBag)来让其在deinit，也就是所有者要释放的时候，自动取消取消监听。

class Observable<Element> {
    func subscribe(observer: Observer<Element>) -> Disposable  // 调用Disposable的方法来取消
}

当然，除了手动释放，RxSwfit提供了一些操作符，比如 takeUntil 来根据条件取消

sequence
    .takeUntil(self.rx_deallocated) //  当对象要释放的时候，取消监听
    .subscribe {
        print($0)
    }

信号处理的顺序

Observable有个隐式的约定，那就是在一个信号处理完成之前，不会发送下一个信号，不管发送信号的线程是并发的or串行的。

比如

someObservable
  .subscribe { (e: Event<Element>) in
      print("Event processing started")
      // processing
      print("Event processing ended")
  }

只会出现

Event processing started
Event processing ended
Event processing started
Event processing ended
Event processing started
Event processing ended

不会出现

Event processing started
Event processing started
Event processing ended
Event processing ended

操作符(Operator)

对信号进行映射，过滤，这时候我们就要用到操作符了。关于操作符效果，你可以参见 http://rxmarbles.com/的可视化效果

map 对信号（Element）进行映射处理。比如输入是String，影射到Bool
filter 对信号(Element)进行过滤处理。返回信号，和输入的信号是同一种类型
combineLatest 对两种信号的值进行结合。可以返回不同种类的信号。

let firstObserverable = firstTextfield.rx_text.map({"first" + $0})
let secondObserverable = secondTextfield.rx_text.filter({$0.characters.count > 3})
_ =  Observable.combineLatest(firstObserverable, secondObserverable, resultSelector:{ ($0 + $1,$0.characters.count + $1.characters.count)}).subscribeNext { (element) in
    print("combineLatest:\(element)")
}

对于，每一个fistTextfield的信号，在字符串开始出增加“first”；对secondTextField的信号进行过滤，当长度大于3的时候，才会继续传递。对两个信号进行结合，取truple类型，然后打印出来。

所以，当我们在firstTextfield中输入1234，然后在secondTextfield中依次输入abcdefg的时候

combineLatest:("first1234abcd", 13)
combineLatest:("first1234abcd3", 14)
combineLatest:("first1234abcd", 13)
combineLatest:("first1234abcde", 14)
combineLatest:("first1234abcdef", 15)
combineLatest:("first1234abcdefg", 16)

创建一个Observable

Observable可以用来处理任务，并且异步返回Event信号(Next, Error, Completion)

// observable就是处理输入，并且把description发送出去
func createObservable(object: AnyObject?) -> Observable<String?> {
    return Observable.create({ observer in
        observer.onNext(object?.description)
        observer.onCompleted()
        return NopDisposable.instance
    })
}

这样调用


_ = createObserveable(test).subscribe({ (event) in
    switch event {
    case .Next(let value):
        print(value)
    case .Completed:
        print("Completed")
    case .Error(let error):
        print(error)
    }
})

log如下

Optional("{\n    a = b;\n    1 = 2;\n}")
Completed

可以看到，创建一个Observable相当容易，调用Observable.create，在必要的时候发送onNext，onError，onCompleted信号。然后返回一个Disposable来取消信号。

throttle/retry/distinctUntilChanged/flatMapLatest

throttle 忽略上一个信号的一段时间的变化，也就是说一段时间没有新的信号输入，才会向下发送
distinctUntilChanged 直到信号改变了再发送
retry 如果失败，重新尝试的次数
flatMapLatest 仅仅执行最新的信号，当新的信号来到时候，取消上次未执行完的整个序列

最直接的列子就是搜索，通常我们想要

用户用一段时间没有输入的时候，再进行网络请求，不然网络请求太频繁，对客户端和服务器都是负担
当新的请求来的时候，如果上一个未完成，则取消上一个
如果网络失败，能重新请求几次就更好了

let searchResults = searchBar.rx_text
    .throttle(0.3, scheduler: MainScheduler.instance)
    .distinctUntilChanged()
    .flatMapLatest { query -> Observable<[Repository]> in
        if query.isEmpty {
            return Observable.just([])
        }

        return doSearchAPI(query).retry(3)
            .catchErrorJustReturn([])

    }
    .observeOn(MainScheduler.instance)

简单的理解

.throttle(0.3, scheduler: MainScheduler.instance) 保证用户没有输入0.3秒后再进行下一步。
distinctUntilChanged() 加入0.3秒之前输入的是ab，0.3秒后输入的还是ab，则不会进行下一步，只有改变了才会进行下一步。
faltMapLatest 保证值搜索最新的，如果之前的没有完成，会被自动取消
doSearchAPI(query).retry(3) 保证，如果发生错误，自动重试3次

Schedulers

Schedulers 抽象化了线程，线程池，GCD中的操作队列，Runloop等概念。可以理解为，Schedulers就是一个执行任务的线程。
默认一个Observable在其创建的线程上执行

与Schedulers相关的操作符有两个

observeOn(scheduler) 在一个scheduler上执行任务，使用场景较多。
subscribeOn(scheduler) 在一个scheduler进行监听

sequence1
    .observeOn(backgroundScheduler)
    .map { n in
        print("This is performed on the background scheduler")
    }
    .observeOn(MainScheduler.instance)
    .map { n in 
        print("This is performed on the main scheduler")
    }
    .subscribeOn(backgroundScheduler)
    .subscribeNext{ n in
        print("This is performed on the background scheduler")
    }

默认一个subscribeNext或者subscribe在其调用的线程上执行

Serial/Concurrent Schedulers 串行或并行

和GCD的队列相似，并行的Schedulers的任务可以并发执行，串行Schedulers只能依次执行。不过RxSwift有内部机制，保证上文提到的信号处理顺序

RxSwift内置的Scheduler

CurrentThreadScheduler (串行)当前线程Schdeduler,默认使用的
MainScheduler (串行)主线程
SerialDispatchQueueScheduler 封装了GCD的串行队列
ConcurrentDispatchQueueScheduler 封装了GCD的并行队列，这个在后台有任务要执行的时候很有用
OperationQueueScheduler 封装了NSOpera

Variable

Variable 表示一个可以监听的数据结构。使用Variable，你可以监听数据的变化，也可以把其他值绑定到它身上。
当Variable被释放的时候，他会向监听者发送onCompleted

class VariableController: UIViewController {

    @IBOutlet weak var label: UILable!
    var timer: NSTimer?
    var count = Variable(0)

    override func viewDidLoad() {
        super.viewDidLoad()
        timer = NSTimer.sheduledTimerWithTimeInterval(1.0, target: self, selector:#selector(VariableController.updateValue), userInfo: nil, repeats: true)

        _ = count.asObservable().subscribeNext { (num) in
            self.lable?.text = "VariableValue: \(num)"
        }
    }

    func updateValue() {
        count.value = count.value + 1
    }

    override func viewDidDisappear(animated: Bool) {
        super.viewDidDisappear(animated)

        timer?.invalidate()
    }

}

数据绑定

数据的绑定是开发的时候很常见的，比如根据文本的输入动态调整textfield的背景色，动态的调整按钮的enable。亦或者根据
textfield的输入变化，动态的去反馈到model层。如果你听过MVVM，那你肯定知道，MVVM的难点就是ViewModel与View的数据绑定问题。
不过，使用RxSwift，数据绑定变的十分容易，你甚至可以绑定到tableview和collectionView上去。

bindTo 随着Switch的开关，view进行显示/隐藏

只需要一行代码

_ = mySwitch.rx_value.bindTo(testView.rx_hidden)

根据输入，进行view状态绑定

let nameObserable = nameTextField.rx_text.shareReplay(1).map({$0.charactors.count >= 6})
let pwdObserable = passwordTextField.rx_text.shareReplay(1).map({$0.charactors.count >= 8})

_ = nameObserable.subscribeNext({ (valid) in
  self.nameTextFiledColor = valid ? UIColor.clearColor() : UIColor.lightGrayColor()
}).addDisposableTo(disposeBag)

_ = pwdObserable.subscribeNext({ (valid) in
  self.passwordTextfield.backgroundColor = valid ? UIColor.clearColor() : UIColor.lightGrayColor()
}).addDisposableTo(disposeBag) // addDisposableTo(disposeBag)是为了自动释放

_ = Observable.combinLatest(nameObserable, pwdObserable) {$0 && $1}.subscribeNext({valid in

        if valid {
            self.registerButton.enabled = true
            self.registerButton.backgroundColor = UIColor.redColor()
        } else {
            self.registerButton.enable = false
            self.registerButton.backgroundColor = UIColor.darkGrayColor()
        }
    }) . addDisposableTo(disposeBag)

    _ = registerButton.rx_tap.shareReplay(1).subcribeNext {
        print("Button tapped")
    }

共享监听Sharing subscription - `shareReplay`

这个是很常用的，比如一个Obserable用作网络请求，通常，当你这样调用的时候，会创建两个序列，
也就是会进行两次网络请求，这是不需要的

let network = networkWithText(text)

let subscription1 = nerwork
    .subscribeNext { n in
        // 创建第一个序列
    }

let subscription2 = network
    .subscribeNext {
        // 创建第二个序列
    }

为了共享一个序列，你只需要这样调用

let network = networkWithText(text).shareReplay(1)

就只会进行一次网络请求，两个subscription共享结果，也就是shareReplay的意思

自定义可绑定属性

上文，textfield和button的状态绑定是手动的，这无疑是不方便的。RxSwift为我们提供了一种方式，来自定义可绑定属性

创建两个extension

extenstion UITextField {
   var ex_validState: AnyObserver<Bool> {
      return UIBindingObserver(UIElement: self) { textfield,valid in
            textfield.backgroundColor = valid ? UIColor.clearColor() : UIColor.lightGrayColor()
      } .asObserver()
   }
}

extension UIButton {
   var ex_validState: AnyObserver<Bool> {
      return UIBindingObserver(UIElement: self) { button, valid in
         button.enabled = valid
         button.backgroundColor = valid ? UIColor.redColor() : UIColro.darkGrayColor()
      } .asObserver()
   }
}

然后，上文的代码，就可以简化成三行了

_ = nameObserable.bindTo(nameTextField.ex_validState) .addDisposableTo(disposeBag)
_ = pwdObserable.bindTo(passwordTextField.ex_validState) .addDisposableTo(disposeBag)
_ = Observable.combineLatest(nameObservable, pwdObservable) {$0 && $1} .bindTo(registerButton.ex_validState).addDisposableTo(disposeBag)

Driver

Driver是RxSwift精心制作的，专门提供给UI层的一个接口。

利用Driver你可以

利用CoreData的模型来驱动UI
利用UI的状态来绑定其他UI的状态

Driver能够保证，在主线程上监听，因为UIKit不是需要在主线程上操作

RxSwift中做数据绑定有三种

利用BindTo方法
利用Driver（强烈建议使用这个）
利用KVO来手动绑定（很少用到）

对于搜索，我们可以这么做

let results = query.rx_text
   .throttle(0.3, scheduler: MainScheduler.instance) // 延迟0.3秒
   .flatMapLatest { query in // 永远只执行最新的
      searchWithText(query)
   }

results
   .map { "\($0.count)" }
   .bindTo(resultCount.rx_text) // 绑定lable
   .addDisposableTo(diposeBag)

results
   .bindTo(resultsTableView.rx_itemsWithCellIdentifier("cell") { (_, result, cell) in // 绑定tableview
      cell.textLable?.text = "\(result)"
   }
   .addDisposableTo(disposeBag)

那么，这有什么缺陷呢？

假如searchWithText失败了，那么整个序列就断掉了，后面的绑定不会有任何作用
假如searchWithText是后台线程执行的，那么后续绑定是在后台线程上进行的，会崩溃
绑定了两次，意味着会执行两次

let results = query.rx_text.
   .throttle(0.3, scheduler: MainScheduler.instance)
   .flatMapLatest { query in
      fetchAutoCompleteItems(query)
         .observeOn(MainScheduler.instance) // 保证在主线程
         .catchErrorJustReturn([]) // 发生错误，返回空数组
   }
   .shareRepaly(1) // 共享监听，保证只执行一次

results
   .map { "\($0.count)" }
   .bindTo(resultCount.rx_text)
   .addDisposableTo(disposeBag)

results
   .bindTo(resultTableView.rx_itemsWithCellIdentifier("Cell")) { (_, resutl, cell) in
      cell.textLabel?.text = "\(result)"
   }
   .addDisposableTo(disposeBag)

利用Driver我们可以将上述过程简化

let resutls = query.rx_text.asDriver()    // 转换成Driver序列
   .throttle(0.3, scheduler: MainScheduler.instance)
   .flatMapLatest { query in
      fetchAutoComplete(query)
         .asDriver(onErrorJustReturn: []) // 告诉Driver发生错误怎么办
   }

results
   .map { "\($0.count)" }
   .drive(resultCount.rx_rext)  // 用Driver绑定，不需要切换到主线程
   .addDisposableTo(disposeBag) 

results
   .drive(resultTableView.rx_itemsWithCellIdentifier("Cell")) { (_, result, cell) in
      cell.textLabel?.text = "\(result)"
   }
   .addDisposableTo(disposeBag)

任何满足以下三个条件的Observer序列都可以转换为Driver

不会因为错误就序列断掉（比如，有错误，但是没有调用onError来发送错误）
在主线程傻姑娘？监听
共享 side effects

对于使用者，只需要调用asDriver(onErrorJustReturn: []) 就能保证上述三点都实现了

KVO

通常的KVO，你需要在这个函数里来处理

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context

而使用RxSwift, KVO变成了这样

view.rx_observe(CGRect.self, "frame")
      .subscribeNext { frame in
         print("Got new frame \(frame)")
      }

或者这样

someSuspicionsViewController
   .rx_observeWeakly(Bool.self, "behavingOk")
   .subscribeNext { behavingOk in
      print("Cates can purr? \(behavingOk)")
   }

二者的区别是

在rx_observe可以使用的地方都可以使用rx_observeWeakly。rx_observeWeakly的执行效率要低一些，因为要处理对象的dealloc关系。除此之外，rx_observeWeakly还可以用在weak属性上。

Notification

使用RxSwift, Notification变的十分简洁

NotificationCenter.defaultCenter()
   .rx_notification(UITextViewTextDidBeginEditingNotification, object: myTextView)
   .map { /* do something with data */ }
   ....

DEBUG

swift是一个强类型语言，能够在绝大部分场景自动推断出变量的类型。比如：

let a = 10 //Int

但是，有时候RxSwift的序列处理会报编译错误，比如：

images = word
   .filter { $0.containsString("important") }
   .flatMap { word in
      return self.api.loadFlickrFeed("karate")
         .catchError { error in
            return just(JSON(1))
         }
   }