Angular 为什么不尊重Observable.delay（）？

我有一个简单的HTTP调用：

  getContributors(pageNumber): Observable<any> {
    const url = `${this.apiBaseUrl}/orgs/angular/public_members?&page=${pageNumber}`;
    const requestOptions = this.getRequestOptions();

    return this.http.get(url, requestOptions);
  }

但是，虽然HTTP调用返回一个包含多个值的数组，但它们在任何情况下都是同时发出的

我是否误解了

delay（）

操作符的用途（在这种情况下，我如何实现预期的结果？）或者我使用它的方式是错误的

注意：我导入了增强

import'rxjs/add/operator/delay'

更新：澄清一下，预期结果是：我希望分割数组，并在给定（恒定）时间分别发出数组中的每个值

更新2：因此，数组实际上是由

 .flatMap(data => Observable.from(data))

事实上，如果

 .do(value => console.log(value))

每个值分别打印

但是，如果不是.do（…）

我把

.delay(3000)
.do(() => console.log(new Date())

我可以看出延迟根本不受尊重（除了它实际上等待3000才能发出all值，在一个没有延迟的序列中，即一行多个console.log）
好的，关于可观察流中的数组，它们就像流中的任何其他单个值一样。您的http调用返回一个数组值，因此它将整个数组作为一个值返回，该值一次执行所有操作。如果您想将一个数组拆分为多个值，您当然可以这样做，但您需要告诉rxjs这样做，我的首选方法是使用flatMap，如下所示：

.flatMap(arrVal => Observable.from(arrVal))

return this.contributorsService.getContributors(payload.pageNumber)
    .flatMap(data => Observable.from(data))
    .delay(Math.random() * 500) // you should just feed a ms value to delay if you want constant time interval, date parameters mean delay till that date, so they'll all just flow through at that date

return this.http.get(url, requestOptions).map(res => res.json());

此操作将把数组值展平为可观察的值流，因此您可以这样使用它：

.flatMap(arrVal => Observable.from(arrVal))

return this.contributorsService.getContributors(payload.pageNumber)
    .flatMap(data => Observable.from(data))
    .delay(Math.random() * 500) // you should just feed a ms value to delay if you want constant time interval, date parameters mean delay till that date, so they'll all just flow through at that date

return this.http.get(url, requestOptions).map(res => res.json());

但是，上述方法不起作用，因为延迟会随着时间而改变整个流，而不是每一项，因此为了实现平坦化和分离，我们需要从以下答案中得出更明确的结论：

通过这种方式，我们以均匀间隔手动展平阵列

此版本也可以使用，并且可能感觉稍微干净一些：

return this.contributorsService.getContributors(payload.pageNumber)
           .flatMap(data => Observable.from(data))
           .zip(Observable.interval(Math.random() * 500), (d,i) => d)

这只是使用zip操作符将每个项目压缩为一个可观察的间隔

现在，您应该可以看到每个数组项以固定的间隔一次通过一个。但是，如果使用http服务，可能需要在响应中调用.json（）以获取数组形式的值，如下所示：

.flatMap(arrVal => Observable.from(arrVal))

return this.contributorsService.getContributors(payload.pageNumber)
    .flatMap(data => Observable.from(data))
    .delay(Math.random() * 500) // you should just feed a ms value to delay if you want constant time interval, date parameters mean delay till that date, so they'll all just flow through at that date

return this.http.get(url, requestOptions).map(res => res.json());

好的，关于可观测流中的数组，它们就像流中的任何其他单个值一样。您的http调用返回一个数组值，因此它将整个数组作为一个值返回，该值一次执行所有操作。如果您想将一个数组拆分为多个值，您当然可以这样做，但您需要告诉rxjs这样做，我的首选方法是使用flatMap，如下所示：

.flatMap(arrVal => Observable.from(arrVal))

return this.contributorsService.getContributors(payload.pageNumber)
    .flatMap(data => Observable.from(data))
    .delay(Math.random() * 500) // you should just feed a ms value to delay if you want constant time interval, date parameters mean delay till that date, so they'll all just flow through at that date

return this.http.get(url, requestOptions).map(res => res.json());

此操作将把数组值展平为可观察的值流，因此您可以这样使用它：

.flatMap(arrVal => Observable.from(arrVal))

return this.contributorsService.getContributors(payload.pageNumber)
    .flatMap(data => Observable.from(data))
    .delay(Math.random() * 500) // you should just feed a ms value to delay if you want constant time interval, date parameters mean delay till that date, so they'll all just flow through at that date

return this.http.get(url, requestOptions).map(res => res.json());

但是，上述方法不起作用，因为延迟会随着时间而改变整个流，而不是每一项，因此为了实现平坦化和分离，我们需要从以下答案中得出更明确的结论：

通过这种方式，我们以均匀间隔手动展平阵列

此版本也可以使用，并且可能感觉稍微干净一些：

return this.contributorsService.getContributors(payload.pageNumber)
           .flatMap(data => Observable.from(data))
           .zip(Observable.interval(Math.random() * 500), (d,i) => d)

这只是使用zip操作符将每个项目压缩为一个可观察的间隔

现在，您应该可以看到每个数组项以固定的间隔一次通过一个。但是，如果使用http服务，可能需要在响应中调用.json（）以获取数组形式的值，如下所示：

.flatMap(arrVal => Observable.from(arrVal))

return this.contributorsService.getContributors(payload.pageNumber)
    .flatMap(data => Observable.from(data))
    .delay(Math.random() * 500) // you should just feed a ms value to delay if you want constant time interval, date parameters mean delay till that date, so they'll all just flow through at that date

return this.http.get(url, requestOptions).map(res => res.json());

您可以通过第二次平面映射来使用
delay（）

return this.contributorsService.getContributors(payload.pageNumber)
  .flatMap(x => x)                                            // to single values
  .flatMap(x => Observable.of(x).delay(Math.random() * 500))  // apply delay


const Observable=Rx.Observable
可观测的（[1,2,3]）
.flatMap（x=>x）
.flatMap（x=>可观测的（x）.延迟（Math.random（）*500））
.subscribe（console.log）
您可以通过第二次平面映射来使用
delay（）

return this.contributorsService.getContributors(payload.pageNumber)
  .flatMap(x => x)                                            // to single values
  .flatMap(x => Observable.of(x).delay(Math.random() * 500))  // apply delay


const Observable=Rx.Observable
可观测的（[1,2,3]）
.flatMap（x=>x）
.flatMap（x=>可观测的（x）.延迟（Math.random（）*500））
.subscribe（console.log）
您的预期结果是什么？延迟会让你失去价值。。。延迟时间有多长，如果您的值是一个数组，那么它不会将数组拆分为一个值流或类似的内容，它会延迟整个单个值。@bryan60确切地说，我希望数组被拆分，数组中的每个值都以给定的（常量）单独发出时间请用预期结果更新你的问题，写一篇answer@bryan60完成。谢谢你的预期结果是什么？延迟会让你失去价值。。。延迟时间有多长，如果您的值是一个数组，那么它不会将数组拆分为一个值流或类似的内容，它会延迟整个单个值。@bryan60确切地说，我希望数组被拆分，数组中的每个值都以给定的（常量）单独发出时间请用预期结果更新你的问题，写一篇answer@bryan60完成。谢谢谢谢似乎有效。让我调查一下，然后我会接受答案事实上，它似乎不起作用。我将用details@bryan60更新我的问题，这是因为您使用日期作为延迟输入，请查看我的评论，了解您为什么不应该这样做，如果jsut使用ms，.now（）只计算一次，而不是每个项目，您需要一个固定的时间，您根本没有理由使用日期输入。抱歉，我错过了这个。尽管如此，例如，即使我通过了3000（请参见更新的问题），行为也不会改变（除了它实际上等待3000发出所有值并分别发出）是的，我只是在延迟操作符上读取文档，它似乎改变了整个流，而不是每个项。我会改变我的答案。谢谢。似乎有效。让我调查一下，然后我会接受答案事实上，它似乎不起作用。我会用细节更新我的问题@bryan60因为