我有2个问题:
struct Info {
var index: Int?
var data: String?
}
let infoData: BehaviorRelay<Info> = BehaviorRelay<Info>(value: Info())
var osInfo: Observable<String> { return self.infoData.map({ return $0.data }).distinctUntilChanged() }
osInfo.bind { (target) in
print("bind!")
}.disposed(by: self.disposeBag)
osInfo.subscribe { (target) in
print("subscribe!")
}
.disposed(by: self.disposeBag)
a. var osInfo: Observable<String> { return self.infoData.map({ return $0.data }).distinctUntilChanged() }
b. var osInfo: Observable<String> { return self.infoData.asObservable().map({ return $0.data }).distinctUntilChanged() }
答案 0 :(得分:4)
如果我们检查bind(...)
的实现,我们发现它只做subscribe(...)
的工作,并且在调试时由于错误而崩溃:
/**
Subscribes an element handler to an observable sequence.
In case error occurs in debug mode, `fatalError` will be raised.
In case error occurs in release mode, `error` will be logged.
- parameter onNext: Action to invoke for each element in the observable sequence.
- returns: Subscription object used to unsubscribe from the observable sequence.
*/
public func bind(onNext: @escaping (E) -> Void) -> Disposable {
return subscribe(onNext: onNext, onError: { error in
rxFatalErrorInDebug("Binding error: \(error)")
})
}
通过使用bind(onNext)
,您可以表示流永远不会发出错误,并且您只对项目事件感兴趣。
因此,如果您对错误/完成/处置事件感兴趣,则应使用subscribe(onNext:...)
,否则应使用bind(onNext...)
。但是由于它是RxCocoa
而不是RxSwift
的一部分,所以我通常在各处使用subscribe
。
map(...)
是在ObservableType
上声明的函数,并返回新的Observable
让我们从ObservableType
开始。
ObservableType
是只需要一种方法的协议:subscribe(...)
,这使他可以创建func asObservable()
的默认实现。
对您来说,这意味着您可以从符合Observable
的任何类型创建ObservableType
。
/// Represents a push style sequence.
public protocol ObservableType : ObservableConvertibleType {
func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E
}
extension ObservableType {
/// Default implementation of converting `ObservableType` to `Observable`.
public func asObservable() -> Observable<E> {
// temporary workaround
//return Observable.create(subscribe: self.subscribe)
return Observable.create { o in
return self.subscribe(o)
}
}
}
因此,每次调用asObservable()
底层引擎时,RxSwift都会在流周围创建新的Observable
包装器。
如果检查BehaviourRelay
的来源,也会发现它也符合ObservableType
。因此,您可以随时从中创建Observable
:
public final class BehaviorRelay<Element>: ObservableType { ... }
现在让我们检查map
功能:
extension ObservableType {
/**
Projects each element of an observable sequence into a new form.
- seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
- parameter transform: A transform function to apply to each source element.
- returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
*/
public func map<R>(_ transform: @escaping (E) throws -> R)
-> Observable<R> {
return self.asObservable().composeMap(transform)
}
}
如预期的那样map
,只需在内部调用asObservable()
并在新的Observable
上进行操作。
如果我们“解开” map
电话,我们将得到:
var osInfoA: Observable<String> {
return infoData
.asObservable()
.composeMap { $0.data }
.distinctUntilChanged()
}
var osInfoB: Observable<String> {
return infoData
.asObservable()
.asObservable()
.composeMap { $0.data }
.distinctUntilChanged()
}
由于composeMap
是内部函数,但是您已经有了主要思想,因此可以确定它不会编译。
在其他运算符之前调用asObservable
是多余的(大多数运算符在ObservableType
上定义),只会增加少量开销。