rx-swift - rxswift 绑定(bind)(onNext : VS subscribe(onNext:

Question

我有两个问题:

'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)

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() }

Answer 1

'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是只需要一种方法的协议(protocol): 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() underhood 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 上定义)并且只是增加了少量开销。