Typescript 角度2合并观测值

我在获取一些可观测数据方面遇到了困难。我好像找不到两个 可以观察到把尼斯放在一起。他们自己干得很好，但我 两者都需要

db.glass.subscribe（（glass:GlassData[]）：void=>{
console.log（glass）；//这个打印
});
db.casted_designs.subscribe（（卡带：卡带数据[]）：void=>{
console.log（磁带）：//这会打印
});

由于不太熟悉可见光，我尝试的第一件事是 将一个嵌套在另一个中，但内部的一个似乎没有任何作用

db.glass.subscribe（（glass:GlassData[]）：void=>{
console.log（glass）；//这个打印
db.casted_designs.subscribe（（卡带：卡带数据[]）：void=>{
console.log（磁带）：//这不是
});
});

这似乎有点傻，所以我在谷歌上搜索，看看是否有一个 更好的方法来组合观测值，结果有几个。我试过了

zip

和

forkJoin

因为它们看起来最像我想做的，但是 他们也没办法

Observable.zip（db.casted_设计，db.glass，（casteds:casteddata[]，glass:GlassData[]）：void=>{
console.log（磁带）；//不打印
console.log（glass）；//不打印
});
可观察。forkJoin（[db.caste_designs，db.glass]）。订阅（（数据：any）：void=>{
console.log（数据）；//不打印
});

这可能很简单，因为我没有正确调用函数，但是 我本以为我会在某个时候得到某种警告或错误<代码>tsc 代码没有任何问题，我在开发人员中没有收到任何消息 Chrome或Firefox上的控制台

更新 我尝试了

combinelatetest

，但它仍然没有在控制台中显示任何内容。我肯定错过了什么，但我不知道是什么。他们各自工作

可观察。组合测试（db.CASE_设计，db.glass，（卡带：卡带数据[]，玻璃：玻璃数据[]）：void=>{
console.log（磁带）；//不打印
console.log（glass）；//无法打印
});

通过以下方式创建可观察对象：

。。。
公共侦听（事件：字符串）：可观察
{
返回新的可观察对象（（订阅方：订阅方）：订阅=>{
const listen_func=（res:Response）：void=>subscriber.next（res）；
this.\u socket.on（事件，侦听函数）；
返回新订阅（（）：void=>
此._socket.removeListener（事件，侦听函数））；
});
}
...

然后，为了实际获得观测值，我发送了一个侦听器，以获取相关事件的响应。e、 g

。。。
公共卡式磁带机设计：可观察；
...
this.caste\u designs=\u socket.Listen（“获取\u caste\u designs”）
.map（（res:Response）=>res.data.data）；

嘿，如果你想要一个单独的流（可观测的）来发射两个源的组合数据，请检查

CombineTest

方法。

这两种方法：observable.zip和observable.forkJoin都必须工作。（就个人而言，我更喜欢‘forkJoin’——它返回一个顺序相同的数组，因为您推送了可观察对象，并且不需要太多参数）

---

也许，如果您正在手动创建观察对象（Observable.create…），您只是忘记了从“create”方法为两个提供的观察者调用“completed”。

我通过实际订阅结果，成功地使

CombineRelatest

工作 可见的

最初我是这样做的：

可观察。组合测试（db.CASE_设计，db.glass，（卡带：卡带数据[]，玻璃：玻璃数据[]）：void=>{
控制台日志（磁带）；
控制台。原木（玻璃）；
});

现在我要做的是：

Observable.combinelatetest（db.caste\u designs，db.glass）。订阅（（数据：any[]）：void=>{
控制台日志（数据）；
//磁带-数据[0]
//玻璃-数据[1]
});

要跟进您的发现：

1） 可观察的

是一种延迟执行数据类型，这意味着它在订阅之前不会执行管道中的任何内容。这也适用于组合运算符
zip
、
forkJoin
、
combinelatetest
和
withLatestFrom
都将递归订阅
可观察对象，只有在它们本身拥有订阅后，您才会传递它们

因此：

var output = Observable.combinelatest(stream1, stream2, (x, y) => ({x, y}));

在您调用
output.subscribe（）
之前，实际上不会执行任何操作，此时
subscribe
也会在
stream1
和
stream2
上被调用，您将获得Rx的所有魔力

2） 更次要的一点是，每当您开始创建自己的方法时，请首先查看文档，看看它是否已经存在。有用于、
数组
、
承诺
、节点样式回调和yes-even-standard的静态创建方法

因此，您的
Listen
方法可以变成：

public Listen<R>(event: string): Observable<R> {
  return Observable.fromEvent(this._socket, event);
}

公共侦听（事件：字符串）：可观察{
返回可观察的.fromEvent（此._套接字，事件）；
}
我使用了组合测试。我需要三个API调用，但我只需要一个对象来组合这三个响应

我遵循了同一篇文章中提到的公式：

var output = Observable.combinelatest(stream1, stream2, (x, y) => ({x, y}));

作为最终代码：

getGobalStats(): Observable<any> {

    let obs1 = this._http.get(this._config.getGlobalStatsUrl(), this._config.getOptions())
      .map((res: Response) => {
        return res.json().content;
      })
      .catch((error: any) => { console.error(error); return error; });
    let obs2 = this._http.get(this._config.getGlobalStatsUrl() + '?type=1', this._config.getOptions())
      .map((res: Response) => {
        return res.json().content;
      })
      .catch((error: any) => { console.error(error); return error; });
    let obs3 = this._http.get(this._config.getGlobalStatsUrl() + '?type=3', this._config.getOptions())
      .map((res: Response) => {
        return res.json().content;
      })
      .catch((error: any) => { console.error(error); return error; });

      return Observable.combineLatest(obs1,obs2,obs3,(res1,res2,res3) => { return {all:res1,running: res2, cycling: res3}});
  }

getGobalStats（）：可观察{
设obs1=this.\u http.get（this.\u config.getGlobalStatsUrl（），this.\u config.getOptions（））
.map（（res:Response）=>{
返回res.json（）.content；
})
.catch（（错误：any）=>{console.error（错误）；返回错误；}）；
设obs2=this.\u http.get（this.\u config.getGlobalStatsUrl（）+'？type=1'，this.\u config.getOptions（））
.map（（res:Response）=>{
返回res.json（）.content；
})
.catch（（错误：any）=>{console.error（错误）；返回错误；}）；
让obs3=this.\u http.get（this.\u config.getGlobalStatsUrl（）+'？type=3'，this.\u config.getOptions（））
.map（（res:Response）=>{
        Observable.merge(
            Observable.fromEvent(canvasEl, 'mousedown'), Observable.fromEvent(canvasEl, 'touchstart'))
            .switchMap((e) => {
                return Observable.merge(
                    Observable.fromEvent(canvasEl, 'mousemove').takeUntil(Observable.fromEvent(canvasEl, 'mouseup')),
                    Observable.fromEvent(canvasEl, 'touchmove').takeUntil(Observable.fromEvent(canvasEl, 'touchend')),
                )
                    .pairwise()
            })
            .subscribe(...