Question

考虑以下情况：值数组应一个接一个地处理，并且在处理之后再次返回单个数组值。以下代码将起到作用：

Observable.of([1, 2, 3, 4]) /* Base array */
.concatMap<number[], number[]>(valArr => { /* Inner stream to process array */
  return Observable.from(valArr) /* breake apart array into values */
  .map<number, number>((num, idx) => {
    return valArr[idx] + 1; 
  })
  .toArray()
})
.subscribe(arr => {
  console.log(arr)
})

即。将流分解为单个元素流，对值进行一些操作，toArray()将其合并回数组响应。整个进一步处理将停止，直到内部concatMap处理单个元素未完成。

问题是，如何在没有使用toArray()的情况下实现相同的行为？

Answer 1

您可以在baseArray上使用Observable.from()并跳过concatMap //内部可观察逻辑来简化代码。如果你想最终得到一个数组，你最好的选择确实是在最后使用.toArray()：

Observable.from([])
  .map((val) => 1 + val)
  .toArray()

Answer 2

我们提出了以下解决方法：

使用concat：

Observable.of([1, 2, 3, 4]) /* Base array */
.concatMap<number[], number[]>(valArr => { /* Inner stream to process array */


  return Observable.from(valArr) /* breake apart array into values */
  .map<number, number>((num, idx) => {
    return valArr[idx] + 1; 
  })
  .concat(Observable.from(valArr))
})
.subscribe(arr => {
  console.log(arr)
})

使用last：

Observable.of([1, 2, 3, 4]) /* Base array */
.concatMap<number[], number[]>(valArr => { /* Inner stream to process array */

  return Observable.from(valArr) /* breake apart array into values */
  .map<number, number>((num, idx) => {
    return valArr[idx] + 1; 
  })
  .last()
  .map(v => {
    return Observable.from(valArr)
  })
})
.subscribe(arr => {
  console.log(arr)
})

Answer 3

Observable.from([1, 2, 3, 4])
          .reduce((acc, curr) => [...acc, curr + 1], [])

// result: [2, 3, 4, 5]

RxJS toArray（）等价

3 个答案: