Angular 从ngrx/存储效果返回forkJoin的结果

我试图使用ngrx store返回一个有效的

forkJoin

结果，如下伪代码所示：

@Effect()
someEffect$: Observable<Action> = this.action$.pipe(
    ofType<SomeActionType>(ActionTypes.SomeActionType),
    switchMap((action: any) => 
        this.http.get<any>('some/url').pipe(
            map(someResult => {
                // this implementation is unimportant, just the gist of the flow I'm after
                const potentialResults = oneOrMany(someResult);

                if( potentialResults.length === 1 )   {
                    return new SomeAction(potentialResults[0]);
                } else {
                    observables: Observable<any> = getObservables(someResult);

                    forkJoin(observables).subscribe((result) =>
                        // this is where I get stuck    
                        return new SomeAction(result);
                    )
                }
            }
        ))
)

@Effect（）
someEffect$：Observable=此.action$.pipe(
of类型（ActionType.SomeActionType），
开关映射（（操作：任意）=>
这个.http.get（'some/url'）.pipe(
映射（someResult=>{
//这个实现并不重要，只是我所追求的流程的要点
恒电位结果=一个或多个（某个结果）；
如果（potentialResults.length==1）{
返回新的SomeAction（潜在结果[0]）；
}否则{
可观测值：可观测值=获取可观测值（someResult）；
forkJoin（可观察）。订阅（（结果）=>
//这就是我被卡住的地方
返回新动作（结果）；
)
}
}
))
)

---

我如何能从

forkJoin

的结果中同步返回这样的操作？目前，我正在

forkJoin

块中直接向存储分配操作，但这相当难闻，我想知道如何使用另一个操作符（例如）在

forkJoin

块中返回此操作作为

map

或类似的东西。有什么想法吗？

你不能从map（）回调返回一个可观察的。你需要使用

switchMap（）

（或另一个

xxxMap（）

）来实现。你也不能订阅forkJoin可观察的。相反，你必须

map（）

：

someEffect$：Observable=this.action$.pipe(
of类型（ActionType.SomeActionType），
switchMap（（）=>this.http.get（'some/url'），
开关映射（someResult=>{
恒电位结果=一个或多个（某个结果）；
如果（potentialResults.length==1）{
返回（新动作（潜在结果[0]）；
}否则{
常量可观测值：数组=getObservables（someResult）；
returnforkjoin（observes）.map（结果=>newsomeAction（结果））
}
})
)

您无法从map（）回调返回可观察对象。您需要使用

switchMap（）

（或另一个

xxxMap（）

）来执行此操作。您也不能订阅forkJoin可观察对象。相反，您必须

map（）

：

someEffect$：Observable=this.action$.pipe(
of类型（ActionType.SomeActionType），
switchMap（（）=>this.http.get（'some/url'），
开关映射（someResult=>{
恒电位结果=一个或多个（某个结果）；
如果（potentialResults.length==1）{
返回（新动作（潜在结果[0]）；
}否则{
常量可观测值：数组=getObservables（someResult）；
returnforkjoin（observes）.map（结果=>newsomeAction（结果））
}
})
)

您可以创建主题并返回：

someEffect$ = createEffect(() => this.actions$.pipe(
ofType(SomeType.Save),
mergeMap(action => {
  const obsList: Observable<any>[] = createList();

  const sub: Subject<Action> = new Subject<Action>();
  forkJoin(obsList).subscribe(() => {
    sub.next(new SomeAction());
    sub.complete();
  });
  return sub;
})));

someEffect$=createEffect（（）=>this.actions$.pipe(
ofType（SomeType.Save），
合并映射（操作=>{
常量obsList:Observable[]=createList（）；
const sub:Subject=新主题（）；
forkJoin（obsList）.订阅（（）=>{
sub.next（新的SomeAction（））；
sub.complete（）；
});
返回子节点；
})));

您可以创建主题并返回：

someEffect$ = createEffect(() => this.actions$.pipe(
ofType(SomeType.Save),
mergeMap(action => {
  const obsList: Observable<any>[] = createList();

  const sub: Subject<Action> = new Subject<Action>();
  forkJoin(obsList).subscribe(() => {
    sub.next(new SomeAction());
    sub.complete();
  });
  return sub;
})));

someEffect$=createEffect（（）=>this.actions$.pipe(
ofType（SomeType.Save），
合并映射（操作=>{
常量obsList:Observable[]=createList（）；
const sub:Subject=新主题（）；
forkJoin（obsList）.订阅（（）=>{
sub.next（新的SomeAction（））；
sub.complete（）；
});
返回子节点；
})));

返回forkJoin（…）.map（result=>newsomeaction（result））

很遗憾，这不起作用-我收到一个错误，表明效果没有返回操作；可能是因为

返回
在map内，而不是
forkJoin
块
返回forkJoin（…）.map（result=>newsomeaction（结果）
不幸的是，这不起作用-我收到一个错误，表明效果没有返回动作；大概是因为
返回
在地图内，而不是
forkJoin
blockYep之外。这就是我需要的。谢谢！暂时忘记了高阶观测值是如何工作的。是的，这就是我需要的。谢谢你！暂时忘记了高阶观测是如何工作的。