6

目前我已经创建了一个函数unwrapOptional来安全地解开流中的可选输入。

    func unwrapOptional<T>(x: Optional<T>) -> Observable<T> {
       return x.map(Observable.just) ?? Observable.empty()
    }

    let aOpt: String? = "aOpt"
    _ = Observable.of(aOpt).flatMap(unwrapOptional).subscribeNext { x in print(x)}

    let aNil: String? = nil
    _ = Observable.of(aNil).flatMap(unwrapOptional).subscribeNext { x in print(x)}

    let a: String = "a"
    _ = Observable.of(a).flatMap(unwrapOptional).subscribeNext { x in print(x)}

   // output 
    aOpt
    a

我要存档的是创建一个方便的功能而不是使用flatMap(unwrapOptional)，例如

Observable.of(a).unwrapOptional()

我试图做的事情，但它永远不会编译......

extension ObservableType {
    func unwrapOptional<O : ObservableConvertibleType>() -> RxSwift.Observable<O.E> {
        return self.flatMap(unwrapOptional)
    }
}
4

4 回答 4

9

您希望该unwrapOptional方法仅适用于具有可选类型的可观察对象。

因此，您必须以某种方式约束ElementofObservable以符合Optional协议。

extension Observable where Element: OptionalType {
    /// Returns an Observable where the nil values from the original Observable are
    /// skipped
    func unwrappedOptional() -> Observable<Element.Wrapped> {
        return self.filter { $0.asOptional != nil }.map { $0.asOptional! }
    }
}

不幸的是，Swift 没有定义这样的协议 ( OptionalType)。所以你还需要自己定义

/// Represent an optional value
///
/// This is needed to restrict our Observable extension to Observable that generate
/// .Next events with Optional payload
protocol OptionalType {
    associatedtype Wrapped
    var asOptional:  Wrapped? { get }
}

/// Implementation of the OptionalType protocol by the Optional type
extension Optional: OptionalType {
    var asOptional: Wrapped? { return self }
}
于 2016-04-22T08:15:09.133 回答
6

unwrap在https://github.com/RxSwiftCommunity/RxSwift-Ext结帐:)

或https://github.com/RxSwiftCommunity/RxOptional

目前，您应该将其RxOptional用于您的个人需求
但是，RxSwift-Ext在接下来的 2-3 个月内将呈指数增长 :)

于 2016-04-19T15:50:44.717 回答
4

RxSwift 现在支持compactMap()。因此，现在您可以执行以下操作：

func unwrap(_ a: Observable<Int?>) -> Observable<Int> {
  return a.compactMap { $0 }
}
于 2020-06-18T14:52:59.587 回答
3

这是一个不需要的版本OptionalType（来自https://stackoverflow.com/a/36788483/13000）

extension Observable {

    /// Returns an `Observable` where the nil values from the original `Observable` are skipped
    func unwrap<T>() -> Observable<T> where Element == T? {
        self
            .filter { $0 != nil }
            .map { $0! }
    }
}
于 2020-05-06T13:03:24.060 回答