Rxjs 从内部平面图通知

这里有一个相当复杂的示例：

主要内容：

可观察到：

public runInstructionAndGetResult(): Observable<string> {
    return this.runAnInstruction()
        .flatMap((data) => {
            console.info("flatMap of runAnInstruction:", data);
            return this.getInstructionExecutionStatusInPolling()
                .filter(data => data != "Polling")
                .take(1)
                .flatMap((data) => {
                    console.info("flatMap of getInstructionExecutionStatusInPolling:", data);
                    return this.getInstructionResult();
                }).map((data) => {
                    console.info("Map of getInstructionResult:", data);
                    return data;
                });
        });
  }

  public runAnInstruction(): Observable<string> {
    return Observable.of("StartRun");
  }

  public getInstructionResult(): Observable<string> {
    return Observable.of("FinalResult");
  }

  public getInstructionExecutionStatusInPolling(): Observable<string> {
    return Observable.interval(1000)
        .concatMap(data => {
            return this.getInstructionExecutionStatus();
        });
  }

  public getInstructionExecutionStatus(): Observable<string> {
    return Observable.of("Polling", "Terminate");
  }

public runInstructionAndGetResult（）：可观察{
返回此.runAnInstruction（）
.flatMap（（数据）=>{
console.info（“运行说明的平面图：”，数据）；
返回此值。GetInstructionExecutionStatusInPoll（）
.filter（数据=>数据！=“轮询”）
.采取（1）
.flatMap（（数据）=>{
console.info（“getInstructionExecutionStatusInPolling的平面图：”，数据）；
返回此.getInstructionResult（）；
}).map（（数据）=>{
console.info（“getInstructionResult的映射：”，数据）；
返回数据；
});
});
}
公共运行说明（）：可观察{
可观测的回报（“StartRun”）；
}
public getInstructionResult（）：可观察{
可观察的回报（“最终结果”）；
}
public GetInstructionExecutionStatusInPoll（）：可观察{
可观测返回间隔（1000）
.concatMap（数据=>{
返回此.getInstructionExecutionStatus（）；
});
}
public getInstructionExecutionStatus（）：可观察{
可观察的返回（“轮询”、“终止”）；
}

这里是普朗克：

主要的问题是，我只想被告知关于内部流和外部流的“进化”

现在，只有当所有内部平面图都完成时，主屏幕上才有“下一个”事件。

如何获取通知？如何向主流发送显式值（例如在轮询期间）

---

谢谢。

我找到了一个分享的解决方案

普朗克更新如下：

基本上，我使用以下方法创建了一个简单的可观察对象：

然后我以编程方式调用下一个方法并最终完成：

 public runInstructionAndGetResult(): Observable<string> {
    return Observable.create((ops)=> {
      ops.next(1);
      this.runAnInstruction()
        .concatMap((data) => {
            ops.next(2);
            console.info("flatMap of runAnInstruction:", data);
            return this.getInstructionExecutionStatusInPolling()
                .filter(data => data != "Polling")
                .take(1)
                .concatMap((data) => {
                    ops.next(3);
                    console.info("flatMap of getInstructionExecutionStatusInPolling:", data);
                    return this.getInstructionResult();
                }).map((data) => {
                    console.info("Map of getInstructionResult:", data);
                    ops.next(4);
                    ops.complete();
                    return data;
                });
        }).subscribe();
        });
  }

public runInstructionAndGetResult（）：可观察{
返回可观察。创建（（ops）=>{
行动计划下（1）；
这个.runAnInstruction（）
.concatMap（（数据）=>{
行动计划下一阶段（2）；
console.info（“运行说明的平面图：”，数据）；
返回此值。GetInstructionExecutionStatusInPoll（）
.filter（数据=>数据！=“轮询”）
.采取（1）
.concatMap（（数据）=>{
行动计划下一阶段（3）；
console.info（“getInstructionExecutionStatusInPolling的平面图：”，数据）；
返回此.getInstructionResult（）；
}).map（（数据）=>{
console.info（“getInstructionResult的映射：”，数据）；
行动计划下一阶段（4）；
ops.complete（）；
返回数据；
});
}).subscribe（）；
});
}

你能更明确地说明你想要得到什么样的结果吗？或者您希望在控制台中看到什么输出。我不明白这是怎么回事。@martin我只想在main上订阅下一个调用，例如“StartRun”数据或“Terminate”数据。因此，如果我理解正确：您希望从一个仅以1个数据开始的流接收2个下一个调用-在这种情况下，您应该查看concat运算符，或者尝试类似于

this.runInstructionAndGetResult（）.startWith（“StartRun”）.subscribe…

 public runInstructionAndGetResult(): Observable<string> {
    return Observable.create((ops)=> {
      ops.next(1);
      this.runAnInstruction()
        .concatMap((data) => {
            ops.next(2);
            console.info("flatMap of runAnInstruction:", data);
            return this.getInstructionExecutionStatusInPolling()
                .filter(data => data != "Polling")
                .take(1)
                .concatMap((data) => {
                    ops.next(3);
                    console.info("flatMap of getInstructionExecutionStatusInPolling:", data);
                    return this.getInstructionResult();
                }).map((data) => {
                    console.info("Map of getInstructionResult:", data);
                    ops.next(4);
                    ops.complete();
                    return data;
                });
        }).subscribe();
        });
  }