RxSwift使用教程

最新推荐文章于 2024-09-07 09:14:23 发布
最新推荐文章于 2024-09-07 09:14:23 发布
阅读量1k 收藏
点赞数
文章标签： RxSwift Swift Reactive Cocoa iOS
本文介绍了RxSwift的核心思想、基础使用及优点。RxSwift是一种用于Swift的响应式编程框架，可方便地处理数据流和异步任务。文章还提供了多个实际示例，包括创建Observable、数据绑定等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转自: http://blog.youkuaiyun.com/Hello_Hwc/article/details/51859330


前言

RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发，维护。

RxSwift的目的是让让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程

目前，RxSwift在Github上收到了5000+Star，600+fork。

本文的目的

  • 介绍RxSwift的核心思想
  • 讲解RxSwift的基础使用
  • 介绍RxSwift的优点

如果你有时间，建议先读读RxSwift的文档，这会给你一个最基本的认识

本文不会讲解函数式编程，也不会讲解函数响应式编程的概念，计划后面单独出一篇博客来讲解Swift与函数式编程。

本文来自于官方文档的翻译，官方example代码的阅读，以及自己的理解

RxSwift和ReativeCocoa

老一点的iOS开发者应该对ReativeCocoa有一些了解，iOS响应式编程的鼻祖。就个人来看

  • ReativeCocoa更适合OC，缺点语法复杂，概念繁多，参考资料少（尤其RAC4），不易理解
  • RxSwift对Swift的兼容很好，利用了很多的Swift特性，语法简单，概念清楚

So，个人是非常推荐RxSwift的

Observables/Sequences

先复习下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
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
  • 1
  • 2
  • 3
  • 4
  • 5

也就是说，把Array作为一个序列，然后依次对这个序列进行过滤，映射等操作,也可以通过indexGenerator来一个个的获取序列中的数据。

RxSwift的核心思想和这个类似。

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

  • Observable(ObservableType) 和 SequenceType类似
  • ObservableType.subscribe 和 SequenceType.generate类似
  • 由于RxSwift支持异步获得信号，所以用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>) ／／监听所有的信号
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

取消监听

Observable分为两种

  1. 在有限的时间内会自动结束（Completed/Error）,比如一个网络请求当作一个序列，当网络请求完成的时候，Observable自动结束，资源会被释放
  2. 信号不会自己结束，最简单的比如一个Timer，每隔一段时间发送一个新的信号过来，这时候需要手动取消监听，来释放相应的资源,又比如一个label.rac_text是一个Obserable，通常需要这样调用addDisposableTo(disposeBag)来让其在deinit，也就是所有者要释放的时候，自动取消监听。
class Observable<Element> {
    func subscribe(observer: Observer<Element>) -> Disposable //调用Disposable的方法来取消
}

 
  • 1
  • 2
  • 3
  • 4

 
  • 1
  • 2
  • 3
  • 4

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

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

 
  • 1
  • 2
  • 3
  • 4
  • 5

信号处理的顺序

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

比如

someObservable
  .subscribe { (e: Event<Element>) in
      print("Event processing started")
      // processing
      print("Event processing ended")
  }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

只会出现

Event processing started
Event processing ended
Event processing started
Event processing ended
Event processing started
Event processing ended
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

不会出现

Event processing started
Event processing started
Event processing ended
Event processing ended
 
  • 1
  • 2
  • 3
  • 4

 
  • 1
  • 2
  • 3
  • 4

第一个例子

我们监听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)
        }
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

RxSwift用extensiton的方式，为UITextfield,UIlabel等控件添加了很多可监听的属性，这里的textfield.rx_text就是一个

效果：随着文字输入，实时Log出textfield的文字，当点击button之后，再输入，则不会Log

操作符(Operators)

在上文的第一个例子里面，你看到了监听信号，并且log出值。事实上，这样直接处理信号的时候是很少的，很多时候，我们需要对信号进行映射，过滤，这时候我们就要用到操作符了。在这个文档里，你可以找到所有的操作符。

关于操作符效果，你可以参见http://rxmarbles.com/的可视化效果，这会给你一个更好的理解

例子二，map,filter,combineLatest

  • 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)")
      }        
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
  • 1
  • 2
  • 3
  • 4
  • 5

对于，每一个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)
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

例子三，创建一个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
    })
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

这样调用

_ = createObserveable(test).subscribe({ (event) in
      switch event{
      case .Next(let value):
          print(value)
      case .Completed:
          print("Completed")
      case .Error(let error):
          print(error)
      }
  })
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

然后，Log如下

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

 
  • 1
  • 2

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

throttle/retry/distinctUntilChanged/flatMapLatest

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

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

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

这时候，用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)
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

这里简单讲解下作用

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

Schedulers

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

有一点要注意：默认一个Observerable在其创建的线程上执行

与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")
  }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

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

Serial/Concurrent Schedulers 串行或并行

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

RxSwift内置的Scheduler

通常，使用内置的Scheduler足矣。

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

例子四，在后台Scheduler之行任务，然后在主线程上更新UI

Variable

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()
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

数据绑定

数据绑定是开发的时候很常见的，比如根据文本的输入动态调整textfield的背景色，动态调整按钮的enable。亦或者根据textfield的输入变化，动态的去反馈到model层。如果你听过MVVM，那你肯定知道，MVVM的难点就是ViewModel与View的数据绑定问题。

不过，使用RxSwift，数据绑定变的十分容易，你甚至可以把数据绑定到tableview和collectionView上去。

例子六，bindTo 
很简单，随着Switch的开关，view进行显示/隐藏

 
只需要一行代码

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

 
  • 1

例子七，根据输入，进行View状态绑定

我们想要实现这样的状态

  • 用户名至少6位，小于6位，则背景色是灰色，合法则透明
  • 密码至少位8位，小于8位，则背景色是灰色，合法则透明
  • 当用户名和密码都合法的时候，注册按钮enable，并且背景色变红

信号的处理方式如下，

        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")
        }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

共享监听Sharing subscription－shareReplay

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

let network = networkWithText(text)
let subscription1 = network
    .subscribeNext { n in
       //创建第一个序列
    }
let subscription2 = network
    .subscribeNext { n in
       //创建第二个序列
    }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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

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

 
  • 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()
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

然后，上文的代码，就可以简化成三行了，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)
 
  • 1
  • 2
  • 3
  • 4

 
  • 1
  • 2
  • 3
  • 4

Driver

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

利用Driver你可以

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

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


Tips: 
RxSwift中做数据绑定有三种

  1. 利用BindTo方法
  2. 利用Driver(强烈建议使用这个，)
  3. 利用KVO来手动绑定（很少用到）

回到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)

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

那么，这有什么缺陷呢？ 

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

于是，我们需要进行额外的操作，来避免上述缺陷。

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)
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

利用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)
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

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

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

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

KVO

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

-(void)observeValueForKeyPath:(NSString *)keyPath
                     ofObject:(id)object
                       change:(NSDictionary *)change
                      context:(void *)context
 
  • 1
  • 2
  • 3
  • 4

 
  • 1
  • 2
  • 3
  • 4

而使用RxSwift,KVO变成了这样

view.rx_observe(CGRect.self, "frame")
    .subscribeNext { frame in
        print("Got new frame \(frame)")
    }
 
  • 1
  • 2
  • 3
  • 4

 
  • 1
  • 2
  • 3
  • 4

或者这样

someSuspiciousViewController
    .rx_observeWeakly(Bool.self, "behavingOk")
    .subscribeNext { behavingOk in
        print("Cats can purr? \(behavingOk)")
    }
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
  • 1
  • 2
  • 3
  • 4
  • 5

二者的区别是

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

在使用view.rx_observe的时候，有几点要注意

由于KVO是建立在NSObject子类的基础上的，你可以通过如下方法，来让Structs支持KVO

Notification

使用RxSwift，Notification变的十分简洁

NSNotificationCenter.defaultCenter()
    .rx_notification(UITextViewTextDidBeginEditingNotification, object: myTextView)
    .map { /*do something with data*/ }
    ....
 
  • 1
  • 2
  • 3
  • 4

 
  • 1
  • 2
  • 3
  • 4

DEBUG

调试编译问题

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

let  a = 10 //Int
 
  • 1

 
  • 1

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

images = word
    .filter { $0.containsString("important") }
    .flatMap { word in
        return self.api.loadFlickrFeed("karate")
            .catchError { error in
                return just(JSON(1))
            }
      }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

如果，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))
            }
      }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

调试

使用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(
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

你可以用自定义操作符的方式，来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()
            }
        }
    }
 }

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

调试内存泄漏问题

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)")
    }
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

然后

  1. 进入相关界面，进行正常操作
  2. 退出界面
  3. 观察RxSwift.resourceCount
  4. 在进入同一个界面，退出
  5. 观察RxSwift.resourceCount

使用心得

  1. 时刻牢记，使用RxSwift，尽量把所有的任务（可以理解为方法）抽象成Obserable（序列）和Obserable创建者，监听者
  2. 能用数据绑定的（bindTo和Driver）的就不要手动绑定
  3. 一定要熟练RxSwift提供的操作符，要会自定义操作符

RxSwift的优点

  • Composable 可组合，在设计模式中有一种模式叫做组合模式，你可以方便的用不同的组合实现不同的类
  • Reusable 代码可重用，原因很简单，对应RxSwift，就是一堆Obserable
  • Declarative 响应式的，因为状态不可变，只有数据变化
  • Understandable and concise 简洁，容易理解。
  • Stable 稳定，因为RxSwift写出的代码，单元测试时分方便
  • Less stateful “无”状态性，因为对于响应式编程，你的应用程序就是一堆数据流
  • Without leaks 没有泄漏，因为资源管理非常简单

user-wang
关注
RxSwift学习教程之基础篇
08-29
通过使用 RxSwift，你可以将复杂的异步逻辑转化为简洁、可测试的代码，同时保持代码的整洁和模块化。 例如，你可能会用 RxSwift 来实现一个按钮点击触发的网络请求，更新 UI 并处理错误： ```swift let button = ...
初识RxSwift及使用教程
iOS开发by韩俊强
08-01 725
什么是RxSwift？RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发、维护其他语言像C#, Java 和 js 也有，Rx.NET、RxJava、RxJSRxSwift的目的是让让数据/事件流和异步任务能够更方便的序列化处理，能够使用swift进行响应式编程函数式响应编程?RxSwift做了什么?观察者模式什么KVO，通知, 甚至代理都是观察者模式
RxSwift使用教程大全 韩俊强的博客
weixin_34343308的博客
08-03 218
接上一篇:初识RxSwift及使用教程 韩俊强的博客 本文档内容来自于 RxSwift 的 Playground。记录大多数 ReactiveX 的概念和操作符。 (部分翻译和注解来自 ReactiveX文档中文翻译) Introduction 为什么使用 RxSwift? 我们写的很多代码实际上是为了解决和响应外部事件。当用户操作一个控件的时候...
RxSwift 使用方式
ZhaiAlan的博客
07-12 1133
最近项目业务，所有模块已经支持Swift混编开发，正在逐步使用Swift 方式进行开发新业务，以及逐步替换老业务方式进行发展，所以使用一些较为成熟的Swift 的三方库，成为必要性，经过调研发现RxSwift 在使用的情况上，较为成熟，且方便实用；以下介绍一些RxSwift 使用的一些方式和大家一起学习讨论。Swift为值类型，在传值与方法回调上有影响，RxSwift一定程度上弥补Swift的灵活性。
[Swift]RxSwift常见用法详解
Gamin
12-01 4858
RxSwift 是 ReactiveX API 的 Swift 版。它是一个基于 Swift 事件驱动的库，用于处理异步和基于事件的代码。
RxSwift学习教程之类型对象Subject详解
08-29
理解并熟练使用这四种Subject，可以帮助开发者更好地控制和管理RxSwift中的数据流，从而构建出更加灵活和响应式的应用程序。在实际开发中，根据需求选择合适的Subject类型至关重要，以确保数据的正确传递和处理。
RxSwift使用技巧之过滤操作详解
08-29
在RxSwift中，过滤操作是响应式编程中非常关键的一部分，它允许我们根据特定条件对数据流进行筛选，从而在处理事件或数据时减少不必要的计算和处理。在本文中，我们将深入探讨RxSwift中几种主要的过滤操作，包括`...
RxSwift-Tutorial:RxSwift 学习资料(学习教程、开源项目)
05-18
RxSwift系统教程播客 RxSwift的学习资料清单 RxSwift学习之旅 RxSwift: Transforming Operators in Practice RxSwift: Transforming Operators Raywenderlich RxSwift Reactive Programming with Swift RxSwift 开源...
RxSwift 教程
gitblog_00430的博客
09-02 413
RxSwift 教程 项目介绍 RxSwift 是一个在 Swift 语言中实现响应式编程的框架。它允许开发者以一种更加简洁和直观的方式处理异步数据流和事件。RxSwift 是 ReactiveX (Rx) 家族的一部分，该家族包括多种编程语言的实现。 项目快速启动 安装 RxSwift 首先，确保你的项目已经创建并打开在 Xcode 中。然后，通过 CocoaPods 安装 RxSwift： #...
RxSwift:RxSwift从入门到放弃，Swift+RxSwift， RxSwift入门教程
05-01
RxSwift 从前段时间开始接触RxSwift，跟着网上教程一点点的敲一些基础代码，慢慢地接触到越来越深的知识点，记录在此。 运行截图 002 003 004 005 006 007 008 009 学习RxSwift这条路还有很长，代码也会越写越长，与全部热爱学习的伙伴共勉。
RXSwift教程iOS Mac OS中使用RX函数式编程最新版本1.1
09-02
RXSwift教程，iOS，Mac OS中使用RX函数式编程，最新版本1.1版，非常好的教程。
RxSwift学习（五）--- RxSwift 操作符
～玉麒麟～
12-30 852
RxSwift学习（一）— RxSwift介绍 RxSwift学习（二）— Observable 常见的序列创建方法 RxSwift学习（三）— RxSwift 高阶函数 RxSwift学习（四）— RxSwift 操作符
RxSwift入门教程（一）
HaKimK
12-29 1267
Getting Started(This project tries to be consistent with ReactiveX.io.The general cross platform documentation and tutorials should also be valid in case of Rxswift.) *Observables aka Sequences *Disp
RxSwift教程 （warnings）
HaKimK
12-26 408
Warnings（Unused disposable。The following is valid for the subscribe*, bind* and drive* family of functions that return Disposable.You will receive a warning for doing something such as this:） let xs:
RxSwift教程（1）：Observable
kmyhy的专栏
12-22 1046
概念 Observable 等同于 RAC 中的信号 RACSignal。它会发送 3 种事件： next completed error 事件 Event 是一种特殊的枚举，包含了上述 3 个值，其中 next 和 error 事件都会带一个参数，但 completed 事件没有参数： public enum Event<Element> { case next(Elem...
RXswif的使用
lingjunjie的博客
03-14 519
RxSwift的一些基础使用方法整理
【亲测免费】 RxSwift 中文文档教程
最新发布
gitblog_00968的博客
09-07 483
RxSwift 中文文档教程 1. 项目介绍 RxSwift 中文文档 是一个非官方的 RxSwift 资源库，旨在帮助开发者迅速掌握响应式编程在 Swift 环境下的应用。此项目综合了 RxSwift 正式文档、RxJS 以及 ReactiveX 的核心概念，并融入作者的见解，提供一系列详细指南和实例，适应从入门到进阶的所有学习阶段。文档不仅覆盖基础理论，还深入到实际的编码实践，是学习响应式编程...
RxSwift學習教程之基礎篇
diaoju3333的博客
05-09 101
前言 我們在 iOS 開發過程中，幾乎無時無刻都要面對異步事件的處理。例如，按鍵點擊、數據保存、、音頻後臺播放、交互動畫展示。這些事件並不具備特定時序性，甚至它們可能同時發生。 雖然 Apple 提供了通知、代理、GCD、閉包等異步機制，但是這些機制缺乏一個統一的抽象表述。另外，這些機制在處理共享的可變數據或狀態時不夠清晰簡練。當然，這並不是說編寫優雅的異步代碼不現實。畢竟與其他平臺...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值