RxSwift (x) Basic Usage part 1- Sequence, subscribe, destroy
December 27, 2023
by Elaine Hartley
No Comments
Rxswift (1) Functional responsive programming idea
RxSwift (II) Sequence core logic analysis
Create, subscribe, and destroy an RxSwift Observable
RxSwift (4) higher-order functions
RxSwift (v)
(6) Dispose source code analysis
RxSwift (7) RxSwift vs. SWIFT usage
RxSwift (x) Basic Usage part 1- Sequence, subscribe, destroy
RxSwift Learning 12 (Basics 3- UI Control Extensions)
Download the latest code from GitHub: github.com/ReactiveX/R…
1. RxSwift profile
The role of RxSwift
1) When writing codes, we often need to detect changes of some values (such as textFiled input value changes, data request completion or failure changes) and process them accordingly. In the past, different event-passing methods were used for different situations, such as Delegate, notification, target-Action, KVO, etc. The appearance of RectiveX mechanism (implemented by RxSwift) unify the event passing response method in the program. Replace the usual event-passing methods (delegate, notification, target-Action, etc.) with Rx’s “signal chain” approach. (2) If we usually use MVVM development mode, through RxSwift can obtain more convenient data binding method, making MVVM development more powerful.
RxSwift and RxCocoa
RxSwift: It is based only on the Rx standard implementation library of the Swift language, so RxSwift does not contain any Cocoa or UI classes. RxCocoa: A library developed for iOS based on RxSwift that adds Rx features to native UI controls via Extension, making it easier to subscribe to and respond to their events.
2. Simple use of RxSwift
2.1 Comparison sample between responsive programming and traditional programming
Example 2.1
There is a requirement: the table is showing the song information (song name, and artist) click on any cell, print out the corresponding song information in the console.
In the traditional way, first we create a Music structure that holds the name of the song and the name of the artist. It also follows the CustomStringConvertible protocol to facilitate debugging of output.
import UIKit
// Song structurestructMusic{
let name: String/ / titlelet singer: String/ / singerinit(name: String, singer: String) {
self.name = name
self.singer = singer
}
}
// Implement CustomStringConvertible protocol to facilitate output debuggingextensionMusic: CustomStringConvertible{
var description: String {
returnName: ""\(name)Singer:\(singer)"}}Copy the code
2.1.1 Traditional programming
So let’s write a ViewModel
import Foundation
// Song list data sourcestructMusicListViewModel{
let data = [
Music(name: "Unconditional", singer: Eason Chan),
Music(name: "You were a teenager.", singer: "S.H.E"),
Music(name: "The old me.", singer: "Kit Chan"),
Music(name: "In Jupiter", singer: "Hackberry")]}Copy the code
ViewController code (viewcontroller.swift)
We then set up the delegate of the UITableView and have the view controller implement the UITableViewDataSource and UITableViewDelegate protocols, as well as the associated protocol methods.
I’m sure you’ve written this a million times, and there’s nothing to tell. So let’s see, this is 43 lines of code.
import UIKit
import RxSwift
classViewController: UIViewController{
/ / tableView object@IBOutletweakvar tableView: UITableView!
// Song list data sourcelet musicListViewModel = MusicListViewModel(a)overridefuncviewDidLoad(a) {
super.viewDidLoad()
// Set the proxy
tableView.dataSource = self
tableView.delegate = self}}extensionViewController: UITableViewDataSource{
// Returns the number of cellsfunctableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return musicListViewModel.data.count
}
// Returns the corresponding cellfunctableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath)
-> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: "musicCell")!
letmusic = musicListViewModel.data[indexPath.row] cell.textLabel? .text = music.name cell.detailTextLabel?.text = music.singerreturn cell
}
}
extensionViewController: UITableViewDelegate{
// Cell clickfunctableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
print("Information about the song you selected [\(musicListViewModel.data[indexPath.row])】")}}Copy the code
Let’s look at the programming of Rxswift
2.1.2 Rxswift programming
rightViewModelDo some modification
Here we turn the data property into an observable sequence object (Observable Squence), and the contents of the object are exactly the same as those contained in the array.
I’ll talk more about observable sequence objects in a later article. Simply put, a “sequence” can subscribe to these values.Subscribe), somewhat similar to “Notice (NotificationCenter)”
import RxSwift
// Song list data sourcestructMusicListViewModel{
let data = Observable.just([
Music(name: "Unconditional", singer: Eason Chan),
Music(name: "You were a teenager.", singer: "S.H.E"),
Music(name: "The old me.", singer: "Kit Chan"),
Music(name: "In Jupiter", singer: "Hackberry"),])}Copy the code
View Controller code (ViewController.swift)
We no longer need to implement datasource and delegate protocols. I’m going to write some reactive code that binds the data to the UITableView.
We’re only going to need 31 lines of code here, which is a quarter less code than we had before. And the code is a little cleaner.
DisposeBag: Rx automatically interprets the resources bound to the view controller or its owner when it is about to be destroyed. It is implemented through a “subscription disposition mechanism” (similar to removeObserver of NotificationCenter). Rx.items (cellIdentifier:) : This is a wrapper around RX based on the cellForRowAt data source method. In the traditional way we also have a numberOfRowsInSection method, which is no longer needed when we use Rx (Rx already does that for us). Rx. modelSelected: This is a wrapper around RX based on the UITableView delegate callback method didSelectRowAt.
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
/ / tableView object@IBOutletweakvar tableView: UITableView!
// Song list data sourcelet musicListViewModel = MusicListViewModel(a)// Responsible for object destructionlet disposeBag = DisposeBag(a)overridefuncviewDidLoad(a) {
super.viewDidLoad()
// Bind data source data to tableView
musicListViewModel.data
.bind(to: tableView.rx.items(cellIdentifier:"musicCell")) { _, music, cell incell.textLabel? .text = music.name cell.detailTextLabel?.text = music.singer }.disposed(by: disposeBag)//tableView click response
tableView.rx.modelSelected(Music.self).subscribe(onNext: { music inprint("Information about the song you selected [\(music)】")
}).disposed(by: disposeBag)
}
}
Copy the code
2.2 Observable Describes and creates Observable sequences
Observable is the foundation of Rx, so we need to get a basic understanding of it.
Observable:
The Observable class, which is the basis of the Rx framework, is called an Observable sequence. What it does is generate a series of events asynchronously, that is, an Observable emits events (Element: T) irregularly over time. These events can also carry data, and their generics are used to specify the type of data carried by the Event. With Observable sequences, we also need an Observer to subscribe to them so that the subscriber can receive the events that an Observable emits from time to time.
Event
If you look at the RxSwift source code, you can find that the Event is defined as follows:
publicenumEvent<Element> {
/// Next element is produced.case next(Element)
/// Sequence terminated with an error.case error(Swift.Error)
/// Sequence completed successfully.case completed
}
Copy the code
You can see that an Event is an enumeration, which means that an Observable emits three different types of events:
next:nextAn event is an event that can carry data, and it can be said to be the “most normal” event.
error:errorAn event represents an error, and it can carry specific error content onceObservableissuederror event, thisObservableSo it’s going to terminate, and it’s not going to emit an event anymore.
completed:completedThe event saidObservableThe emitted event ends normally, just like error, onceObservableissuedcompleted event, thisObservableSo it’s going to terminate, and it’s not going to emit an event anymore.
2.2.1 Comparison between Observable and Sequence
1) For better understanding, we can take each of themObservableImagine the Sequence in a Swift:
That is, aObservable(ObservableType) is equivalent to a sequenceSequence(SequenceType).
ObservableType.subscribe(_:)The method is essentially the same thing asSequenceType.generate()
2) But there are many differences:
The Swift,SequenceTypeIt’s a synchronous cycle, andObservableIt’s asynchronous.
ObservableThe object automatically passes the Event as a parameter when it has any EventObservableType.subscribe(_:)Emit, without using the next method.
2.2.2 Creating an Observable sequence
There are several ways to create an Observable sequence
Just () method
(1) The method is initialized by passing in a default value. (2) In the following example, the type of observable is explicitly marked as Observable, which specifies that the data type of the event emitted by the Observable must be Int.
let observable = Observable<Int>.just(5)
Copy the code
Of () method
(1) The method can accept a variable number of arguments (all of the same type). (2) In the example below, I don’t explicitly declare the generic type of Observable, and Swift will automatically infer the type.
let observable = Observable.of("A"."B"."C")
Copy the code
The from () method
(1) This method takes an array argument. (2) The elements in the data in the following example are treated as the data content of the Observable event. The result is the same as in the of() example above.
let observable = Observable.from(["A"."B"."C"])
Copy the code
The empty() method creates an Observable sequence of empty content.
let observable = Observable<Int>.never()
Copy the code
The never() method creates an Observable sequence that never emits an Event (and never terminates).
let observable = Observable<Int>.never()
Copy the code
The error() method creates an Observable that does nothing but sends an error.
enumMyError: Error{
caseAcaseB
}
let observable = Observable<Int>.error(MyError.A)
Copy the code
The range () method
(1) This method creates an Observable sequence that starts with all values in the range by specifying the start and end values. (2) In the following example, the two methods create the same Observable sequence.
/ / use the range ()let observable = Observable.range(start: 1.count: 5)
/ / use of ()let observable = Observable.of(1.2.3 ,4 ,5)
Copy the code
RepeatElement () this method creates an Observable sequence that emits events for the given element indefinitely (never terminating).
let observable = Observable.repeatElement(1)
Copy the code
The generate () method
(1) This method creates an Observable that gives an action only when all the provided criteria are true. (2) In the following example, the two methods create the same Observable sequence.
// Use generate()let observable = Observable.generate(
initialState: 0,
condition: { $0< =10 },
iterate: { $0 + 2})// Use the of() methodlet observable = Observable.of(0 , 2 ,4 ,6 ,8 ,10)
Copy the code
The create () method
(1) The method takes a block and processes each incoming subscription. (2) Here is a simple example. Subscription code has been added for demonstration purposes
// The block has a callback parameter observer that is the subscriber to the Observable// When a subscriber subscribes to an Observable, it passes the subscriber as an argument to the block to perform somethinglet observable = Observable<String>.create{observer in// A.next event was issued to the subscriber, carrying a data "hangge.com"
observer.onNext("hangge.com")
// A.completed event was issued to the subscriber
observer.onCompleted()
Since a subscription has a Disposable return value, we must returen a Disposable at the endreturnDisposables.create()
}
// Subscribe tests
observable.subscribe {
print($0)}Copy the code
Deferred () method
(1) This method is equivalent to creating an Observable factory, which executes deferred Observable creation by passing in a block where the actual sequence object is instantiated. (2) Here is a simple demo:
// Is used to indicate whether it is odd or evenvar isOdd = true// Defer Observable initialization with the Deferred () method, pass the block to initialize the Observable and return it.let factory : Observable<Int> = Observable.deferred {
// alternate odd and even numbers every time this block is executedisOdd = ! isOdd// Based on the isOdd parameter, determine whether an odd or even Observable is created and returnedif isOdd {
returnObservable.of(1.3.5 ,7)}else {
returnObservable.of(2.4.6.8)}}// First subscription test
factory.subscribe { event inprint("\(isOdd)", event)
}
// Second subscription test
factory.subscribe { event inprint("\(isOdd)", event)
}
Copy the code
The results are as follows, and we can see that the two observables we subscribe to are different:
(1) The Observable created by this method emits an index element every set period of time. And it’s going to keep going. (2) the following method causes it to be sent every 1 second and is sent from the MainScheduler.
let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event inprint(event)
}
Copy the code
The timer () method
(1) There are two ways to use this method. One is to create an Observable sequence that generates a unique element after a set period of time.
// Emits a unique element 0 after 5 secondslet observable = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
observable.subscribe { event inprint(event)
}
Copy the code
(2) The other is an Observable sequence that generates an element at intervals after a set period of time.
// Emit an element every 1 second after a delay of 5 secondslet observable = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
observable.subscribe { event inprint(event)
}
Copy the code
2.3 Observable subscription, Event listening, and subscription destruction
2.3.1 observables subscription
With an Observable, we also subscribe to it using the subscribe() method and receive its events.
2.3.1.1 The first subscription method
(1) We subscribe to an Observable using subscribe(). The block callback parameter of this method is the emitted event, which we print directly.
let observable = Observable.of("A"."B"."C")
observable.subscribe { event inprint(event)
}
Copy the code
The result is as follows:
The default values set when initializing the Observable sequence are sent sequentially through the.next event. When the Observable completes sending the initial data, it automatically emits a.Completed event.
(2) If you want to obtain the data of this event, you can obtain it through event. Element.
let observable = Observable.of("A"."B"."C")
observable.subscribe { event inprint(event.element)
}
Copy the code
The running results are as follows:
2.3.1.2 Second subscription method
(1) RxSwift also provides anothersubscribeMethod, which can categorize events:
Different types of events are handled through different block callbacks. (Where onDisposed indicates the callback after the subscription is disposed)
At the same time, the data carried by the event will be directly unpacked as parameters, which is convenient for us to use.
let observable = Observable.of("A"."B"."C")
observable.subscribe(onNext: { element inprint(element)
}, onError: { error inprint(error)
}, onCompleted: {
print("completed")
}, onDisposed: {
print("disposed")})Copy the code
The running results are as follows:
(2)subscribe()methodsonNext,onError,onCompleted 和 onDisposedThe four callback block arguments have default values, that is, they are optional. So we could just do itonNextRegardless of the other cases.
let observable = Observable.of("A"."B"."C")
observable.subscribe(onNext: { element inprint(element)
})
Copy the code
The command output is as follows: A B C
2.3.2 Event Listening
Introduce’s elite doOn
(1) We can use the doOn method to listen for the life cycle of events, which will be called before each event is sent. (2) Like SUBSCRIBE, it can handle different types of events through different block callbacks. For example, the do(onNext:) method is called before subscribe(onNext:) and the do(onCompleted:) method is called before subscribe(onCompleted:).
Use the sample
let observable = Observable.of("A"."B"."C")
observable
.do(onNext: { element inprint("Intercepted Next：", element)
}, onError: { error inprint("Intercepted the Error:", error)
}, onCompleted: {
print("Intercepted Completed")
}, onDispose: {
print("Intercepted Disposed")
})
.subscribe(onNext: { element inprint(element)
}, onError: { error inprint(error)
}, onCompleted: {
print("completed")
}, onDisposed: {
print("disposed")})Copy the code
2.3.3 Subscription destruction
2.3.3.1 Observable Creation to Termination Process
(1) OneObservableInstead of being activated immediately after a sequence is created to emit events, it is activated only when it has been subscribed by someone.
(2)ObservableOnce the sequence is activated, wait until it’s emitted.erroror.completed 的 eventAfter that, it was ended.
2.3.3.2 the dispose () method
– (1) Using this method we can manually cancel a subscription. – (2) If we feel that the subscription is no longer needed, we can call dispose() method to dispose of the subscription to prevent memory leakage. – (3) When a subscription is disposed, an Observable can’t receive the message if it sends an event again. Here is a simple usage example.
let observable = Observable.of("A"."B"."C")
Use the subscription constant to store this subscription methodlet subscription = observable.subscribe { event inprint(event)
}
// Call the dispose() method on the subscription
subscription.dispose()
Copy the code
2.3.3.13 DisposeBag
(1) In addition to dispose() method, we more often use an object called DisposeBag to manage the destruction of multiple subscriptions:
We can think of a DisposeBag object as a garbage bag into which we can put all of our used subscriptions.
The DisposeBag then calls its Dispose () method on all subscriptions as it approaches dealloc.
(2) Below is a simple usage example.
let disposeBag = DisposeBag(a)// First Observable, and its subscriptionlet observable1 = Observable.of("A"."B"."C")
observable1.subscribe { event inprint(event)
}.disposed(by: disposeBag)
// The second Observable and its subscriptionlet observable2 = Observable.of(1.2.3)
observable2.subscribe { event inprint(event)
}.disposed(by: disposeBag)
Copy the code
2.4 AnyObserver and Binder
2.4.1 Observer (Observer)
The role of an Observer, “Observer,” is to listen for an event and then respond to that event. Or anything that responds to an event is an observer. Such as:
When we click the button, a prompt box pops up. The Observer is an Observer
When we request a remote JSON data, we print it out. So this “print JSON data” is the Observer
2.4.2 Creating an Observer
2.4.2.1 Create observer directly in subscribe and bind methods
Created in the SUBSCRIBE method
(1) The most direct way to create an observer is to describe how to respond to an event after the Subscribe method of an Observable. (2) In the following example, the observer is constructed from the following closures: onNext, onError, onCompleted.
let observable = Observable.of("A"."B"."C")
observable.subscribe(onNext: { element inprint(element)
}, onError: { error inprint(error)
}, onCompleted: {
print("completed")})Copy the code
Running results:
Create an Observable that periodically generates index numbers and displays them on the label tag:
Observable (emits an index every second)let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable
.map { "Current index:\ [$0 )"}
.bind { [weakself](text) in// The number of sent indexes is displayed on the labelself? .label.text = text } .disposed(by: disposeBag)Copy the code
2.4.2.2 Creating an Observer using AnyObserver
AnyObserver can be used to describe any kind of observer.
Used in conjunction with the SUBSCRIBE method
/ / observerlet observer: AnyObserver<String> = AnyObserver { (event) inswitch event {
case .next(let data):
print(data)
case .error(let error):
print(error)
case .completed:
print("completed")}}let observable = Observable.of("A"."B"."C")
observable.subscribe(observer)
Copy the code
Use with bindTo method
/ / observerlet observer: AnyObserver<String> = AnyObserver{[weakself] (event) inswitch event {
case .next(let text):
// The number of sent indexes is displayed on the labelself? .label.text = textdefault:
break}}Observable (emits an index every second)let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable
.map { "Current index:\ [$0 )"}
.bind(to: observer)
.disposed(by: disposeBag)
}
Copy the code
2.4.2.3 Using Binder to create observers
(1) Binder is more focused on specific scenarios than AnyObserver. Binder does not handle error events and ensures that bindings are executed on a given Scheduler (MainScheduler by default). (2) fatalError will be executed in debug and error messages printed in publish.
Instance 2.4.2.3
/ / observerlet observer: Binder<String> = Binder(label) { (view, text) in// The number of sent indexes is displayed on the label
view.text = text
}
Observable (emits an index every second)let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable
.map { "Current index:\ [$0 )"}
.bind(to: observer)
.disposed(by: disposeBag)
Observable (emits an index every second)let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable
.map{$0 % 2= =0 }
.bind(to: button.rx.isEnabled)
.disposed(by: disposeBag)
Copy the code
2.5 Customizing Binding Attributes
Sometimes we want UI controls to have some observers by default when they are created, rather than having to create separate observers for them each time. For example, we want all uilabels to have a fontSize binding property that automatically changes the fontSize of the label based on the event value.
By extending the UI class here we’ve extended UILabel to add a fontSize binding property.
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
@IBOutletweakvar label: UILabel!
let disposeBag = DisposeBag(a)overridefuncviewDidLoad(a) {
Observable (emits an index every 0.5 seconds)let observable = Observable<Int>.interval(0.5, scheduler: MainScheduler.instance)
observable
.map { CGFloat($0) }
.bind(to: label.fontSize) // Zoom in font according to index number
.disposed(by: disposeBag)
}
}
extensionUILabel{
publicvar fontSize: Binder<CGFloat> {
returnBinder(self) { label, fontSize in
label.font = UIFont.systemFont(ofSize: fontSize)
}
}
}
Copy the code
Since you use RxSwift, the more formal way to write this is to extend Reactive. Again, we’re adding a fontSize binding property to UILabel.
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
@IBOutletweakvar label: UILabel!
let disposeBag = DisposeBag(a)overridefuncviewDidLoad(a) {
Observable (emits an index every 0.5 seconds)let observable = Observable<Int>.interval(0.5, scheduler: MainScheduler.instance)
observable
.map { CGFloat($0) }
.bind(to: label.rx.fontSize) // Zoom in font according to index number
.disposed(by: disposeBag)
}
}
extensionReactivewhereBase: UILabel{
publicvar fontSize: Binder<CGFloat> {
returnBinder(self.base) { label, fontSize in
label.font = UIFont.systemFont(ofSize: fontSize)
}
}
}
Copy the code
RxSwift binding properties (UI Observer)
In fact, RxSwift already provides us with many common bindable properties. UILabel, for example, has two binding attributes, text and attributedText.
extensionReactivewhereBase: UILabel{
/// Bindable sink for `text` property.publicvar text: Binder<String? > {returnBinder(self.base) { label, text in
label.text = text
}
}
/// Bindable sink for `attributedText` property.publicvar attributedText: Binder<NSAttributedString? > {returnBinder(self.base) { label, text in
label.attributedText = text
}
}
}
Copy the code
In the example above, we don’t need to customize the UI observer. We can just use the binding property provided by RxSwift.
Observable (emits an index every second)let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable
.map { "Current index:\ [$0 )"}
.bind(to: label.rx.text) // The number of sent indexes is displayed on the label
.disposed(by: disposeBag)
Copy the code
2.6 the Subjects, the Variables
When we create an Observable, we prepare all the data that will be sent out in advance, and wait until someone subscribes to it to send the data out via events. But sometimes we want an Observable to dynamically “get” or “produce” new data at runtime and send it out via events. For example, subscribe to the input content of an input box. When a user enters a word, the Observable associated with the input box issues an Event with the input content to notify all subscribers. This can be done using Subjects, which will be described below.
2.6.1 the Subjects
2.6.1.1 introduction of the Subjects
– (1) Subjects is both a subscriber and an Observable: it is a subscriber because it can receive new values dynamically. It is also an Observable, because when Subjects has a new value, it sends the new value to all its subscribers through events.
– (2) There are four types of Subjects, namely, PublishSubject, BehaviorSubject, ReplaySubject and Variable. They have their own characteristics, but also have something in common:
First of all, they all areObservableTheir subscribers can receive the new ones they send outEvent.
untilSubjecta.completeor.error 的 EventLater, theSubjectIt ends, and it doesn’t go out again.nextEvents.
For those in theSubjectSubscribers who subscribe to him after the end will also receive itsubjectSent out.complete 或 .error 的 eventAnd tell the new subscriber that it’s over.
The biggest difference between them is whether a new subscriber can receive it when he first subscribes to itSubjectOld ones that have been issued beforeEventAnd how many, if any.
– (3) Several commonly used methods of Subject:
onNext(:)On (.next(:)). This method is equivalent to the subject receiving a.next event.
onError(:): is a shorthand for on(.error(:)). This method is equivalent to the subject receiving an.error event.
onCompleted(): is a convenient form of on(.completed). This method is equivalent to the subject receiving a.Completed event.
2.6.1.2 PublishSubject
(1) Basic introduction
The PublishSubject is the most common Subject that can be created without an initial value. PublishSubject subscribers can receive new events issued by the Subject after the subscription from the time they started the subscription, but not events they issued before the subscription.
(2) The sequence diagram is as follows: The top one isPublishSubject. The following two represent two new subscriptions, which are subscribed at different points in time, as you can seePublishSubjectSubscribers will only receive their subscriptionsEvent.
Instance 2.6.1.2:
let disposeBag = DisposeBag(a)// Create a PublishSubjectlet subject = PublishSubject<String> ()// Since there are currently no subscribers, this information will not be printed to the console
subject.onNext("111")
// Subscribe to subject for the first time
subject.subscribe(onNext: { string inprint("1st subscription:", string)
}, onCompleted:{
print("1st Subscription: onCompleted")
}).disposed(by: disposeBag)
// If there is currently one subscription, this information is printed to the console
subject.onNext("222")
// Subscribe the second time to subject
subject.subscribe(onNext: { string inprint("Second subscription:", string)
}, onCompleted:{
print("Second subscription: onCompleted")
}).disposed(by: disposeBag)
// If there are currently two subscriptions, this information is printed to the console
subject.onNext("333")
// Let the subject end
subject.onCompleted()
// The.next event is emitted when the subject is finished.
subject.onNext("444")
// After the subject completes, all of its subscriptions (including those that completed) will receive the Subject's.completed event.
subject.subscribe(onNext: { string inprint("3rd subscription:", string)
}, onCompleted:{
print("Third subscription: onCompleted")
}).disposed(by: disposeBag)
Copy the code
Running results:
2.6.1.3 BehaviorSubject
– (1) Basic introduction
The BehaviorSubject needs to be created with a default initial value. When a subscriber subscribes to it, the subscriber immediately receives an event emitted on BehaviorSubjects. Then, just like normal, it also receives a new event emitted by the BehaviorSubject.
– (2) The timing diagram is as follows: The BehaviorSubject at the top is BehaviorSubject. The following two subscriptions represent two new subscriptions at different times. You can see that the subscriber of BehaviorSubject starts out with an Event that BehaviorSubjects sent earlier.
Instance 2.6.1.3
let disposeBag = DisposeBag(a)// Create a BehaviorSubjectlet subject = BehaviorSubject(value: "111")
// Subscribe to subject for the first time
subject.subscribe { event inprint("1st subscription:", event)
}.disposed(by: disposeBag)
// Send the next event
subject.onNext("222")
// Send an error event
subject.onError(NSError(domain: "local", code: 0, userInfo: nil))
// Subscribe the second time to subject
subject.subscribe { event inprint("Second subscription:", event)
}.disposed(by: disposeBag)
Copy the code
Running results:
2.6.1.4 ReplaySubject
(1) Basic introduction
ReplaySubjectYou need to set one at creation timebufferSizeRepresents the number of events it caches for which it has sent.
For example, aReplaySubject 的 bufferSizeSet to 2 and it sends out 3.next 的 event, then it will divide the last two (the nearest two)eventCache it. Now if I have onesubscriberSubscribe to thisReplaySubjectSo thissubscriberIt will immediately receive the first two cached.next 的 event.
If asubscriberSubscription has endedReplaySubjectExcept that it will receive a cache.next 的 eventAlso, you will receive the termination.erroror.complete 的 event.
(2) The sequence diagram is as follows: The top one isReplaySubject(bufferSizeSet it to 2). The following two represent two new subscriptions at different points in time. You can findReplaySubjectSubscribers will receive it right from the startReplaySubjectThe two we sent out earlierEvent(if any).
Instance 2.6.1.4:
let disposeBag = DisposeBag(a)// Create a ReplaySubject with bufferSize 2let subject = ReplaySubject<String>.create(bufferSize: 2)
// Send three consecutive next events
subject.onNext("111")
subject.onNext("222")
subject.onNext("333")
// Subscribe to subject for the first time
subject.subscribe { event inprint("1st subscription:", event)
}.disposed(by: disposeBag)
// Send a next event
subject.onNext("444")
// Subscribe the second time to subject
subject.subscribe { event inprint("Second subscription:", event)
}.disposed(by: disposeBag)
// Let the subject end
subject.onCompleted()
// Subscribe subject for the third time
subject.subscribe { event inprint("3rd subscription:", event)
}.disposed(by: disposeBag)
Copy the code
Running results:
2.6.2 Variables
Note: Since Variable will be deprecated in future releases, it is recommended that you use BehaviorRelay as described below instead of Varible
2.6.2.1 Variable
– (1) Basic introduction
VariableIn fact, yes.BehaviorSubjectSo it must also be created with a default initial value.
VariablewithBehaviorSubjectTo send the last one to its subscriberseventAnd the ones that are created after thatevent.
The difference is,VariableIt also saves the currently emitted value as its own state. It will also be sent automatically when destroyed.complete 的 eventIt is not necessary and cannot be given manuallyVariablessendcompletedorerrorEvents to end it.
In a nutshellVariableThere is avalueProperty, let’s change thisvalueThe value of the property is equivalent to the call generalSubjects 的 onNext()Method, and this latest oneonNext()The value of is saved invalueProperty, until we modify it again.
VariablesItself has nosubscribe()Method, but allSubjectsThere is aasObservable()Methods. We can use this method to return thisVariable 的 ObservableType, get thisObservableType we can subscribe to it.
Instance 2.6.2.1
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
overridefuncviewDidLoad(a) {
super.viewDidLoad()
let disposeBag = DisposeBag(a)// Create a Variable whose initial value is 111let variable = Variable("111")
// Change the value
variable.value = "222"// First subscription
variable.asObservable().subscribe {
print("1st subscription:", $0)
}.disposed(by: disposeBag)
// Change the value
variable.value = "333"// Second subscription
variable.asObservable().subscribe {
print("Second subscription:", $0)
}.disposed(by: disposeBag)
// Change the value
variable.value = "444"}} Note: Due toVariableThe object is initialized within the viewDidLoad() method, so its lifetime is limited to that method. When this method is done, thisVariableThe object is destroyed, and it automatically issues the.Completed event to all its subscribersCopy the code
Running results:
2.6.2.2 BehaviorRelay
1) Basic introduction
BehaviorRelayAs aVariableA replacement has emerged. It’s also true in natureBehaviorSubjectSo it must also be created with a default initial value.
BehaviorRelaywithBehaviorSubjectTo send the last one to its subscriberseventAnd the ones that are created after thatevent.
withBehaviorSubjectThe difference is that manual feeding is not required and cannot be doneBehaviorReplysendcompletedorerrorEvents to end it (BehaviorRelayWill not be automatically sent when destroyed.complete 的 event).
BehaviorRelayThere is avalueProperty by which we can get the latest value. And what goes through itaccept()Method can modify values.
(2) aboveVariableWe can change the sample toBehaviorRelay, the code is as follows:
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
overridefuncviewDidLoad(a) {
super.viewDidLoad()
let disposeBag = DisposeBag(a)// Create a BehaviorRelay with an initial value of 111let subject = BehaviorRelay<String>(value: "111")
// Change the value
subject.accept("222")
// First subscription
subject.asObservable().subscribe {
print("1st subscription:", $0)
}.disposed(by: disposeBag)
// Change the value
subject.accept("333")
// Second subscription
subject.asObservable().subscribe {
print("Second subscription:", $0)
}.disposed(by: disposeBag)
// Change the value
subject.accept("444")}}Copy the code
Running results:
(3) If you want to merge the new value to the original value, you can passaccept()The methods andvalueProperty to implement. (This is often used with pull and load functions on tables,BehaviorRelayTo save all loaded data)
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
overridefuncviewDidLoad(a) {
super.viewDidLoad()
let disposeBag = DisposeBag(a)// Create a BehaviorRelay that starts with an array of one elementlet subject = BehaviorRelay"[String]>(value: ["1"])
// Change the value
subject.accept(subject.value + ["2"."3"])
// First subscription
subject.asObservable().subscribe {
print("1st subscription:", $0)
}.disposed(by: disposeBag)
// Change the value
subject.accept(subject.value + ["4"."5"])
// Second subscription
subject.asObservable().subscribe {
print("Second subscription:", $0)
}.disposed(by: disposeBag)
// Change the value
subject.accept(subject.value + ["6"."Seven"])}}Copy the code
Transform operations refer to transformations of the original Observable sequence, similar to the conversions of CollectionType in Swift.
2.7.1 buffer
(1) Basic introduction
The buffer method is a buffer combination. The first parameter is the buffer time, the second parameter is the number of buffers, and the third parameter is the thread. This method simply caches new elements emitted by an Observable, and when the number of elements reaches a certain number or a certain amount of time passes, it sends the collection of elements out.
Instance 2.7.1
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
let disposeBag = DisposeBag(a)overridefuncviewDidLoad(a) {
let subject = PublishSubject<String> ()// Each cache of 3 elements is combined and emitted together.// If there are less than 3 arrays in 1 second, the array is also emitted (if there are several arrays, none of them are empty arrays).
subject
.buffer(timeSpan: 1.count: 3, scheduler: MainScheduler.instance)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
subject.onNext("a")
subject.onNext("b")
subject.onNext("c")
subject.onNext("1")
subject.onNext("2")
subject.onNext("3")}}Copy the code
Running results:
2.7.2 window
(1) Basic introduction
The window operator is very similar to buffer. Buffers periodically send cached elements, whereas Windows periodically send elements as observables. At the same time, the buffer will not issue the element sequence until the element is collected. Windows emits sequences of elements in real time.
Instance 2.7.2
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
let disposeBag = DisposeBag(a)overridefuncviewDidLoad(a) {
let subject = PublishSubject<String> ()// Every three elements is emitted as a child Observable.
subject
.window(timeSpan: 1.count: 3, scheduler: MainScheduler.instance)
.subscribe(onNext: { [weakself] inprint("subscribe: \ [$0)")
$0.asObservable()
.subscribe(onNext: { print($0) })
.disposed(by: self! .disposeBag) }) .disposed(by: disposeBag) subject.onNext("a")
subject.onNext("b")
subject.onNext("c")
subject.onNext("1")
subject.onNext("2")
subject.onNext("3")}}Copy the code
Running results:
2.7.3 map
This operator converts an Observable into a new Observable by passing in a function closure.
Instance 2.7.3
let disposeBag = DisposeBag(a)Observable.of(1.2.3).map{$0 * 10}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Result: 10, 20, 30
2.7.4 flatMap
(1) Basic introduction
mapIt is easy to “raise dimension” when doing transformations. That is, after the transformation, you go from a sequence to a sequence of sequences.
whileflatMapThe operator will apply to the sourceObservableApply a conversion method to each element of theObservables. And then take thoseObservablesThe element is merged before being sent out. That is to “flatten” it into oneObservableSequence.
This operator is very useful. Such as whenObservableThe element Bunsen has the othersObservableWhen, we can put all the childrenObservablesThe element is sent.
Instance 2.7.4
let disposeBag = DisposeBag(a)let subject1 = BehaviorSubject(value: "A")
let subject2 = BehaviorSubject(value: "1")
let variable = Variable(subject1)
variable.asObservable()
.flatMap { $0 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
subject1.onNext("B")
variable.value = subject2
subject2.onNext("2")
subject1.onNext("C")
Copy the code
Running results:
2.7.5 flatMapLatest
The only difference between flatMapLatest and flatMap is that flatMapLatest only receives the latest value event.
Example 2.7.5: Here we change the flatMap in the previous example to flatMapLatest
let disposeBag = DisposeBag(a)let subject1 = BehaviorSubject(value: "A")
let subject2 = BehaviorSubject(value: "1")
let variable = Variable(subject1)
variable.asObservable()
.flatMapLatest { $0 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
subject1.onNext("B")
variable.value = subject2
subject2.onNext("2")
subject1.onNext("C")
Copy the code
Running results:
2.7.6 flatMapFirst
(1) Basic introduction
FlatMapFirst is the opposite of flatMapLatest: flatMapFirst only receives the initial value event.
This operator prevents repeated requests: clicking a button to send a request, for example, should not continue until the request is complete. The flatMapFirst operator should be used.
Example 2.7.6: Here we change flatMapLatest from the previous example to flatMapFirst.
let disposeBag = DisposeBag(a)let subject1 = BehaviorSubject(value: "A")
let subject2 = BehaviorSubject(value: "1")
let variable = Variable(subject1)
variable.asObservable()
.flatMapFirst { $0 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
subject1.onNext("B")
variable.value = subject2
subject2.onNext("2")
subject1.onNext("C")
Copy the code
Running results:
2.7.7 concatMap
(1) Basic introduction
The only difference between concatMap and flatMap is that a subsequent Observable can emit elements only after the current one has been sent. Or wait for the previous Observable to generate and complete the event before subscribing to the next Observable.
Instance 2.7.7
let disposeBag = DisposeBag(a)let subject1 = BehaviorSubject(value: "A")
let subject2 = BehaviorSubject(value: "1")
let variable = Variable(subject1)
variable.asObservable()
.concatMap { $0 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
subject1.onNext("B")
variable.value = subject2
subject2.onNext("2")
subject1.onNext("C")
subject1.onCompleted() // The next sequence can only be received after the previous sequence endsCopy the code
Running results:
2.7.8 scan
(1) Basic introduction
Scan is to give an initial number, and then continuously take the previous result and the latest value for processing operation.
Instance 2.7.8
let disposeBag = DisposeBag(a)Observable.of(1.2.3.4.5)
.scan(0) { acum, elem in
acum + elem
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
The results
2.7.9 groupBy
(1) Basic introduction
The groupBy operator breaks up the source Observable into sub-Observables and sends them out. That is, the operator groups elements by a key and sends the grouped element sequence as an Observable.
Instance 2.7.9
let disposeBag = DisposeBag(a)// Divide odd and even numbers into two groupsObservable<Int>.of(0.1.2.3.4.5)
.groupBy(keySelector: { (element) -> Stringinreturn element % 2= =0 ? "Even" : "Base"
})
.subscribe { (event) inswitch event {
case .next(let group):
group.asObservable().subscribe({ (event) inprint("The key:\(group.key)The event:\(event)")
})
.disposed(by: disposeBag)
default:
print("")
}
}
.disposed(by: disposeBag)
Copy the code
Running results:
2.8 Filter operators: filter, take, skip, etc
Filtering refers to sending specific data from a source Observable.
2.8.1 filter
(1) Basic introduction
This operator is used to filter out certain events that do not meet the requirements.
Instance 2.8.1
let disposeBag = DisposeBag(a)Observable.of(2.30.22.5.60.3.40 ,9).filter{$0 > 10
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
2.8.2 distinctUntilChanged
This operator is used to filter out continuously repeated events.
Instance 2.8.2
let disposeBag = DisposeBag(a)Observable.of(1.2.3.1.1.4)
.distinctUntilChanged()
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running results:
2.8.3 single
(1) Basic introduction
Restrict sending of only one event, or the first event that satisfies the condition. An error event is raised if there are multiple events or no events. If there is only one event, no error event is raised.
This method implementation only handles events at a specified location.
Instance 2.8.4
let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4)
.elementAt(2)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running result: 3
2.8.5 ignoreElements
(1) Basic introduction
This operator can ignore all elements and only issue an error or completed event. We can use the ignoreElements operator if we don’t care about any of the Observable’s elements and just want to know when the Observable terminates.
Instance 2.8.5
let disposeBag = DisposeBag(a)Observable.of(1.2.3.4)
.ignoreElements()
.subscribe{
print($0)
}
.disposed(by: disposeBag)
Copy the code
Result: completed
2.8.6 take
This implementation sends only the first n events in the Observable sequence, and.completed is automatically completed when the number is satisfied.
Instance 2.8.6
let disposeBag = DisposeBag(a)Observable.of(1.2.3.4)
.take(2)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running results: 1 2
2.8.7 takeLast
This implementation sends only the last n events in the Observable sequence.
Instance 2.8.7
let disposeBag = DisposeBag(a)Observable.of(1.2.3.4)
.takeLast(1)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running result: 4
2.8.8 skip
This method skips the first n events emitted by the source Observable sequence.
Instance 2.8.8
let disposeBag = DisposeBag(a)Observable.of(1.2.3.4)
.skip(2)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running results: 3 4
2.8.9 Sample
In addition to subscribes to the source Observable, Sample can also monitor another Observable, namely, notifier.
Each time a Notifier event is received, the latest event is fetched from the source sequence and sent. If there is no event in the source sequence between notifier events, no value is sent.
Instance 2.8.9
let disposeBag = DisposeBag(a)let source = PublishSubject<Int> ()let notifier = PublishSubject<String>()
source
.sample(notifier)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
source.onNext(1)
// Make the source sequence receive the receive message
notifier.onNext("A")
source.onNext(2)
// Make the source sequence receive the receive message
notifier.onNext("B")
notifier.onNext("C")
source.onNext(3)
source.onNext(4)
// Make the source sequence receive the receive message
notifier.onNext("D")
source.onNext(5)
// Make the source sequence receive the receive message
notifier.onCompleted()
Copy the code
Running results:
1, 2, 4, 5
2.8.10 debounce
(1) Basic introduction
The debounce operator, which can be used to filter out high-frequency elements, emits only the element after which no new element has been created for a period of time.
In other words, the element in the queue will be filtered out if the interval between the element and the next element is less than the specified interval.
Debounce is often used when a user types, instead of sending an event for each letter typed, it waits for the last event to be taken.
Instance 2.8.10:
import UIKit
import RxSwift
import RxCocoa
classViewController: UIViewController{
let disposeBag = DisposeBag(a)overridefuncviewDidLoad(a) {
// Define the value of each event and the time it was sentlet times = [
[ "value": 1."time": 0.1 ],
[ "value": 2."time": 1.1 ],
[ "value": 3."time": 1.2 ],
[ "value": 4."time": 1.2 ],
[ "value": 5."time": 1.4 ],
[ "value": 6."time": 2.1]]// Generate the corresponding Observable and subscribeObservable.from(times)
.flatMap { item inreturnObservable.of(Int(item["value"]!) ) .delaySubscription(Double(item["time"]!) , scheduler:MainScheduler.instance)
}
.debounce(0.5, scheduler: MainScheduler.instance) // Emit only elements more than 0.5 seconds apart from the next one
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
}
}
Copy the code
Running results: 1 5 6
2.9 Conditional and Boolean operators: AMb, takeWhile, skipWhile, etc
Conditional and Boolean operations emit or transform Observables based on conditions, or perform Boolean operations on them.
2.9.1 amb
When multiple Observables are passed to the AMB operator, it takes the first emitted element or Observable that generated the event, and emits only its element. And ignore the other Observables.
The method in turn determines whether each value of the Observable sequence satisfies a given condition. It completes automatically when the first value that does not meet the condition appears.
Instance 2.9.2
let disposeBag = DisposeBag(a)Observable.of(2.3.4.5.6)
.takeWhile { $0 < 4 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running results: 2 3
2.9.3 takeUntil
Basic introduction
In addition to subscriptionsObservableOutside,takeUntilMethod we can also monitor another oneObservable, i.e.,notifier.
ifnotifierA value orcompleteNotice, then sourceObservableAutomatically completes, and stops sending events.
Ditto belowtakeUntilThe same,skipUntilIn addition to subscriptionsObservableOutside,skipUntilMethod we can also monitor another oneObservable, i.e.,notifier 。
withtakeUntilOn the contrary. The sourceObservableSequence events are skipped by default untilnotifierA value orcompleteNotice.
2.10 Combine operators such as startWith, Merge, and zip
2.10.1 startWith
Basic introduction:
This method inserts event elements before the Observable sequence starts. These pre-inserted event messages are emitted before the event message is emitted
Illustration:
Instance 2.10.1
let disposeBag = DisposeBag(a)Observable.of("2"."3")
.startWith("1")
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running results:
1 2 3
Example 2.10.1.1: Multiple data can be inserted
let disposeBag = DisposeBag(a)Observable.of("2"."3")
.startWith("a")
.startWith("b")
.startWith("c")
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Copy the code
Running results:
c b a 2 3
2.10.2 merge
Basic introduction:
This method merges multiple (two or more) Observable sequences into one Observable.
This method compresses multiple (two or more) Observables into a single Observable. And it waits until each Observable event corresponds to one another before merging.
Zip is often used to consolidate network requests:
For example, if we want to send two requests at the same time, only after both requests are successful, we can combine the results of the two requests and continue processing. This can be done with zip.
// First requestlet userRequest: Observable<User> = API.getUser("me")
// Second requestlet friendsRequest: Observable<Friends> = API.getFriends("me")
// Combine the two requestsObservable.zip(userRequest, friendsRequest) {
user, friends in// Combine two signals into one signal and compress it into a tuple to return (both signals were successful)return (user, friends)
}
.observeOn(MainScheduler.instance) // This is added because the request is in the background thread, and the following bindings are in the foreground thread.
.subscribe(onNext: { (user, friends) in// Bind data to the interface/ /...
})
.disposed(by: disposeBag)
Copy the code
2.10.4 combineLatest
Basic introduction:
This method also combines multiple (two or more)ObservableSequence elements are merged.
But with thezipThe difference is, whenever any one of themObservableWhen a new event is emitted, it will send eachObservableThe latest event element of the sequence is merged.
