rxswift bind(onNext:VS subscription(onNext:

时间:2019-03-22 06:50:35

标签: rx-swift rx-cocoa

我有2个问题:

  1. 'bind(onNext:')和'subscribe(onNext:')之间有什么区别?
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)
  1. a没有asObservable(),但是可执行性很好。 a和b的区别是什么?
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() }

1 个答案:

答案 0 :(得分:4)

'bind(onNext:')和'subscribe(onNext:')之间有什么区别?

如果我们检查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

a没有asObservable(),但是可执行性很好。 a和b的区别是什么?

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上定义),只会增加少量开销。