Angular rxjs：如何使foreach循环等待内部可观察

我有一个foreach循环，在这个循环中，我可能需要一个http请求来获取一些信息。我尝试在foreach循环中使用forkjoin来“让foreach循环等待可观察对象”（在本例中，只有一个可观察对象，但实际上我会有更多…）。但是有了这段代码，foreach会继续运行，而不必等待可观察对象完成，我无法找到任何解决方案来防止这种情况

非常感谢你的帮助

。。。
让愿望：愿望[]=[]；
响应.愿望.forEach（（愿望）=>{
let newWish:Wish=新愿望（Wish.\u id，Wish.title，Wish.price）；
let personObservables:Observable[]=[]；
如果（希望，预订）{
push（this.peopleService.getPersonById（wish.reservation.reservedBy））；
}否则{
personObservables.push（of（null））；
}
forkJoin（personObservables）.subscribe（[reservedBy]）=>{
如果（由保留）{
newWish.reservation={
…希望，预定，
保留的
};
}
愿望。推（新愿望）；
} );
});
...

编辑：没有foreach循环的完整工作解决方案。在管道中使用map操作符和在数组中使用map函数要容易得多。我了解到，将这种逻辑拆分为几个运算符比在一个map运算符中修复所有运算符更容易

publicGetWishList（接收者：个人）：可观察{
返回此.http$.get(
environment.apirl+'wishlist/'+receiver.id
).烟斗(
//从API响应中的每个愿望创建愿望实例，并保存保留供以后使用
映射（wishlistResponse=>
wishlistResponse[0]。wish.map（wish=>({
愿望：this.createWishInstanceFromResponse（愿望，接收者），
预订：wish.reservation
}))),
//对于每个预订的愿望：获取“reservedBy”id的个人信息
map（wishesanderservationobjects=>wishesanderservationobjects.map（{wish，reservation}）=>
！预订？
（愿望）：
this.peopleService.getPersonById（reservation.reservedBy）
.烟斗(
地图（reservedBy=>{
if（reservedBy）wish.reservation={
…保留，
reservedBy:newperson（reservedBy.id、reservedBy.firstName、reservedBy.lastName）
}
还愿；
})
)
)),
//forkJoin所有可观察的对象，因此结果是所有愿望的数组
switchMap（reservedByObservables=>reservedByObservables.length！==0？forkJoin（reservedByObservables）：共（[]），共//https://stackoverflow.com/questions/41723541/rxjs-switchmap-not-emitting-value-if-the-input-observable-is-empty-array
//根据每个愿望（有保留或无保留）调用方法，以在每个实例中设置用户标志（必须在添加reservedBy后完成）
地图（愿望=>wisks.map（愿望=>{
wish.setUserIsFlags（this.userService.currentUser）；
还愿；
})),
//对于每个愿望：通过API调用获取状态
映射（wishesWithoutState=>wishesWithoutState.map（wishesWithoutState=>
this.http$.get（environment.apirl+'wish/'+wishWithoutState.id+'/state'）
.烟斗(
catchError（（）=>of（null）），
映射（状态=>{
wishWithoutState.status=状态；
返回未超出状态的WISH；
})
)
)),
//将所有StateObservable合并到一个数组中
switchMap（stateObservables=>stateObservables.length！==0？forkJoin（stateObservables）：of（[]））
)
}
私有createWishInstanceFromResponse（wishResponse:IWishResponse，接收者：Person）：愿望{
让愿望：愿望=新的愿望(
wishResponse.\u id，
wishResponse.title，
wishResponse.price，
...
);
还愿；
}

您可以使用

from

和

concatMap

来完成此操作

let wishes: Wish[] = [];
from(response.wishes).pipe(concatMap(wish) => {
      let newWish : Wish = new Wish( wish._id, wish.title, wish.price );
               
      let personObservables: Observable<any>[] = [];
      if (wish.reservation){
        personObservables.push(this.peopleService.getPersonById(wish.reservation.reservedBy)); 
      } else {
        personObservables.push(of(null));
      }
      return forkJoin(personObservables).pipe(tap([reservedBy]) => {
        if (reservedBy) {
          newWish.reservation = {
            ...wish.reservation,
            reservedBy
          };
        }
        wishes.push(newWish);
      }));
    }).subscribe();

让愿望成真：愿望[]=[]；
from（response.wish）.pipe（concatMap（wish）=>{
let newWish:Wish=新愿望（Wish.\u id，Wish.title，Wish.price）；
let personObservables:Observable[]=[]；
如果（希望，预订）{
push（this.peopleService.getPersonById（wish.reservation.reservedBy））；
}否则{
personObservables.push（of（null））；
}
返回forkJoin（personObservables）.管道（水龙头（[reservedBy]）=>{
如果（由保留）{
newWish.reservation={
…希望，预定，
保留的
};
}
愿望。推（新愿望）；
}));
}).subscribe（）；

您可以创建此函数来处理您的流程：

completeData（项目）：可观察{
let$apiCallItems:可观察[]=[]；
const itemsNeedServiceCall:Array=[]；
const itemsCompleted:Array=[]；
items.forEach（（项目）=>{
如果（项目预订）{
$apiCallItems.push（this.peopleService.getPersonById（item.reservation.reservedBy））；
itemsNeedServiceCall.push（项目）；
}否则{
项目完成。推送（项目）；
}
});
返回分叉连接（$apiCallItems）。管道(
地图（（r）=>{
for（设i=0；i}

作为一般规则，除非您是最终消费者，并且准备好扔掉可观察对象（不再需要），否则千万不要对可观察对象调用subscribe