Typescript 完成时发出相同可见光的可见光链

我希望在rxjs中做到这一点：

• 我有N个http调用
• 我想按顺序拨打这些电话
• 我想把每次调用的结果映射到一个可观察的信息流中

非工作伪代码：

class InfoMessage {
  constructor(public message: string) {}
}

doAllRequests() : Observable<InfoMessage> {
    return Observable.create((obs: Observer<InfoMessage>) => {
      doRequest("http://test1.com").map((res: RxRequestResponse) => obs.next(new InfoMessage("request1 done")));
      doRequest("http://test2.com").map((res: RxRequestResponse) => obs.next(new InfoMessage("request2")));
      doRequest("http://test3.com").map((res: RxRequestResponse) => obs.next(new InfoMessage("request3")));
      obs.complete();
    });
  }

doRequest(url: string) : Observable<RxRequestResponse> {
  // use some http client which is wrapped in an Observable of type RxRequestResponse
}

doAllRequests().subscribe(next => console("Message: " + next.message));

class信息{
构造函数（公共消息：字符串）{}
}
doAllRequests（）：可观察{
返回可观察的。创建（（obs:Observer）=>{
多勒奎斯特（”http://test1.commap（（res:RxRequestResponse）=>obs.next（新信息消息（“请求1完成”））；
多勒奎斯特（”http://test2.commap（（res:RxRequestResponse）=>obs.next（newinfomessage（“request2”））；
多勒奎斯特（”http://test3.commap（（res:RxRequestResponse）=>obs.next（newinfomessage（“request3”））；
obs.complete（）；
});
}
doRequest（url:string）：可观察{
//使用一些包装在RxRequestResponse类型的可观察对象中的http客户端
}
doAllRequests（）.subscribe（next=>console（“Message:+next.Message”）；

更新马丁建议的答案： 您的回答似乎有效，但前提是我同意第一个请求，如下所示：

Observable.create((observer: Observer<InfoMessage>) => {
  doRequest("http://test1.com")
    .do(response => observer.next(new InfoMessage("request1 done")))
    .concatMap(() => doRequest("http://test2.com"))
    .do(response => observer.next(new InfoMessage("request2")))
    .concatMap(() => doRequest("http://test3.com"))
    .do(response => {
      observer.next(new InfoMessage("request3"));
      observer.complete();
    }).subscribe();
})

Observable.create（（观察者：观察者）=>{
多勒奎斯特（”http://test1.com")
.do（response=>observer.next（newinfomessage（“request1 done”））
.concatMap（（）=>doRequest（“http://test2.com"))
.do（response=>observer.next（新的InfoMessage（“request2”））
.concatMap（（）=>doRequest（“http://test3.com"))
.do（响应=>{
observer.next（新信息消息（“request3”）；
observer.complete（）；
}).subscribe（）；
})

我真的很想推迟订阅，并将其留给doAllRequests（）的调用者。有什么想法吗

更新：昆汀建议的答案

该解决方案可以工作，而且对于我将要运行的大型脚本（有许多请求），在代码的冗长性方面（或者更确切地说是缺少代码），它可以更好地扩展

---

因为这是我现在最终使用的答案，所以我正在更改我接受的答案。但是马丁，我确实为此感到内疚。我还有一票支持你。。。好吗？

如果每个HTTP调用都独立于前一个调用的结果，那么您可以使用

concatMap

链接它们：

Observable.create((observer: Observer<InfoMessage>) => {
  doRequest("http://test1.com")
    .do(response => observer.next(new InfoMessage("request1 done")))
    .concatMap(() => doRequest("http://test2.com"))
    .do(response => observer.next(new InfoMessage("request2")))
    .concatMap(() => doRequest("http://test3.com"))
    .do(response => {
      observer.next(new InfoMessage("request3"));
      observer.complete();
    });
})

Observable.create（（观察者：观察者）=>{
多勒奎斯特（”http://test1.com")
.do（response=>observer.next（newinfomessage（“request1 done”））
.concatMap（（）=>doRequest（“http://test2.com"))
.do（response=>observer.next（新的InfoMessage（“request2”））
.concatMap（（）=>doRequest（“http://test3.com"))
.do（响应=>{
observer.next（新信息消息（“request3”）；
observer.complete（）；
});
})

---

不要忘记，您需要返回可观察的

。从您的函数创建
，然后订阅它。
如果每个HTTP调用都独立于上一次调用的结果，您可以将它们与
concatMap
链接：

Observable.create((observer: Observer<InfoMessage>) => {
  doRequest("http://test1.com")
    .do(response => observer.next(new InfoMessage("request1 done")))
    .concatMap(() => doRequest("http://test2.com"))
    .do(response => observer.next(new InfoMessage("request2")))
    .concatMap(() => doRequest("http://test3.com"))
    .do(response => {
      observer.next(new InfoMessage("request3"));
      observer.complete();
    });
})

Observable.create（（观察者：观察者）=>{
多勒奎斯特（”http://test1.com")
.do（response=>observer.next（newinfomessage（“request1 done”））
.concatMap（（）=>doRequest（“http://test2.com"))
.do（response=>observer.next（新的InfoMessage（“request2”））
.concatMap（（）=>doRequest（“http://test3.com"))
.do（响应=>{
observer.next（新信息消息（“request3”）；
observer.complete（）；
});
})

别忘了你需要返回可观察的。从你的函数中创建并订阅它。
既然你的
doRequest（）
已经返回了一个可观察的，你为什么不尝试将所有的请求合并成一个流呢？您可以使用forkJoin进行以下操作：

doAllRequests() : Observable<InfoMessage> {
 return forkJoin(
  doRequest("http://test1.com"),
  doRequest("http://test2.com"),
  doRequest("http://test3.com")
 ).pipe(
  mergeMap((responsesArray: any[]) => from(responsesArray)),
  map((response: any) => new InfoMessage(response))
 );
}
this.doAllRequests().subscribe();

doAllRequests（）：可观察{
返回叉连接(
多勒奎斯特（”http://test1.com"),
多勒奎斯特（”http://test2.com"),
多勒奎斯特（”http://test3.com")
).烟斗(
合并映射（（responsesArray:any[]）=>from（responsesArray）），
map（（响应：any）=>newinfomessage（响应））
);
}
this.doAllRequests（）.subscribe（）；
既然您的
doRequest（）
已经返回了一个可观察的，为什么不尝试将所有请求合并到一个流中？您可以使用forkJoin进行以下操作：

doAllRequests() : Observable<InfoMessage> {
 return forkJoin(
  doRequest("http://test1.com"),
  doRequest("http://test2.com"),
  doRequest("http://test3.com")
 ).pipe(
  mergeMap((responsesArray: any[]) => from(responsesArray)),
  map((response: any) => new InfoMessage(response))
 );
}
this.doAllRequests().subscribe();

doAllRequests（）：可观察{
返回叉连接(
多勒奎斯特（”http://test1.com"),
多勒奎斯特（”http://test2.com"),
多勒奎斯特（”http://test3.com")
).烟斗(
合并映射（（responsesArray:any[]）=>from（responsesArray）），
map（（响应：any）=>newinfomessage（响应））
);
}
this.doAllRequests（）.subscribe（）；
因此，您希望在观察者完成后立即在观察者中接收每个响应，然后启动下一个http调用。@martin yessir。因此，您希望在观察者完成后立即在观察者中接收每个响应，然后启动下一个http调用。@martin yessir。我正在尝试并让您知道。提前谢谢。“return”确实应该出现在我的示例中。在尝试后更新了我的问题是的，这是真的，你需要订阅，但这并不重要，因为对
Observable.create的回调只有在订阅了这个Observable之后才会调用。我正在尝试并让你知道。提前谢谢。“return”确实应该出现在我的示例中。在尝试之后更新了我的问题是的，这是真的，你需要订阅，但这并不重要，因为对
Observable.create
的回调只有在订阅了这个Observable之后才调用。我非常喜欢这段代码的外观。谢谢你的回答，我明天就要尝试这个了。我用rxjs的最新版本和pipeable操作符编写了代码，但是我相信你可以在当前版本中找到如何编写它的方法。不要忘记，为了让forkJoin操作符发出，您传递给forkJoin的所有观察都必须完成（因为这是请求，我假设它们都已完成）。请尝试并使用它。谢谢。我真的很喜欢这个代码的外观。谢谢你的回答，我明天会试试这个。我用l写的代码