RxSwift教程 （warnings）

referingTo：https://github.com/ReactiveX/RxSwift/blob/master/Documentation/Warnings.md
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: Observable…
xs
.filter{…}
.map{…}
.switchLatest()
.subscribe(onNext: {
…
}, onError: {
///
})
The subscribe function returns a subscription Disposable that cn be used to cancel computation and free resources.However,not using it(and thus not disposing it)will result in an error.
The preferred way of termiating these fluent calls is by using a DisposeBag,either through chaining a call to .disposed(by: disposeBag)or by adding the disposable directly to the bag.
let xs: Observable…
let disposeBag = DisposeBag()
xs
.filter {…}
.map{…}
.switchLatest()
.subscribe(onNext: {
} ,onError:{

})
.disposed(by:disposeBag)//note .disposed(by:)
When disposeBag gets deallocated,the disposables contained within it will be automatically disposed as well.In the case where xs terminates in a predictable way with either a completed or Error message,not handling the subscription Disposable won’t leak any resources.However,even in this case,using a dispose bag is still the preferred way to handle subscription disposables.It ensures that element computation is always terminated at a predictable moment, and makes your code robust and future proof because resources will be properly disposed even if the implementation of xs changes.
Another way to make sure subscriptions and resources and tied to the lifetime of some object is by using the takeUtil operator.
let xs: Observable…
let someObject: NSObject…
_ = xs
.filter{}
.map{}
.switchLatest()
.takeUtil(someObject.deallocated)
.subscribe(onNext: {
///
}, onError:{
///
})
if ignoring the subscription Disposable is the desired behavior,this is how to silence the compiler warning.
let xs: Observable…
_ = xs//note the underscorre
.filter{}
.map{}
.switchLatest()
.subscribe(onNext:{
}, onError :{
})
Unused observable sequence(unused-observable)
You will receive a warning for doing something such as this:
let xs: Observable…
xs
.filter{}
.map{}
This code defines an observable sequence that is filtered and mapped from the xs sequence but then ignores the result.Sincethis code just defines an observable sequence and then ignores it, it doesn’t actually do anything.Your intention was probably to either store the observable sequence definition and use it later…
let xs: Observable…
let ys = xs//names definition as ys
.filter{}
.map{}
or start computation based on that definition
let xs: Observable…
let disposeBag = DisposeBag()
xs
.filter{}
.map{}
.subscribe(onNext: { nextElement in
print(nextElement)
})
.disposed(by:disposeBag)