Question

我正在尝试为角度应用程序实现一个解决方案，该解决方案返回多级过程的状态并处理已发生的结果。我不想使用公共对象来处理状态和可能的错误，而是使用两个单独的通道来输出成功和错误的信息选择的方法是Observable.throw功能（link）。该方法应按如下方式调用：

myFunction(result).subscribe((status: boolean) => {
      console.log(data);          
    }, err => this.errorSub.next( err));
  }

如果程序正确完成，则调用第一个方法;如果发生错误，则调用带错误的第二个函数。

return this.service.createAndGetEntity(result.data.order)
  .map((response: EntityResponse<OrderModel>) => {

    if (result.data.unknownLocation) {
      if (result.data.isRedundant) {
        this.secondService.createWithRedundancy(someData).subscribe(() => {
          this.dispatchSuccessAction(newOrder);
          return true;
        }, (err) => {
          this.dispatchErrorAction(err);
          throw Observable.throw(err);
        });
      }
      else {
        this.secondService.createEntity(someData).subscribe(() => {
          this.dispatchSuccessAction(newOrder);
          return true;
        }, (err) => {
          this.dispatchErrorAction(err);
          throw Observable.throw(err);
        });
      }
    }
    else {
      this.dispatchSuccessAction(newOrder);
      // also return true here
    }
  });

现在我的问题：为了使程序正确运行，需要相互依赖的订阅，这些订阅将根据上一步的结果依次执行。该方法最后应返回一个Observable，但我的snatz不起作用。因此，我的问题是：如何构造不同的调用，以便最后运行正确的顺序，并返回true或引发相应错误文本的错误？

Answer 1

您可以通过mergeMap运算符获得所需的结果。

import { mergeMap, map } from 'rxjs/operators';

createAndGetAntity(result) {
  return this.service.createAndGetEntity(result.data.order).pipe(
    mergeMap((response: EntityResponse<OrderModel>) => {
      if (result.data.unknownLocation) {
        if (result.data.isRedundant) {
          return this.secondService.createWithRedundancy(someData);
        } else {
          return this.secondService.createEntity(someData);
        }
      }
      return of(true);
    }),
    map(() => true),
  );
}

我会处理在订阅块中调度成功和错误操作，而不是在服务方法本身中调度。

this.service.dispatchErrorAction(result).subscribe(
  (order) => this.dispatchSuccessAction(order), 
  (err) => this.dispatchErrorAction(err)
)

设置多级和依赖的可观察量

1 个答案: