带阵列的rxjs concatMap
是一种用于响应式编程的操作符，用于处理Observable序列中的元素，并生成一个新的Observable序列。它主要用于处理带有阵列的Observable序列，并将阵列中的每个元素映射到一个新的Observable序列中。
具体来说，带阵列的rxjs concatMap操作符按顺序处理Observable序列中的每个元素，并通过将每个元素传递给提供的投射函数来映射它们。然后，将生成的Observable序列与之前生成的序列连接在一起，形成一个新的Observable序列。每个映射的Observable序列都会按照顺序依次发出元素，确保按照阵列元素的顺序进行处理。
带阵列的rxjs concatMap操作符的优势在于能够处理并发的Observable序列。它确保所有映射的Observable序列按照顺序进行处理，而不会产生竞争条件。这对于需要按照特定顺序处理的任务非常有用，例如按顺序发送HTTP请求或处理事务。
带阵列的rxjs concatMap操作符在以下场景中非常适用：
- 批量处理任务：当需要逐个处理一系列任务，并确保按照顺序进行处理时，可以使用concatMap操作符。例如，将阵列中的任务映射为HTTP请求，并确保每个请求按顺序发送和处理。
- 有序数据处理：当需要按照特定顺序处理数据时，可以使用concatMap操作符。例如，在音视频处理中，可以按顺序处理不同的音视频流，确保按照正确的顺序进行编解码或混音。
- 数据库查询：当需要按照特定顺序处理数据库查询结果时，可以使用concatMap操作符。例如，按照阵列中的ID顺序查询数据库，并按顺序处理查询结果。
腾讯云提供了一系列适用于云计算的产品和服务，其中与rxjs concatMap操作符相关的产品包括云函数SCF（Serverless Cloud Function）和消息队列CMQ（Cloud Message Queue）。
- 云函数SCF是一种事件驱动的无服务器计算服务，可实现按需计算。通过在云函数中使用rxjs concatMap操作符，可以轻松处理大量事件，并确保按顺序处理每个事件。了解更多：云函数SCF
- 消息队列CMQ是一种消息传递服务，可实现消息的异步通信和解耦。使用rxjs concatMap操作符，可以将每条消息映射到一个新的Observable序列，并确保按顺序处理每个消息。了解更多：消息队列CMQ
以上是对带阵列的rxjs concatMap操作符的完善且全面的答案。请注意，答案中未提及其他流行的云计算品牌商，如亚马逊AWS、Azure、阿里云等。
相关·内容
RXJS5-6迁移说明的措辞，以及像this one这样的博客帖子暗示，只需将“rxjs -compat”作为我们项目的依赖项与“rxjs”一起使用，那么从“rxjs”导入的可观察值、主题等将与遗留运算符兼容。例如：Observable.of(3, 4, 5).concatMap(num => {/*...*/})。然而，对于我们来说，情况似乎并非如此。如果我们直接从'rxjs-compat‘导入，事情确实会像预期的那样工作，这似乎不是预期的迁移路径，而且也不方便，因为'rxjs’的TypeScript声明更完整，并且在同一个文件中同时导入'rxjs‘和'
浏览 30提问于2019-03-07得票数 1
1回答
我在RxJS方面没有太多的经验，我想在我的角度服务中用RxJS管做下面的事情。
我尝试了iif功能，但我只是没有足够的经验。
角版是：角9
RxJS版本：6.5.5
通过HttpClient检查GET请求true的响应
……真正的->检查是否可以通过HttpClient访问网站
.真->集this.isOnline =真
..通过HttpClient从另一个url获取响应
..真->集this.result = responseFromUrl
.端管
..假-> throwError(“无法获得结果”)
.假->集this.isOnline = false
..端
浏览 1提问于2020-06-07得票数 2
我有一系列的消息。每隔N秒，我需要从Observable发出一条消息。
我尝试了下一个代码。第一条消息是延迟发出的，我在订阅者中得到了它，但按顺序生成其他消息已停止。如果我删除.delay()方法调用，我会得到所需的序列，订阅者会对每条消息做出反应，但没有消息之间的时间间隔。我怎么才能修复它？
import { Observable } from 'rxjs/Observable';
import { fromArray } from 'rxjs/observable/fromArray';
import 'rxjs/add/operator/delay
浏览 44提问于2018-06-05得票数 2
回答已采纳
2回答
好吧，所以我对RxJ很陌生，我搞不懂什么东西。我需要实现图像处理，其中用户一次添加多个图像，对于每个图像，除其他外，必须执行以下操作：
在web工作者中生成图像缩略图。
将图像和缩略图上载到服务器
但是我不希望所有的缩略图都同时生成，我想让它们依次生成。以下是我尝试过的：
我还将在这里粘贴代码：
import { of } from "rxjs";
import { map } from "rxjs/operators";
const imageObservable = of(1, 2, 3, 4, 5);
function generate
浏览 0提问于2019-06-28得票数 1
回答已采纳
我试图在rxjs中使用内置的rxjs类。我已经将大部分的基本代码设置为一个角服务，如下所示：
import { Injectable } from '@angular/core';
import { webSocket, WebSocketSubject } from 'rxjs/webSocket';
import { Subscription, from, Observable } from 'rxjs';
@Injectable({
providedIn: 'root'
})
export class Websocke
浏览 3提问于2020-10-29得票数 2
回答已采纳
仅当外部可观察对象不为空时，我才想订阅内部可观察对象。
import { of } from 'rxjs';
import { concatMap, delay, mergeMap } from 'rxjs/operators';
//emit delay value
const source = of(2000, 1000);
// map value from source into inner observable, when complete emit result and move to next
const example = source.pi
浏览 6提问于2020-02-07得票数 0
回答已采纳
1回答
考虑以下类型记录/ rxjs代码：
import { range } from 'rxjs';
range(1, 5).subscribe(async (num) => {
await longLastingOperation(num);
})
function longLastingOperation(num) {
console.log('starting', num);
return new Promise((resolve) => {
setTimeout(() => {
console.log(
浏览 0提问于2018-11-07得票数 0
回答已采纳
我有一个process函数，它以异步的方式工作-它需要输入文本的行并处理它(在下面的代码片段中-为了简化-它从行中提取数字)。这些行来自输入大文件(很多GB)，并被逐个读取并发送到管道(这是由下面的of操作符“模拟”的)。process函数很慢-但读取行很快-所以关键是逐个读取和处理行，以避免内存“堆栈溢出”。 const { of, Subject } = rxjs;
const { take, bufferCount, map, finalize } = rxjs.operators;
let source = of("line 11 of text", "
浏览 2提问于2020-10-24得票数 1
回答已采纳
我希望限制使用"from“运算符创建的数组可观察值的内容，使每个值间隔1秒显示。省略油门将按预期显示1到10。如果我在可观察对象的管道()中引入一个节流，流只输出"1“。 https://stackblitz.com/edit/rxjs-behaviorsubject-simpleexample-knappa?file=index.ts // RxJS v6+
import { from, interval } from 'rxjs';
import { throttle } from 'rxjs/operators';
const obse
浏览 11提问于2020-04-15得票数 1
我正在尝试使用RxJS concatMap对我的两个观察值进行排序，以便它在调用服务返回绑定到我在Angular 9中的Mat-Table的对象之前返回employeeID。但是我不确定如何正确编写语法。第一个observable实际上是我创建的一个行为主题，它允许组件在应用程序的任何位置订阅。第二个是来自web api的http响应。 我一直在看这里的例子，并试图弄清楚它，但只是敲击键盘。RxJS concatMap //first observable (actually a Behavior Subject)
this.userService.currentEmployeeId.sub
浏览 23提问于2020-06-17得票数 1
回答已采纳
2回答
我想执行2项承诺，然后将promise2的结果传递给一组其他的rxjs操作符，以便在promise2解析时执行一系列不同的事情。但是，我希望promise2只在promise1解析时执行。为了达到这个效果，我是否应该使用类似的方法
from(promise1).pipe(
map(x => promise2),
tap((x) => console.log('response from map: ', x)),
other_rxjs_ops)
.subscribe(...)
如果我用concat而不是map
concat(promise1, defer(() =
浏览 9提问于2022-03-30得票数 1
回答已采纳
我正在尝试迭代我的一个HTTP get()调用。它不能正常工作。我不知道在Angular 6中如何在for循环中使用HTTP方法。另一个问题是，如果我省略了for循环，那么rxjs delay()函数将无法工作。
getRoleOftheUser() {
for ( let i = 0; i < this.arr.length; i++) {
return this.http.get<any>(`${this.baseURL}/aaa/groups/${this.arr[i]}/effectiveRolesByUser`)
.pipe(
浏览 4提问于2018-09-27得票数 0
我试图显示前3个数字，每个数字延迟1秒，第四个数字显示4秒。不幸的是，我的代码在1秒内显示这四个数字。
import { from, of, race, timer, interval } from 'rxjs';
import { groupBy, mergeMap, toArray, map,merge, reduce, concatMap, delay, concat, timeout, catchError, take } from 'rxjs/operators';
const obs$ = from([1,2,3]).pipe(concatMap(
浏览 0提问于2018-07-01得票数 3
回答已采纳
我保存配置文件，一旦请求成功，我会提出另一个请求创建一个付款。现在代码看起来像这样
this.profileService.saveProfile(dataProfile).pipe(
catchError(e => of(null))
).subscribe(res => {
if (res) { // if user saved profile data
const data = {
params: {
user: {
surname: this.formInfo.get(
浏览 3提问于2021-03-15得票数 2
回答已采纳
我正在努力理解为什么我的代码不能正常工作，我希望它能正常运行。
如果您在中复制和粘贴以下代码，您将看到它等待4秒，然后它每秒钟显示'aaaa‘而不是每秒显示'bbbb’。为什么？
import { from, of, race, timer, interval } from 'rxjs';
import { groupBy, mergeMap, toArray, map,merge, reduce, concatMap, delay, concat, timeout, catchError, take } from 'rxjs/operators'
浏览 0提问于2018-07-01得票数 1
回答已采纳
我使用可观测的pipe方法合成多个可观测值，当数组中的所有可观测值发出时，我想发出一个最终的复合值。
import { apiSvc } from '../lib/api-service'
import { of as observableOf } from 'rxjs/observable/of'
import { map } from 'rxjs/operators'
const uris = [
'/api/items/1',
'/api/items/2',
'/api/items/3
浏览 1提问于2018-03-28得票数 0
回答已采纳
1回答
正如标题所暗示的，我希望将迭代器中的每个值延迟一段时间，同时保持对可迭代器的延迟计算。这是我到目前为止得到的最接近的例子，它适用于有限的可迭代程序或那些不会抛出错误的程序
function* iter () {
let i = 0
while (true) yield i++
}
rxjs.zip(
rxjs.from(iter()),
rxjs.timer(500, 500),
x => x
).subscribe(console.log)
浏览 2提问于2019-11-13得票数 0
试图将一个非常大的对象数组转换为100个对象的块，然后等待10秒才能发出下一个100个对象。数据集来自HTTP请求。
这是我目前的情况
const { Subject, from, of } = require('rxjs');
const { bufferCount, concatMap, flatMap, mergeAll, delay } = require('rxjs/operators');
from(hugeArray)
.pipe(
bufferCount(100),
concatMap(txn =>
浏览 0提问于2019-05-15得票数 1
回答已采纳
1回答
我有一个场景，我想首先进行HTTP调用，当响应(1)出现时，我想进行第二个不需要响应(1)的HTTP调用，并且假设这个第二个HTTP调用提供响应(2)。现在，我想使用来自响应(1)和响应(2)的数据进行多个HTTP调用。我如何使用RxJS来完成这个任务呢？
浏览 4提问于2022-01-19得票数 0
回答已采纳
2回答
如何按照这些标准使用rxjs进行自动保存？
单击“保存”按钮应发出http请求以保存我的数据(来自局部变量，而不是表单)。
每3000毫秒(间隔)应该做同样的我点击按钮。
不能是并行http请求。在请求处于活动状态之前，另一个请求在完成之前不应该运行。如果请求开始，那么所有其他请求都应该在队列中等待(然后逐个执行)。
保存按钮应该在队列/执行中获得高优先级。
我想使用rxjs的强大功能，所以最好由rxjs操作符而不是局部变量(if (this.requestStart === true))来实现。
这是我想要完成的。任何帮助都将不胜感激
import { Compone
浏览 0提问于2019-03-15得票数 0
2回答
如何为interval的每次迭代设置randomIntervals的值？ import {random} from 'lodash'
import {interval, timer} from 'rxjs';
import {takeUntil} from 'rxjs/operators';
const timer$ = timer(5000);
const randomInterval = random(100, 1000);
const source = interval(randomInterval)
.pipe(
take
浏览 26提问于2019-02-06得票数 0
回答已采纳
我有一组可观察数据(HTTP POST请求)，需要在发生特定事件后发送给API。下面是该方法的一个简化示例，其中我使用了concat，这样我就可以利用成功、错误和完整回调。 // build up an array of stored POST requests to fire off later
// array is indeterminate length, could be 1 request could be 1,000
let requests = [ req1, req2, req3, req4 ];
concat(...requests).subscribe(
succ
浏览 33提问于2020-10-10得票数 0
在使用RXJS时，我问自己嵌套的concatMap是否等同于顺序的。请考虑以下示例：
observable1.pipe(
concatMap(result1 => observable2.pipe(
concatMap(result2 => observable3.pipe(
concatMap(result3 => of(result3)
)
)
).susbcribe((result) => {...});
这将导致result成为result3。为了避免嵌套，我想这样写如下：
of(null).pipe(
浏览 4提问于2021-01-19得票数 2
回答已采纳
2回答
我使用RxJS来处理事件流。相当多的事件可以被分派，并且结束处理代码是“相对昂贵的”，例如。加载一个文件，做一些工作，将一些东西保存到数据库中。
const rx = require("rxjs")
// simulate a lot of events
const observable = rx.interval(1)
// subscribe to the events
const subscription = observable
.subscribe(x => {
// do expensive things here
});
浏览 2提问于2020-11-21得票数 4
回答已采纳
我有两个api调用，需要一个接一个地同步进行。我使用rxjs concat操作符来完成同步。这很好，但是如何返回两个可观测到的数据呢？我就是这样实现的：
const userId='someId';
this.restangular.one('users/generate-api-token').customPOST() // Will return an api token
.concatMap(({token}) => this.restangular.one(`users/${userId}/api-token-details`).get())
浏览 6提问于2017-06-13得票数 2
回答已采纳
RxJS是新的，但我正在尝试将单个元素流映射到在所有内部/后续流完成/加载后生成数组的另一个元素流。然而，我内心的观察似乎并没有付诸实施。他们只会被送回来。
在较高的级别上，我需要执行http post来上传文件列表(在两个不同的数组中到两个不同的端点)。因为它们很大，所以我用延迟5秒进行仿真。请求需要并行执行，但仅限于一次并发执行X(此处2)。这一切都需要在管道内，管道应该只允许流在所有帖子完成后才能继续。
import { map, mapTo, mergeMap, mergeAll, delay, tap, catchError, toArray } from 'rxjs/op
浏览 0提问于2019-01-18得票数 1
回答已采纳
1回答
我正在尝试使用RxJS来处理一个项目流，我希望它能够优先地用延迟(如果可能的话是指数退避)重试任何失败，但是我需要保证排序，所以我实际上想阻止这个流，我不想重新处理任何已经处理过的项。
因此，我试图使用retryWhen，如下所示：
const { interval, timer } = Rx;
const { take, map, retryWhen, delayWhen, tap } = RxOperators;
const source = take(5)(interval(1000));
source.pipe(
map(val => {
if (val >
浏览 6提问于2022-03-13得票数 0
回答已采纳
1回答
RxJS顺序运算
、、
我使用RxJS与数据库通信，并试图发送复杂的复合对象。我们的API允许我们同时注入一个元素(即POST不会在正文中处理数组)，考虑以下对象，其中mainField和subFields将是DB中的独立表实体：
OBJ = {
'mainField': 'Main content'
'subFields': [ 'obj1','obj2','obj3' ]
}
所需经费如下：
必须首先传输mainField，响应对象将提供引用ID，subFields将使用该ID
浏览 3提问于2018-01-16得票数 3
我一直在尝试将combineLatest与concatAll()一起使用，但它们仍然是同时调用的。我可以只循环并调用每个函数，但我总是想知道在RXJS工作流程中是否有更好的方法。
combineLatest(arrayOfApiObservables).pipe(concatAll()).subscribe();
浏览 0提问于2020-11-20得票数 0
在我的Angular2组件类的构造函数中有以下代码：
Observable.from([1,2,3]).interval(2000).subscribe(e=>{
console.log(e);
});
我进口了以下产品：
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/observable/from';
import 'rxjs/add/observable/interval';
在使用Angulat构建项目时，我有以下错误消息：
浏览 1提问于2017-03-19得票数 2
回答已采纳
1回答
我正在努力创造一个可以观察到的，它会发出延迟值。然而，这些值正变得越来越不稳定。我在创建了一个堆栈闪电战。守则如下：
import { of } from 'rxjs';
import { map, delay } from 'rxjs/operators';
const arr = [1,2,3,4,5];
const source = of(...arr);
const source2 = source.pipe(delay(2000));
const subscribe = source2.subscribe(val => console.log(
浏览 0提问于2019-03-15得票数 2
回答已采纳
我试图在一个可观察对象中返回一个承诺(Gameid)内的true或false，该对象在用户是否登录时返回我： 下面是我的作者： //Angular
import { Injectable } from '@angular/core';
import { CanActivate, Router, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
//Rxjs
import { Observable } from 'rxjs';
import { map, t
浏览 9提问于2020-01-25得票数 1
回答已采纳
const a = [1, 2, 3, 4, 5, 6, 7,8];
rxjs.from(a.splice(0, 3))
.pipe(
rxjs.concatMap(val => {
return rxjs.of(val).pipe(rxjs.delay(Math.random() * 1000));
}),
rxjs.repeatWhen(completed => completed.pipe(rxjs.delay(2000))),
rxjs.tap(val => {
浏览 8提问于2022-05-04得票数 -1
我尝试遵循这个示例、stackblitz和Observable文档，但似乎对我不起作用。坦率地说，我是RxJS的新手，不知道如何使用http和subscribe。盯着这个问题看了这么久，我的脑子都糊涂了。从本质上讲，我希望subscribe每隔一段时间就检查一次新数据。也许有比rxjs更好的方法？ import { Component, OnDestroy, OnInit } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import
浏览 15提问于2019-04-04得票数 1
我目前正在学习rxjs中的rxjs，但是我很难将这些概念组合起来以正确地表达以下情况：
我对一个端点有一个HTTP请求，这导致一些数据被返回
我目前有以下情况：
this.httpClient
.post('/endpoint1)
.pipe(
tap((firstData) => setFirstState(firstData)),
concatMap((firstData) => this.httpClient.get('endpoint2', {body: somethingOfFirstData
浏览 2提问于2020-07-27得票数 1
回答已采纳
2回答
比方说[65, 66, 67, 68]，我有一个可观察的对象，numberRange$，它发出一个数字数组。 是否有任何数字可以订阅numberRange$，并在新管道中将数组中的每个数字作为单独的发射？ 每个数字都将被用作异步http调用的输入，对于mergeMap来说，批处理http调用是微不足道的，因为它一次只允许2次并行计算。 现在，我订阅了numberRange$并将输出保存在一个变量numberRange$中，并使用rxjs/operators.from(numberRange).pipe(mergeMap(someFunc, batchCount))执行操作，但我宁愿直接通过管
浏览 9提问于2019-03-18得票数 0
回答已采纳
有了承诺，如果你这样做：
Promise.resolve(p).then(function(){
return 5;
})
.then(function(val){
return db.find(); // promise
});
我们可以看到，promises上的then操作符可以处理任何返回值，它只是在返回结果上调用Promise.resolve()并处理它，而不管它是不是promise。
然而，使用RxJS5，我发现很难找到一个可以做类似事情的运算符。我得到了很多错误：
TypeError: You provided x where
浏览 12提问于2017-01-10得票数 0
1回答
我正在构建我的第一个角2应用程序，并有一个问题，链接可观察订阅。
下面的代码在Chrome中运行良好，但在Firefox和IE中不起作用。
做以下事情的正确方法是什么？我需要获得用户的当前位置，然后将其传递给第二个调用(getTiles)。
我没有看到任何错误的网页开发浏览器工具。这也是我在本地主机上运行的时候。该网站还没有部署。我不确定这是否有关联。
我用的是角2.0.0-rc.2。
ngOnInit(): void {
this._LocationService.getLocation().subscribe(
location => {this
浏览 0提问于2016-06-23得票数 5
回答已采纳
我想每隔1秒发出一次请求，但我的超时时间不起作用。
matchlist.service.ts
import 'rxjs/add/operator/toPromise';
import 'rxjs/add/operator/timeout';
getMatch(matchId: number): Promise<Match[]> {
let matchUrl: string = 'https://br1.api.riotgames.com/lol/match/v3/matches/'+ matchId +'?api_k
浏览 14提问于2017-06-18得票数 1
我想要“书签”值顺流而下。更具体地说，来自这样的来源
import { of } from "rxjs";
let start$ = of(1,2,3);
我想要一个能放出
// 1-enter
// 1
// 1-exit
// 2-enter
// 2
// 2-exit
// 3-enter
// 3
我可以通过在中间添加一个主题来做到这一点，例如：
import { of, Subject } from "rxjs";
import { startWith, pairwise, delay } from "rxjs/operators";
浏览 5提问于2021-02-26得票数 1
回答已采纳
我正在进入从rxjs开始的函数式反应式代码，并对如何最好地导入它有一些问题，因为我得到的结果喜忧参半。
目前，我有一个简单的实现，我检查web服务是否已经存在用户名。
下面是完美工作的代码：
$(window).load(function() {
// setup an observable
submission = Rx.Observable.fromEvent($("#submitbutton"), "click").map(
event => {
return "justsomeuser
浏览 4提问于2018-07-20得票数 1
回答已采纳
1回答
如何在Rxjs6中重写这个Rxjs4代码段？ const click$ = Rx.Observable.fromEvent($('.btn'), 'click').share();
click$
.scan((a, b) => a + 1, 0)
.bufferTime(4000, null, 3)
.filter(buffer => buffer.length > 0)
.concatMap(buffer => Rx.Observable.of(buffer).delay(1000))
.timestamp()
浏览 27提问于2021-01-19得票数 0
回答已采纳
我正试着把我的头伸向RxJS。特别是，我有一种情况，我试图通过一个过滤器，通过一个内部可观测谓词，依赖于外部可观测到的输出，从外部观测到的排放管道。举个例子：
outerObs.pipe(
filter(x => myPredicate(x))
).subcribe()
其中mypredicate是一个返回Observable<boolean>的函数。显然，上面的操作不工作，因为filter操作符需要一个boolean，而不是Observable<boolean>。有什么好的方法可以做到吗？我试过查看withLatestFrom和mergeMap运算符，但
浏览 0提问于2019-05-03得票数 3
回答已采纳
请考虑以下几点：
import { timer, of, Subject } from 'rxjs';
import { map, mergeMap } from 'rxjs/operators';
(function(){
var sub$ = new Subject<number>();
var complete = false;
var out$ = sub$.pipe(
mergeMap(n => {
complete = n === 7;
i
浏览 5提问于2022-08-12得票数 -1
回答已采纳
1回答
我试图创建一个自定义的rxjs操作符。我已经创建了一些自定义运算符(例如，MonoTypeOperatorFunction或常规可观察的运算符，它可以将输入作为字符串、数字等)。而且效果很好。我的问题是，我想要创建一个接受匿名函数的操作符。比如x => x.prop或谓词。
在本例中，我希望创建一个运算符，它可以使对象中的元素扁平化。
interface B {
bid: number;
}
interface A {
aid: number;
bs: B[];
}
const b1: B = { bid: 1 };
const b2: B = { bid: 2 };
浏览 0提问于2021-02-21得票数 1
回答已采纳
1回答
我已经尝试用rxjs操作符concat以正确的顺序订阅了3个相互依赖的观察值。在第一个和第二个观察点之间，以及在最后一个观察点之后，必须执行一些操作。最大的问题是:第一个的结果必须传递给第二个。我试过一些方法。例如： let foo = {};
concat(
observable1().pipe(map(result => foo.id = result)),
observable2(foo),
observable3().pipe(map(() => console.log('ready')))
).subscribe(); 没有一件事像预期的那样
浏览 14提问于2021-01-21得票数 0
回答已采纳
1回答
同步网络调用的RXJS
、、、
我们的ionic应用程序频繁地调用特定的web服务，当进行相同的调用时，服务器会抛出错误。
我们希望确保呼叫是同步的。如何在RXJS中实现这一点？
Observers(View1..n)=>Observable(User)=={apply control here?}==>NetworkCall(getUser())
浏览 23提问于2019-11-01得票数 0
在RxJS 6中，我如何用承诺链接和传递数据？我必须使用JIRA连接器npm库在一行中执行一系列jira调用。但我不知道如何执行数据并将数据传递给函数。
谢谢!
例如：
const pipeData = Observable.from(jira.search.search({
jql: 'team = 41 and type = "Initiative"'
}))
pipeData.pipe(
data => operators.flatMap(data.issues),
iss
浏览 1提问于2019-04-23得票数 0
回答已采纳
1回答
各位，我正在学习使用Angular 2的Web应用程序，我想实现一个服务。
该服务如下所示：
@Injectable
export class MyService {
private _data: Any;
private _dataReady: boolean = false;
getData(): Observable<any> {
if (this._dataReady)
return Observable.of(this._data);
else {
http.get('url').subscrib
浏览 0提问于2017-04-21得票数 1
我是RxJS的新手，所以我还在学习如何使用这个库。concatMap的文档提供了以下警告：
警告:如果源值到达的速度超过其相应的内部可观测值所能完成的速度，则将导致内存问题，因为内部可观测值聚集在一个无界缓冲区中，等待订阅它们。
这对我来说是个问题，因为我有一个内存密集型但速度快的concatMap，提供一个慢的concatMap。它是这样设置的：
let uploadObs = Observable.range(0, blockCount).concatMap(blockIndex => {
// This part is fast and memory intensi
浏览 2提问于2016-12-16得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
