RxSwift:操作符

最新推荐文章于 2023-12-01 23:18:53 发布
最新推荐文章于 2023-12-01 23:18:53 发布
阅读量1.4k 收藏
点赞数 1
分类专栏： RXSwift 文章标签： RxSwift
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wo190096/article/details/54708283
版权

RxSwift:操作符

绑定操作

  • startWith

    发出指定序列中的元素之前，先发出指定序列中的元素。

    这里写图片描述

    let disposeBag = DisposeBag()
Observable.of("OC", "C", "Java", "C++")
                  .startWith("1")
                  .startWith("2")
                  .startWith("3", "A", "B")
                  .subscribe(onNext: { print($0) })
                  .addDisposableTo(disposeBag)

输出：

3
A
B
2
1
OC
C
Java
C++

  • merge

    将多个Observable合并成一个Observable，按照时间顺序发出对应的事件。

    这里写图片描述

    let disposeBag = DisposeBag()
let subject1 = PublishSubject<String>()
let subject2 = PublishSubject<String>()        
Observable.of(subject1, subject2)
                  .merge()
                  .subscribe(onNext: { print($0) })
                  .addDisposableTo(disposeBag)

subject1.onNext("A")
subject1.onNext("B")
subject2.onNext("1")
subject2.onNext("2")
subject1.onNext("C")
subject2.onNext("C")

输出：

A
B
1
2
C
C

  • zip

    将多个（最多8个）Observable合并成一个新的Observable。当有事件到达时，会在每个序列中对应的索引上对应的元素发出。

这里写图片描述

let disposeBag = DisposeBag()
let stringSubject = PublishSubject<String>()
let intSubject = PublishSubject<Int>()        
Observable.zip(stringSubject, intSubject) { stringElement, intElement in
    "\(stringElement) \(intElement)"
    }.subscribe(onNext: { print($0)    }).addDisposableTo(disposeBag)
stringSubject.onNext("A")
stringSubject.onNext("B")        
intSubject.onNext(1)        
intSubject.onNext(2)        
stringSubject.onNext("C")
intSubject.onNext(3)

输出：
A 1
B 2
C 3

  • combineLatest

    将最多8个被观察序列合并为一个新的被观察序列，当有事件到达时，会将每个序列中的最新事件发出。

这里写图片描述

let disposeBag = DisposeBag()
let stringSubject = PublishSubject<String>()
let intSubject = PublishSubject<Int>()
Observable.combineLatest(stringSubject, intSubject) { stringElement, intElement in "\(stringElement) \(intElement)"
}.subscribe(onNext: { print($0) })
 .addDisposableTo(disposeBag)
stringSubject.onNext("A")
stringSubject.onNext("B")
intSubject.onNext(1)        
intSubject.onNext(2)        
stringSubject.onNext("C")

输出：
B 1
B 2
C 2

  • switchLatest

    将被监听的被观察者转换为另一个被观察者，从最近的被观察序列中发出元素。

这里写图片描述


let disposeBag = DisposeBag()
let subject1 = BehaviorSubject(value: "1")
let subject2 = BehaviorSubject(value: "A")
let variable = Variable(subject1)
variable.asObservable()
        .switchLatest()
        .subscribe(onNext: { print($0) })
        .addDisposableTo(disposeBag)

subject1.onNext("2")
subject1.onNext("3")        
variable.value = subject2        
subject1.onNext("4")        
subject2.onNext("B")

输出：
1
2
3
A
B

转换操作

  • map

    通过使用一个函数闭包将原来的Observable序列转换为一个新的Observable序列。

这里写图片描述

let disposeBag = DisposeBag()
Observable.of(1, 2, 3)
          .map { $0 * $0 }
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：
1
4
9

  • flatMap

    将一个Observable序列转换为另一个Observable序列，并且合并两个Observable序列。会按时间顺序接收两个序列发出的元素。

这里写图片描述

let disposeBag = DisposeBag()

struct Player {
    var score: Variable<Int>
}

let man = Player(score: Variable(80))
let woman = Player(score: Variable(90))

let player = Variable(man)

player.asObservable()
      .flatMap { $0.score.asObservable() } 
      .subscribe(onNext: { print($0) })
      .addDisposableTo(disposeBag)

man.score.value = 85

player.value = woman

man.score.value = 95

woman.score.value = 100

输出：

80
85
90
95
100

  • flatMapLatest

    flatMapLatest同flatMap一样，也是将一个序列转换为另一个序列，flatMapLatest只会从最近的序列中发出事件。flatMapLatest = map + switchLatest

let disposeBag = DisposeBag()

struct Player {
    var score: Variable<Int>
}

let man = Player(score: Variable(80))
let woman = Player(score: Variable(90))

let player = Variable(man)

player.asObservable()
      .flatMapLatest { $0.score.asObservable() } 
      .subscribe(onNext: { print($0) })
      .addDisposableTo(disposeBag)

man.score.value = 85

player.value = woman

man.score.value = 95

woman.score.value = 100

输出：

80
85
90
100

  • scan

    scan就是提供一个初始化值，然后使用计算闭包不断将前一个元素和后一个元素进行处理，并将处理结果作为单个元素的Observable序列返回。

这里写图片描述

let disposeBag = DisposeBag()

Observable.of(10, 100, 1000)
          .scan(1) { aggregateValue, newValue in
            aggregateValue + newValue
            }
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

11
111
1111

过滤和条件操作符

从Observable序列中挑选出发出的元素的操作。

  • filter

    在Observable序列中只发出满足过滤条件的事件。

这里写图片描述

let disposeBag = DisposeBag()
Observable.of(
              "A", "B", "C",
              "D", "A", "B",
              "E", "D", "A")
              .filter {
                 $0 == "A"
              }
              .subscribe(onNext: { print($0) })
              .addDisposableTo(disposeBag)

输出：

A
A
A

  • distinctUntilChanged

    禁止连续发出相同的事件。

这里写图片描述

let disposeBag = DisposeBag()

Observable.of("A", "B", "A", "A", "A", "C", "A")
          .distinctUntilChanged()
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

A
B
A
C
A

  • elementAt

    Observable序列只发出在指定位置的事件。

这里写图片描述

let disposeBag = DisposeBag()
Observable.of("A", "B", "C", "D", "E", "F")
          .elementAt(3)
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

D
  • single

只发出一个事件，若发出多个事件或不发出事件，都会发出error错误。

let disposeBag = DisposeBag()

Observable.of("A", "B", "C", "D", "E", "F")
          .single()
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

A
Received unhandled error: /Demo/RxSwift-master/RxExample/RxExample/iOS/AppDelegate.swift:412:application(_:didFinishLaunchingWithOptions:) -> Sequence contains more than one element.

let disposeBag = DisposeBag()

Observable.of("A", "B", "C", "D", "E", "F")
          .single { $0 == "D" }
          .subscribe { print($0) }
          .addDisposableTo(disposeBag)

Observable.of("A", "B", "C", "D", "B", "E")
          .single { $0 == "B" }
          .subscribe { print($0) }
        .addDisposableTo(disposeBag)

Observable.of("A", "B", "C", "D", "E", "F")
          .single { $0 == "H" }
          .subscribe { print($0) }
          .addDisposableTo(disposeBag)

输出：

next(D)
completed
next(B)
error(Sequence contains more than one element.)
error(Sequence doesn't contain any elements.)

  • take

    只处理前几个信号。

这里写图片描述

let disposeBag = DisposeBag()

Observable.of("A", "B", "C", "D", "E", "F")
          .take(3)
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

A
B
C

  • takeLast

    只处理后几个信号。

这里写图片描述

let disposeBag = DisposeBag()

Observable.of("A", "B", "C", "D", "E", "F")
          .takeLast(3)
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

D
E
F

  • takeWhile

    只处理满足条件的信号。

这里写图片描述

let disposeBag = DisposeBag()

Observable.of(1, 2, 3, 4, 5, 6)
          .takeWhile { $0 < 4 }
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：
1
2
3

  • takeUntil

    直到另一个Observable序列发出一个信号，则原序列终止。

这里写图片描述

let disposeBag = DisposeBag()

let sourceSequence = PublishSubject<String>()
let referenceSequence = PublishSubject<String>()

sourceSequence.takeUntil(referenceSequence)
              .subscribe { print($0) }
              .addDisposableTo(disposeBag)

sourceSequence.onNext("A")
sourceSequence.onNext("B")
sourceSequence.onNext("C")

referenceSequence.onNext("1")

sourceSequence.onNext("E")
sourceSequence.onNext("F")
sourceSequence.onNext("G")

输出：

next(A)
next(B)
next(C)
completed

  • skip

    跳过前几个信号。

这里写图片描述

//跳过前两个事件
let disposeBag = DisposeBag()

Observable.of("A", "B", "C", "D", "E", "F")
          .skip(2)
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

C
D
E
F

  • skipWhile

    跳过满足条件的事件，只要遇见不满足条件的事件，则该事件极其之后的事件（不管是否满足条件）都会发出。

这里写图片描述

let disposeBag = DisposeBag()

Observable.of(1, 2, 3, 4, , 6)
          .skipWhile { $0 < 4 }
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

4
5
6

  • skipWhileWithIndex

    跳过索引满足条件的事件。

let disposeBag = DisposeBag()

Observable.of("A", "B", "C", "D", "E", "F")
          .skipWhileWithIndex { element, index in
            index < 3
            }
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

D
E
F

  • skipUntil

    跳过另一个Observable序列发出事件之前的所有事件。

这里写图片描述

let disposeBag = DisposeBag()

let sourceSequence = PublishSubject<String>()
let referenceSequence = PublishSubject<String>()

sourceSequence.skipUntil(referenceSequence)
              .subscribe(onNext: { print($0) })
              .addDisposableTo(disposeBag)

sourceSequence.onNext("A")
sourceSequence.onNext("B")
sourceSequence.onNext("C")

referenceSequence.onNext("1")

sourceSequence.onNext("E")
sourceSequence.onNext("F")
sourceSequence.onNext("G")

输出：

E
F
G

数学和集合操作符

  • toArray

    将一个Observable序列转化为一个数组，并转换为单一的事件信号，然后结束。

这里写图片描述

let disposeBag = DisposeBag()

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

输出：

next([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
completed

  • reduce

    使用一个初始值和一个操作符，对Observable序列中的所有元素进行累计操作，并转换成单一事件信号。

这里写图片描述

let disposeBag = DisposeBag()

Observable.of(10, 100, 1000)
          .reduce(1, accumulator: +)
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)

输出：

1111

  • concat

    将两个序列合并成一个序列，当一个序列中的所有信号发送完成后，才后发送另一个序列中的信号。

这里写图片描述

let disposeBag = DisposeBag()

let subject1 = BehaviorSubject(value: "A")
let subject2 = BehaviorSubject(value: "1")

let variable = Variable(subject1)

variable.asObservable()
        .concat()
        .subscribe { print($0) }
        .addDisposableTo(disposeBag)

subject1.onNext("B")
subject1.onNext("C")

variable.value = subject2

subject2.onNext("I would be ignored")
subject2.onNext("2")

subject1.onCompleted()

subject2.onNext("3")

输出：

next(A)
next(B)
next(C)
next(1)
next(2)

连接操作符

Connectable Observable在订阅时不会发出事件消息，而是仅当调用它们的connec()方法时才会发出事件消息。这样就可以等待所有我们想要的订阅者都已经订阅了以后，再开始发出事件消息，这样能保证我们想要的所有订阅者都能接收到事件消息。其实也就是等大家都就位以后，开始发出消息。

  • publish

    将一个普通的Observable转换为一个Connectable Observable。

这里写图片描述

let intSequence = Observable<Int>.interval(1, scheduler: MainScheduler.instance).publish()

_ = intSequence.subscribe(onNext: { print("Subscription 1:, Event: \($0)") })

delay(2) { _ = intSequence.connect() }//把信号推迟2s发出

delay(4) {
        _ = intSequence
            .subscribe(onNext: { print("Subscription 2:, Event: \($0)") })
    }

delay(6) {
        _ = intSequence
            .subscribe(onNext: { print("Subscription 3:, Event: \($0)") })
    }

输出：

Subscription 1:, Event: 0
Subscription 1:, Event: 1
Subscription 1:, Event: 2
Subscription 2:, Event: 2
Subscription 1:, Event: 3
Subscription 2:, Event: 3
Subscription 1:, Event: 4
Subscription 3:, Event: 4
Subscription 2:, Event: 4
...

  • replay

    将一个普通的sequence转换成一个connectable sequence，然后和replaySubject相似，能接收到订阅之前的事件消息。

这里写图片描述

let intSequence = Observable<Int>.interval(1, scheduler: MainScheduler.instance).replay(5)

_ = intSequence.subscribe(onNext: { print("Subscription 1:, Event: \($0)") })

delay(2) { _ = intSequence.connect() }

delay(4) {
        _ = intSequence
            .subscribe(onNext: { print("Subscription 2:, Event: \($0)") })
    }

delay(8) {
        _ = intSequence
            .subscribe(onNext: { print("Subscription 3:, Event: \($0)") })
    }

输出：

Subscription 1:, Event: 0
Subscription 1:, Event: 1
Subscription 2:, Event: 0
Subscription 2:, Event: 1
Subscription 1:, Event: 2
Subscription 2:, Event: 2
Subscription 1:, Event: 3
Subscription 2:, Event: 3
Subscription 1:, Event: 4
Subscription 2:, Event: 4
Subscription 1:, Event: 5
Subscription 2:, Event: 5
Subscription 3:, Event: 1
Subscription 3:, Event: 2
Subscription 3:, Event: 3
Subscription 3:, Event: 4
Subscription 3:, Event: 5
Subscription 1:, Event: 6
Subscription 3:, Event: 6
Subscription 2:, Event: 6
Subscription 1:, Event: 7
Subscription 3:, Event: 7
Subscription 2:, Event: 7
Subscription 1:, Event: 8
Subscription 3:, Event: 8
Subscription 2:, Event: 8
Subscription 1:, Event: 9
Subscription 3:, Event: 9
Subscription 2:, Event: 9
Subscription 1:, Event: 10
Subscription 3:, Event: 10
Subscription 2:, Event: 10
...
  • multicast

将普通的Observable序列转换为connectable sequence，通过指定的subject广播事件。

let subject = PublishSubject<Int>()

 _ = subject.subscribe(onNext: { print("Subject: \($0)") })

let intSequence = Observable<Int>.interval(1, scheduler: MainScheduler.instance).multicast(subject)

 _ = intSequence.subscribe(onNext: { print("\tSubscription 1:, Event: \($0)") })

delay(2) { _ = intSequence.connect() }

delay(4) {
        _ = intSequence
            .subscribe(onNext: { print("\tSubscription 2:, Event: \($0)") })
    }

delay(6) {
        _ = intSequence
            .subscribe(onNext: { print("\tSubscription 3:, Event: \($0)") })
    }

输出：

Subject: 0
    Subscription 1:, Event: 0
Subject: 1
    Subscription 1:, Event: 1
Subject: 2
    Subscription 2:, Event: 2
    Subscription 1:, Event: 2
Subject: 3
    Subscription 2:, Event: 3
    Subscription 1:, Event: 3
Subject: 4
    Subscription 2:, Event: 4
    Subscription 3:, Event: 4
    Subscription 1:, Event: 4
Subject: 5
    Subscription 2:, Event: 5
    Subscription 3:, Event: 5
    Subscription 1:, Event: 5
Subject: 6
    Subscription 2:, Event: 6
    Subscription 3:, Event: 6
    Subscription 1:, Event: 6
Subject: 7
    Subscription 2:, Event: 7
    Subscription 3:, Event: 7
    Subscription 1:, Event: 7

错误处理

帮助从一个Observable的错误通知中恢复的运算符。

  • catchErrorJustReturn

    遇到Error事件时，输出一个指定元素，然后终止。

这里写图片描述

let disposeBag = DisposeBag()

let sequenceThatFails = PublishSubject<String>()

sequenceThatFails.catchErrorJustReturn("error!")
                 .subscribe { print($0) }
                 .addDisposableTo(disposeBag)

sequenceThatFails.onNext("A")
sequenceThatFails.onNext("B")
sequenceThatFails.onNext("C")
sequenceThatFails.onNext("D")
sequenceThatFails.onError(TestError.test)

输出：

next(A)
next(B)
next(C)
next(D)
next(error!)
completed

  • catchError

    捕获error，并转换成指定的Observable序列对error进行处理。

这里写图片描述

let disposeBag = DisposeBag()

let sequenceThatFails = PublishSubject<String>()
let recoverySequence = PublishSubject<String>()

sequenceThatFails.catchError {
            print("Error:", $0)
            return recoverySequence
        }.subscribe { print($0) }
         .addDisposableTo(disposeBag)

sequenceThatFails.onNext("1")
sequenceThatFails.onNext("2")
sequenceThatFails.onNext("3")
sequenceThatFails.onNext("4")
sequenceThatFails.onError(TestError.test)

recoverySequence.onNext("5")

输出：

next(1)
next(2)
next(3)
next(4)
Error: test
next(5)

  • retry

    对Error事件进行重试。

这里写图片描述

let disposeBag = DisposeBag()
    var count = 1

let sequenceThatErrors = Observable<String>.create { observer in
    observer.onNext("A")
    observer.onNext("B")
    observer.onNext("C")

    if count == 1 {
        observer.onError(TestError.test)
        print("Error encountered")
        count += 1
    }

    observer.onNext("D")
    observer.onNext("E")
    observer.onNext("F")
    observer.onCompleted()

    return Disposables.create()
}

sequenceThatErrors.retry()
                  .subscribe(onNext: { print($0) })
                  .addDisposableTo(disposeBag)

输出：
A
B
C
Error encountered
A
B
C
D
E
F
  • retry(_:)

指定最大的重试次数。

let disposeBag = DisposeBag()
var count = 1

let sequenceThatErrors = Observable<String>.create { observer in
    observer.onNext("A")
    observer.onNext("B")
    observer.onNext("C")

    if count < 5 {
        observer.onError(TestError.test)
        print("Error encountered")
        count += 1
    }

    observer.onNext("D")
    observer.onNext("E")
    observer.onNext("F")
    observer.onCompleted()

    return Disposables.create()
}

sequenceThatErrors.retry(3)
                  .subscribe(onNext: { print($0) })
                  .addDisposableTo(disposeBag)

输出：

A
B
C
Error encountered
A
B
C
Error encountered
A
B
C
Error encountered
Received unhandled error: /Demo/RxSwift-master/RxExample/RxExample/iOS/AppDelegate.swift:705:application(_:didFinishLaunchingWithOptions:) -> test

调试操作符

调试Rx代码的操作符

  • debug

打印所有的subscriptions，events，和disposals。

let disposeBag = DisposeBag()
var count = 1

let sequenceThatErrors = Observable<String>.create { observer in
    observer.onNext("A")
    observer.onNext("B")
    observer.onNext("C")

    if count < 5 {
        observer.onError(TestError.test)
        print("Error encountered")
        count += 1
    }

    observer.onNext("D")
    observer.onNext("E")
    observer.onNext("F")
    observer.onCompleted()

    return Disposables.create()
    }

sequenceThatErrors.retry(3)
                  .debug()
                  .subscribe(onNext: { print($0) })
                  .addDisposableTo(disposeBag)

输出：

2017-01-24 15:25:40.991: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> subscribed
2017-01-24 15:25:41.013: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(A)
A
2017-01-24 15:25:41.013: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(B)
B
2017-01-24 15:25:41.013: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(C)
C
Error encountered
2017-01-24 15:25:41.014: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(A)
A
2017-01-24 15:25:41.014: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(B)
B
2017-01-24 15:25:41.014: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(C)
C
Error encountered
2017-01-24 15:25:41.015: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(A)
A
2017-01-24 15:25:41.015: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(B)
B
2017-01-24 15:25:41.015: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event next(C)
C
Error encountered
2017-01-24 15:25:41.016: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> Event error(test)
Received unhandled error: /Demo/RxSwift-master/RxExample/RxExample/iOS/AppDelegate.swift:732:application(_:didFinishLaunchingWithOptions:) -> test
2017-01-24 15:25:41.016: AppDelegate.swift:731 (application(_:didFinishLaunchingWithOptions:)) -> isDisposed
  • RxSwift.Resources.total

查看RxSwift所有资源的占用，对于检查内存泄露是很有用的。

print(RxSwift.Resources.total)

let disposeBag = DisposeBag()

print(RxSwift.Resources.total)

let variable = Variable("A")

let subscription1 = variable.asObservable().subscribe(onNext: { print($0) })

print(RxSwift.Resources.total)

let subscription2 = variable.asObservable().subscribe(onNext: { print($0) })

print(RxSwift.Resources.total)

subscription1.dispose()

print(RxSwift.Resources.total)

subscription2.dispose()

print(RxSwift.Resources.total)

输出：

0
1
A
4
A
6
5
4
iOS学习社区
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxSwift: Reactive Programming with Swift
05-03
3. **Operators**：了解RxSwift提供的丰富的操作符，如`map`用于转换数据，`filter`用于筛选元素，`switchMap`用于在事件之间切换，`debounce`用于去除快速连续的事件等。这些操作符使得对数据流的处理更加简洁。 4...
RxSwift:RxSwift！
03-31
RxSwift的核心理念是通过Observables（观察者）和Operators（操作符）来抽象和管理复杂的事件序列。Observables允许我们订阅事件序列，而Operators则提供了丰富的工具来组合、过滤、转换这些事件。这种模型非常适合...
RxSwift 操作符 (concat)
Hellolad的博客
05-15 2313
concat ReactiveX: The Concat operator concatenates the output of multiple Observables so that they act like a single Observable, with all of the items emitted by the first Observable being emit...
iOS Swift RxSwift中 Subject、Variable 的使用（四）
WangQingLei0307的博客
03-30 1134
上几章讲解都是一些常用的控件（UILabel、UIButton等）RxSwfit的使用，今天讲解Subject、Variable，这两个在以后实际项目开发过程中占据着很大的比重，所以这两个的使用在这里我回着重的讲解 Variable其实本质和BehaviorSubject是一个东西，Variable相当于在BehaviorSubject进行了再次封装。当然是用上就更佳方便了。 首先是Subject 这里先接受一下Subject的一个特性 Subjects有一个属性，就是Subjects 既是.
[Swift]RxSwift常见用法详解
最新发布
Gamin
12-01 2452
RxSwift 是 ReactiveX API 的 Swift 版。它是一个基于 Swift 事件驱动的库，用于处理异步和基于事件的代码。
iOS Swfit RxSwift-变化操作符（五）
WangQingLei0307的博客
04-23 486
从本篇开始开始讲解RxSwift的一些操作符（变化操作符、条件和布尔操作符、结合操作符等）。 今天我们主要讲解的就是变化操作符 变化操作符主要包括了8种，分别是Buffer、Window、Map、FlatMap、FlatMapLatest、ConcatMap、Scan、GroupBy 下面我们开始讲解每一个操作符的使用。 1、Buffer Buffer 本称为缓冲集合，可以设置制定时间、缓存多少数据，然后发出数据，当然如果不够的也会发出数据。举个例子： func RxSwiftB.
RxSwift之常用高阶函数(操作符Operator)的说明和使用
╰つ栺尖篴夢ゞ
08-09 8554
一、组合操作符 ① startWith startWith 方法会在 Observable 序列开始之前插入一些事件元素，即发出事件消息之前，会先发出这些预先插入的事件消息。如下所示： Observable.of("2", "3", "4") .startWith("1") .subscribe(onNext: { print($0) }) .disposed(by: DisposeBag()) // 输出结果 1 2 3 4 插入多个数据，如下所示： Observ
RxSwiftExtensions:RxSwift操作符扩展
03-16
RxSwiftExtensions 例子 要运行示例项目，请克隆存储库，然后首先从Example目录运行pod install 。 要求 安装 RxSwiftExtensions可通过。 要安装它，只需将以下行添加到您的Podfile中： pod 'RxSwiftExtensions' ...
RxSwift学习
dzqxwzoe的博客
01-12 1552
如果我们需要在发生错误时，经过一段延时后重试，那可以这样实现： 这个操作符主要描述应该在何时重试，并且通过闭包里面返回的 Observable 来控制重试的时机,当它发出一个 error 或者 completed 事件时，就不会重试，并且将这个事件传递给到后面的观察者.一个比较典型的例子就是，在后台发起网络请求，然后解析数据，最后在主线程刷新页面。当退出页面时， ViewController 就被释放，disposeBag 也跟着被释放了，那么这里的 5 次绑定（订阅）也就被取消了。这正是我们所需要的。
RxSwift操作符详解
永不止步
03-26 1917
共演示了大概60个操作符的使用 Demo 项目地址 - Creating Operators never 创建既不发射数据也不会终止的序列 Observable&lt;String&gt;.never() .subscribe{ print($0) }.disposed(by: GlobalD...
swift-rxswift的一些操作符的示例和详解
08-15
rxswift 的一些操作符的示例和详解
RxObjC:用于 Objective-C 的 ReactiveX
05-31
RxObjC：Objective-C 的 ReactiveX RxObjC是一个Objective-C的端口 当前版本是 1.0 ~ 2.5 RxSwift。 RxObjC 1.0 只包含 rx 的核心，没有 RxCocoa 模块。 如何安装 使用 :warning: 重要的！ 对于 tvOS 支持，需要 CocoaPods 0.39 。 :warning: # Podfile use_frameworks! target 'YOUR_TARGET_NAME' do pod 'RxObjC', '~> 1.0' end # RxTests and RxBlocking make the most sense in the context of unit/integration tests target 'YOUR_TESTING_TARGET' do pod 'RxBlocking',
RxSwift 里缺少的一些操作符扩展.zip
10-10
RxSwift 里缺少的一些操作符扩展.zip,A collection of Rx operators & tools not found in the core RxSwift distribution
RxSwift学习（五）--- RxSwift 操作符
～玉麒麟～
12-30 608
RxSwift学习（一）— RxSwift介绍 RxSwift学习（二）— Observable 常见的序列创建方法 RxSwift学习（三）— RxSwift 高阶函数 RxSwift学习（四）— RxSwift 操作符
学习 RxSwift操作符
Coding_Physical的专栏
05-07 365
ViewModel 的核心功能是把 Model 数据转换为用于 UI 呈现所需的数据。其实RxSwift 的操作符就是负责转换的，使用合适的操作符能帮我们减少代码量并提高生产力。 一、过滤操作符 001 filter 操作符用于过滤不需要的事件 func filterFunc() { Observable.of(2,23,5,45,1,21).filter{ $0 > 20 }.subscribe(onNext:{
RxSwift学习--高阶函数 / 操作符（上）
weixin_30570101的博客
08-14 310
前言 在RxSwift中，高阶函数也可以成为操作符，高阶函数可以帮助我们创建新的序列，或者变化组合原有的序列，从而生成一个新的序列。 转换操作符 1. map map操作符会通过传入一个函数闭包把原来的 Observable 序列转变为一个新的 Observable 序列,map函数会将源序列的所有元素进行转换，返回一个新序列. 例子： let disposeBag = DisposeB...
RxSwift学习之十一 （基础使用篇 2 - 高阶函数）
kyl282889543的博客
08-30 684
RxSwift学习之十 （基础使用篇 中）2. 高阶函数2.11 算数、以及聚合操作（Mathematical and Aggregate Operators）2.11.1 toArray2.11.2 reduce2.11.3 concat 2. 高阶函数 2.11 算数、以及聚合操作（Mathematical and Aggregate Operators） 2.11.1 toArray 该操...
RxSwift系列—RxSwift高阶函数
极客专栏
12-01 1585
3.1 组合操作符 3.1.1 startWith 在开始从可观察源发出元素之前，发出指定的元素序列 print("*****startWith*****") Observable.of("1", "2", "3", "4") .startWith("A") .startWith("B") .startWith("C", "a", "b") .subscribe(onNext: { print($0) }) .disposed(by: disposeBag) //
RxSwift 入坑手册 - 基础概念
Rey的技术博客
01-04 819
https://blog.callmewhy.com/post/rxswift-getting-started-0/#combining 前言 RxSwift 是我在 Github 上关注已久的一个项目，今天花点时间过了一下它的示例代码，感觉很有意思。 我主要是通过项目里的 Rx.playground 进行学习和了解的，这种方式确实便捷高效。只需要把文档用/*: */注释即可，直接用 Markdown编写，简单方便。不过 Xcode7 中这种方式现在还不是很稳定，会有大量的空行，而且有个最大的问题就是阅读到
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值