RXJS等待其他可观察到的

我需要订阅一个结果，但要等待中间操作完成后才能获得结果。诀窍是我“访问”我的结果以填充它：

// a service that gets a model
service.getModel(): Observable<MyModel>;

// I need to enrich my model before consuming it
service.getModel()
    .makeSureAllCodesAreFetched(data => visitModel(model))
    .subscribe(data => console.log("data is ready: ", data));

// a visitor that visits the model tree and enriches the leaves
// recursively visit the branches
visitModel(model: MyModel) {
    if (model.isLeaf) {
       // on condition, call a service to fetch additional data
       service.fetchCodes(model.codeKey).subscribe(codes => model.codes = codes);
    } else {
        model.properties.forEach(prop: MyModel => visit(prop));
    }
}

//获取模型的服务
service.getModel（）：可观察；
//在消费之前，我需要丰富我的模型
service.getModel（）的
.确保所有代码均已删除（数据=>访问模型（模型））
.subscribe（data=>console.log（“数据准备就绪：”，data））；
//参观模型树并丰富树叶的访客
//递归地访问分支
visitModel（型号：MyModel）{
if（型号为isLeaf）{
//在条件满足时，调用服务获取附加数据
service.fetchCodes（model.codeKey）.subscribe（codes=>model.codes=codes）；
}否则{
forEach（prop:MyModel=>visit（prop））；
}
}

---

我尝试使用merges和forkJoin（）但没有成功。我只想确保对

fetchCodes（）

的所有调用，无论结果如何，都是在订阅数据之前完成的。

我找到了一个解决方案，但我认为它不是最干净的

// a service that gets a model
service.getModel(): Observable<MyModel>;

// I need to enrich my model before consuming it
service.getModel()
    .pipe(
        mergeMap(data => forkJoin(visitModel(model))))
    .subscribe(data => console.log("data is ready: ", data[0]));

// a visitor that visits the model tree and enriches the leaves
// recursively visit the branches
visitModel(model: MyModel, obs?: Observable<MyModel>[]): Observable<MyModel>[] {
    if (obs === undefined) {
        obs = [];
        obs.push(of(model)); // make sure the very first Observable is the root
    }
    if (model.isLeaf) {
       // on condition, call a service to fetch additional data
       // push Observable result in the array
       obs.push(service.fetchCodes(model.codeKey).map(codes => {
           model.codes = codes;
           return model;
       }));
    } else {
        model.properties.forEach(prop: MyModel => visit(prop, obs)); // recursive call
    }
    return obs;
}

//获取模型的服务
service.getModel（）：可观察；
//在消费之前，我需要丰富我的模型
service.getModel（）的
.烟斗(
mergeMap（数据=>forkJoin（visitModel（model）））
.subscribe（data=>console.log（“数据准备就绪：”，数据[0]）；
//参观模型树并丰富树叶的访客
//递归地访问分支
visitModel（模型：MyModel，obs？：可观察[]）：可观察[]{
如果（obs==未定义）{
obs=[]；
obs.push（of（model））；//确保第一个可观察到的是根
}
if（型号为isLeaf）{
//在条件满足时，调用服务获取附加数据
//在数组中推送可观察结果
obs.push（service.fetchCodes（model.codeKey）.map（codes=>{
型号代码=代码；
收益模型；
}));
}否则{
forEach（prop:MyModel=>visit（prop，obs））；//递归调用
}
返回obs；
}

---

我的访问者实际上会将对

fetchCodes（）

的所有调用附加到

可观察对象的数组中，并返回它。这样，
forkJoin
将等待所有调用完成。诀窍（和肮脏的部分）是，我必须确保第一个可观察的
实际上是我感兴趣的根元素。
我找到了一个解决方案，但我认为它不是最干净的

// a service that gets a model
service.getModel(): Observable<MyModel>;

// I need to enrich my model before consuming it
service.getModel()
    .pipe(
        mergeMap(data => forkJoin(visitModel(model))))
    .subscribe(data => console.log("data is ready: ", data[0]));

// a visitor that visits the model tree and enriches the leaves
// recursively visit the branches
visitModel(model: MyModel, obs?: Observable<MyModel>[]): Observable<MyModel>[] {
    if (obs === undefined) {
        obs = [];
        obs.push(of(model)); // make sure the very first Observable is the root
    }
    if (model.isLeaf) {
       // on condition, call a service to fetch additional data
       // push Observable result in the array
       obs.push(service.fetchCodes(model.codeKey).map(codes => {
           model.codes = codes;
           return model;
       }));
    } else {
        model.properties.forEach(prop: MyModel => visit(prop, obs)); // recursive call
    }
    return obs;
}

//获取模型的服务
service.getModel（）：可观察；
//在消费之前，我需要丰富我的模型
service.getModel（）的
.烟斗(
mergeMap（数据=>forkJoin（visitModel（model）））
.subscribe（data=>console.log（“数据准备就绪：”，数据[0]）；
//参观模型树并丰富树叶的访客
//递归地访问分支
visitModel（模型：MyModel，obs？：可观察[]）：可观察[]{
如果（obs==未定义）{
obs=[]；
obs.push（of（model））；//确保第一个可观察到的是根
}
if（型号为isLeaf）{
//在条件满足时，调用服务获取附加数据
//在数组中推送可观察结果
obs.push（service.fetchCodes（model.codeKey）.map（codes=>{
型号代码=代码；
收益模型；
}));
}否则{
forEach（prop:MyModel=>visit（prop，obs））；//递归调用
}
返回obs；
}

我的访问者实际上会将对
fetchCodes（）
的所有调用附加到
可观察对象的数组中，并返回它。这样，
forkJoin
将等待所有调用完成。诀窍（和肮脏的部分）是，我必须确保第一个可观察的
实际上是我感兴趣的根元素。
请编辑问题并添加您使用
forkJoin（）尝试的内容。
-您可能已经接近可行的解决方案。请编辑问题并添加您使用
forkJoin（）尝试的内容
-您可能已经接近一个可行的解决方案。