标签：
RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发，维护。
RxSwift的目的是让让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程
目前，RxSwift在Github上收到了5000+Star，600+fork。
本文的目的
如果你有时间，建议先读读RxSwift的文档，这会给你一个最基本的认识
本文不会讲解函数式编程，也不会讲解函数响应式编程的概念，计划后面单独出一篇博客来讲解Swift与函数式编程。
本文来自于官方文档的翻译，官方example代码的阅读，以及自己的理解
老一点的iOS开发者应该对ReativeCocoa有一些了解，iOS响应式编程的鼻祖。就个人来看
So，个人是非常推荐RxSwift的
先复习下SequenceType。这是Swift中的一个协议，比如Swift中的Array就遵循这个协议，通过这个协议，你可以这样的去操作一个Array
let array = [1,2,3,4,5]
let array2 = array.filter({$0 > 1}).map({$0 * 2})//4 6 8 10
var indexGenerator = array2.generate()
let fisrt = indexGenerator.next() // 4
let seoncd = indexGenerator.next() //6也就是说，把Array作为一个序列，然后依次对这个序列进行过滤，映射等操作,也可以通过indexGenerator来一个个的获取序列中的数据。
RxSwift的核心思想和这个类似。
RxSwift的核心是想是 Observable<Element> sequence，Observable表示可监听或者可观察，也就是说RxSwift的核心思想是可监听的序列。并且，Observable sequence可以接受异步信号，也就是说，信号是可以异步给监听者的
ObservableType.subscribe，这和indexGenerator.next()类似本文把RxSwift中的序列的每一个Element成为信号,因为异步的Element是与时间相关的，称作信号更好理解一点
RxSwift中，ObservableType.subscribe的回调（新的信号到来）一共有三种
enum Event<Element> {
case Next(Element) // 新的信号到来
case Error(ErrorType) // 信号发生错误，序列不会再产生信号
case Completed // 序列发送信号完成，不会再产生新的信号
}
protocol ObserverType {
func on(event: Event<Element>) ／／监听所有的信号
}
Observable分为两种
addDisposableTo(disposeBag)来让其在deinit，也就是所有者要释放的时候，自动取消监听。class Observable<Element> {
func subscribe(observer: Observer<Element>) -> Disposable //调用Disposable的方法来取消
}
当然，除了手动释放，RxSwift提供了一些操作符，比如 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我们监听textfield的文字变化，然后，Log出text，当button点击的时候，取消这次监听
class ObservableAndCancelController : UIViewController{
var subscription:Disposable?
@IBOutlet weak var textfield: UITextField!
@IBAction func cancelObserve(sender: AnyObject) {
subscription?.dispose()
}
override func viewDidLoad() {
super.viewDidLoad()
subscription = textfield.rx_text.subscribeNext { (text) in
print(text)
}
}
}RxSwift用extensiton的方式，为UITextfield,UIlabel等控件添加了很多可监听的属性，这里的textfield.rx_text就是一个
效果：随着文字输入，实时Log出textfield的文字，当点击button之后，再输入，则不会Log
在上文的第一个例子里面，你看到了监听信号，并且log出值。事实上，这样直接处理信号的时候是很少的，很多时候，我们需要对信号进行映射，过滤，这时候我们就要用到操作符了。在这个文档里，你可以找到所有的操作符。
关于操作符效果，你可以参见http://rxmarbles.com/的可视化效果，这会给你一个更好的理解
例子二，map,filter,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类型，然后打印出来。
所以，当我在fistTextfield中，输入1234，然后secondTextfield中依次输入abcdefg的时候
combineLatest:("first1234abcd", 13)
combineLatest:("first1234abcd3", 14)
combineLatest:("first1234abcd", 13)
combineLatest:("first1234abcde", 14)
combineLatest:("first1234abcdef", 15)
combineLatest:("first1234abcdefg", 16)例子三，创建一个Observable
Observerable可以用来处理任务，并且异步返回Event信号（Next,Error,Completion）
比如，这样一个方法
//Observable就是处理输入，并且把description发送出去
func createObserveable(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用来取消信号
最直接的例子就是搜索，通常我们想要
这时候，用RxSwift你得代码会变的非常简单
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,则不会进行下一步，只有改变了才会进行下一步flatMapLatest 保证只搜索最新的，如果之前的没有完成，会被自动取消doSearchAPI(query).retry(3) 保证，如果发生错误，自动重试3次Schedulers 抽象化了线程，线程池，GCD中操作队列，Runloop等概念。可以理解为，Schedulers就是一个执行任务的线程。
有一点要注意：默认一个Observerable在其创建的线程上执行
与Schedulers相关的操作符有两个
比如
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在其调用的线程上执行
和GCD的队列很相似，并行Schedulers的任务可以并发之行，串行Schedulers只能依次之行。不过RxSwift有内部机制，保证上文提到的信号处理的顺序
通常，使用内置的Scheduler足矣。
CurrentThreadScheduler(串行) 当前线程Scheduler，默认使用的MainScheduler(串行) 主线程SerialDispatchQueueScheduler 封装了GCD的串行队列ConcurrentDispatchQueueScheduler 封装了GCD的并行队列，这个在有任务要在后台执行的时候很有用OperationQueueScheduler 封装了NSOperationQueue例子四，在后台Scheduler之行任务，然后在主线程上更新UI
Variable表示一个可监听的数据结构。使用Variable，你可以监听数据的变化，也可以把其他值绑定到它身上。
当Variable被释放的时候，它会向监听者发送onCompleted
例子五，Variable进行监听
class VariableController: UIViewController {
@IBOutlet weak var label: UILabel!
var timer:NSTimer?
var count = Variable(0)
override func viewDidLoad() {
super.viewDidLoad()
timer = NSTimer.scheduledTimerWithTimeInterval(1.0, target: self, selector:#selector(VariableController.updateValue) , userInfo: nil, repeats: true)
_ = count.asObservable().subscribeNext { (num) in
self.label?.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.characters.count >= 6})
let pwdObserable = passwordTextfield.rx_text.shareReplay(1).map({$0.characters.count >= 8})
_ = nameObserable.subscribeNext({ (valid) in
self.nameTextfield.backgroundColor = valid ? UIColor.clearColor():UIColor.lightGrayColor()
}).addDisposableTo(disposeBag)
_ = pwdObserable.subscribeNext({ (valid) in
self.passwordTextfield.backgroundColor = valid ? UIColor.clearColor(): UIColor.lightGrayColor()
}).addDisposableTo(disposeBag)//addDisposableTo(disposeBag)是为了自动释放
_ = Observable.combineLatest(nameObserable, pwdObserable) {$0 && $1}.subscribeNext({valid in
if valid{
self.registerButton.enabled = true
self.registerButton.backgroundColor = UIColor.redColor()
}else{
self.registerButton.enabled = false
self.registerButton.backgroundColor = UIColor.darkGrayColor()
}
}).addDisposableTo(disposeBag)
_ = registerButton.rx_tap.shareReplay(1).subscribeNext {
print("Button tapped")
}shareReplay这个是很常用的，比如一个Obserable用做网络请求，通常，当你这样调用的时候，会创建两个序列，也就是会进行两次网络请求，这是不需要的
let network = networkWithText(text)
let subscription1 = network
.subscribeNext { n in
//创建第一个序列
}
let subscription2 = network
.subscribeNext { n in
//创建第二个序列
}为了共享一个序列，你只需要这这样调用
let network = networkWithText(text).shareReplay(1)就只会进行一次网络请求，两个subscription共享结果，也就是shareReplay的意思
上文，textfield和button的状态绑定是手动的，这无疑是不方便的。RxSwift为我们提供了一种方式，来自定义可绑定属性
创建两个exetnsion
extension 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() : UIColor.darkGrayColor()
}.asObserver()
}
}然后，上文的代码，就可以简化成三行了，So easy
_ = nameObserable.bindTo(nameTextfield.ex_validState).addDisposableTo(disposeBag)
_ = pwdObserable.bindTo(passwordTextfield.ex_validState).addDisposableTo(disposeBag)
_ = Observable.combineLatest(nameObserable, pwdObserable) {$0 && $1}.bindTo(registerButton.ex_validState).addDisposableTo(disposeBag)Driver是RxSwift精心制作的，专门提供给UI层的一个接口。
利用Driver你可以
Driver能够保证，在主线程上监听，因为UIKit不是需要在主线程上操作
Tips:
RxSwift中做数据绑定有三种
回到Driver上来，上文提到了，对于搜索，我们可以这么做，
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)//绑定label
.addDisposableTo(disposeBag)
results
.bindTo(resultsTableView.rx_itemsWithCellIdentifier("Cell")) { (_, result, cell) in //绑定tableview
cell.textLabel?.text = "\(result)"
}
.addDisposableTo(disposeBag)
那么，这有什么缺陷呢？
于是，我们需要进行额外的操作，来避免上述缺陷。
let results = query.rx_text
.throttle(0.3, scheduler: MainScheduler.instance)
.flatMapLatest { query in
fetchAutoCompleteItems(query)
.observeOn(MainScheduler.instance) // 保证在主线程（解决缺陷1）
.catchErrorJustReturn([]) // 发生错误，返回空数组（解决缺陷2）
}
.shareReplay(1) // 共享监听，保证只执行一次（解决缺陷3）
results
.map { "\($0.count)" }
.bindTo(resultCount.rx_text)
.addDisposableTo(disposeBag)
results
.bindTo(resultTableView.rx_itemsWithCellIdentifier("Cell")) { (_, result, cell) in
cell.textLabel?.text = "\(result)"
}
.addDisposableTo(disposeBag)利用Driver我们可以将上述过程简化
let results = query.rx_text.asDriver() // 转换成Driver序列
.throttle(0.3, scheduler: MainScheduler.instance)
.flatMapLatest { query in
fetchAutoCompleteItems(query)
.asDriver(onErrorJustReturn: []) // 告诉Driver发生错误怎么办
}
results
.map { "\($0.count)" }
.drive(resultCount.rx_text) // 用Driver绑定，不需要切换到主线程
.addDisposableTo(disposeBag)
results
.drive(resultTableView.rx_itemsWithCellIdentifier("Cell")) { (_, result, cell) in
cell.textLabel?.text = "\(result)"
}
.addDisposableTo(disposeBag)任何满足以下三个条件的Observer序列都可以转换为Driver
对于，使用者只需要调用asDriver(onErrorJustReturn: [])就能保证上述三点都实现了
通常的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)")
}或者这样
someSuspiciousViewController
.rx_observeWeakly(Bool.self, "behavingOk")
.subscribeNext { behavingOk in
print("Cats can purr? \(behavingOk)")
}二者的区别是
在rx_observe可以使用地方都可以使用rx_observeWeakly。rx_observeWeakly的执行效率要低一点，因为要处理对象的dealloc关系。除此之外，rx_observeWeakly还可以用在weak属性上。
在使用view.rx_observe的时候，有几点要注意
由于KVO是建立在NSObject子类的基础上的，你可以通过如下方法，来让Structs支持KVO
使用RxSwift，Notification变的十分简洁
NSNotificationCenter.defaultCenter()
.rx_notification(UITextViewTextDidBeginEditingNotification, object: myTextView)
.map { /*do something with data*/ }
....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))
}
}如果，Swift没办法推断出类型，那么最直接的方式，就是显式的告诉Swift类型是什么
images = word
.filter { (s: String) -> Bool in s.containsString("important") } //输入是 string ,返回Bool
.flatMap { (word: String) -> Observable<JSON> in
return self.api.loadFlickrFeed("karate")
.catchError { (error: NSError) -> Observable<JSON> in
return just(JSON(1))
}
}使用Debug操作符，会log所有的数据流
let subscription = myInterval(0.1)
.debug("my probe")
.map { e in
return "This is simply \(e)"
}
.subscribeNext { n in
print(n)
}
NSThread.sleepForTimeInterval(0.5)
subscription.dispose(你可以用自定义操作符的方式，来Log
extension ObservableType {
public func myDebug(identifier: String) -> Observable<Self.E> {
return Observable.create { observer in
print("subscribed \(identifier)")
let subscription = self.subscribe { e in
print("event \(identifier) \(e)")
switch e {
case .Next(let value):
observer.on(.Next(value))
case .Error(let error):
observer.on(.Error(error))
case .Completed:
observer.on(.Completed)
}
}
return AnonymousDisposable {
print("disposing \(identifier)")
subscription.dispose()
}
}
}
}
RxSwift通过RxSwift.resourceCount记录资源分配情况，所以通常的调试方式如下
/* 在AppDelegate方法中添加Log
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool
*/
_ = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
.subscribeNext { _ in
print("Resource count \(RxSwift.resourceCount)")
}然后
标签：
原文地址：http://blog.csdn.net/hello_hwc/article/details/51859330
