RxJS toArray（）等价物

考虑以下场景： 应逐个处理值数组，再次处理后，应返回单个数组值。以下代码将完成此操作：

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)
})

of（[1,2,3,4]）/*基数组的可观测值*/
.concatMap（valArr=>{/*处理数组的内部流*/
返回可观测值。从（valArr）/*将数组拆分为值*/
.map（（num，idx）=>{
返回valArr[idx]+1；
})
.toArray（）
})
.订阅（arr=>{
控制台日志（arr）
})

即，将流分解为单个元素流，对值执行一些操作，

toArray（）

将其合并回数组响应。整个进一步处理将停止，直到内部

concatMap

处理单个元素未完成

---

问题是，如何在不使用

toArray（）

的情况下实现相同的行为？

您可以通过在baseArray上使用

Observable.from（）

并跳过concatMap//内部可观察逻辑来简化代码。如果您希望最终得到一个数组，那么最好的选择确实是在最后使用

.toArray（）

：

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

---

我们刚刚提出了以下解决办法：

使用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)
})

of（[1,2,3,4]）/*基数组的可观测值*/
.concatMap（valArr=>{/*处理数组的内部流*/
返回可观测值。从（valArr）/*将数组拆分为值*/
.map（（num，idx）=>{
返回valArr[idx]+1；
})
.concat（可从（瓦拉尔）观察到）
})
.订阅（arr=>{
控制台日志（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)
})

of（[1,2,3,4]）/*基数组的可观测值*/
.concatMap（valArr=>{/*处理数组的内部流*/
返回可观测值。从（valArr）/*将数组拆分为值*/
.map（（num，idx）=>{
返回valArr[idx]+1；
})
.last（）
.map（v=>{
可观察的返回。从（瓦拉尔）
})
})
.订阅（arr=>{
控制台日志（arr）
})

您可以使用reduce来实现相同的目标，但这可能不是代码的改进。请将操作员的源代码直接复制到您的代码中。等等，瞧，同样的行为，但你不再使用运算符了。@IngoBürk我必须将你的评论标记为删除候选，因为它不会给问题带来任何价值，也会破坏它的严重性。不，它表明了问题的荒谬性。您的代码工作得非常好，根据定义，任何其他解决方案都将具有相同的效果。那么，这有什么意义呢？我认为没有必要把这个问题称为“荒谬的”，也没有必要仅仅因为对你们来说，探究它似乎是不合理的，就根据你们个人的观点来判断它的有效性。由于问题格式正确，没有冒犯性，也没有重复，只是试图回答“如何手动执行此操作”的问题，我认为没有提供此类答案的有效理由。无论如何，还是要感谢您的建议。不幸的是，

toArray

是我们需要避免的运算符，因为流中有一些复杂的异常处理。但是，嘿，谢谢你的回答！虽然这段代码可以回答这个问题，但提供关于它如何和/或为什么解决问题的附加上下文将提高答案的长期价值。

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

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