RxSwift合并不同类型的观测值

我应该如何在RxSwift中合并两种不同类型的

可观察的
s

例如：

var a: Observable<Int>
var b: Observable<Void>

var a：可观测
var b：可观测

由于类型参数不同，无法观察到（a，b）.merge（）
。
要
合并它们，它们的
元素需要具有相同的类型

因此，一种选择是扔掉它们的类型信息并强制转换到
AnyObject
。现在可以合并它们：

let stringSubject = PublishSubject<String>()
let stringObservable = stringSubject.asObservable().map { $0 as AnyObject }

let intSubject = PublishSubject<Int>()
let intObservable = intSubject.asObservable().map { $0 as AnyObject }

Observable.of(stringObservable, intObservable).merge()
    .subscribeNext { print($0) }
    .addDisposableTo(disposeBag)

stringSubject.onNext("a")
stringSubject.onNext("b")
intSubject.onNext(1)
intSubject.onNext(2)
stringSubject.onNext("c")

let stringSubject=PublishSubject（）
设stringObservable=stringSubject.asObservable（）.map{$0 as AnyObject}
让intSubject=PublishSubject（）
让intObservable=intSubject.asObservable（）.map{$0 as AnyObject}
可观察的。of（可观察的，不可观察的）
.subscribebenext{print（$0）}
.addDisposableTo（disposeBag）
stringSubject.onNext（“a”）
stringSubject.onNext（“b”）
intSubject.onNext（1）
intSubject.onNext（2）
stringSubject.onNext（“c”）

输出：

a

b

1

2

c

另一个选项是将其包装在枚举中：

enum Container {
    case S(String)
    case I(Int)
}

let stringSubject = PublishSubject<String>()
let stringObservable = stringSubject.asObservable().map { Container.S($0) }

let intSubject = PublishSubject<Int>()
let intObservable = intSubject.asObservable().map { Container.I($0) }

Observable.of(stringObservable, intObservable).merge()
    .subscribeNext { e in
        switch e {
        case .S(let str):
            print("next element is a STRING: \(str)")
        case .I(let int):
            print("next element is an INT: \(int)")
        }
    }
    .addDisposableTo(disposeBag)

stringSubject.onNext("a")
stringSubject.onNext("b")
intSubject.onNext(1)
intSubject.onNext(2)
stringSubject.onNext("c")

enum容器{
案例S（字符串）
案例一（内部）
}
设stringSubject=PublishSubject（）
设stringObservable=stringSubject.asobbservable（）.map{Container.S（$0）}
让intSubject=PublishSubject（）
让intObservable=intSubject.asObservable（）.map{Container.I（$0）}
可观察的。of（可观察的，不可观察的）
.subscribeNext{e in
开关e{
案例S（let str）：
print（“下一个元素是字符串：\（str）”）
案例一（let int）：
打印（“下一个元素是INT:\（INT）”）
}
}
.addDisposableTo（disposeBag）
stringSubject.onNext（“a”）
stringSubject.onNext（“b”）
intSubject.onNext（1）
intSubject.onNext（2）
stringSubject.onNext（“c”）

输出：

下一个元素是字符串：a

下一个元素是字符串：b

下一个元素是INT:1

下一个元素是INT:2

下一个元素是字符串：c

至于其他可以组合不同类型的
可观察的
s（如
zip
和
combinelatetest
）的操作符，没有一个能像
merge
那样工作。然而，看看这些。它们可能更适合您的要求。
如果您想合并两个可观察对象，但不需要
元素的值，并且希望在使用
.map{$0 as AnyObject}
选项时，能够摆脱类型为“AnyObject”的
表达式未使用的情况：

var a = PublishSubject<Int>()
var b = PublishSubject<Void>()

let observable = Observable.merge(a.map { _ in return Void() }, b)

var a=PublishSubject（）
var b=PublishSubject（）
let observable=observable.merge（a.map{in return Void（）}，b）