Javascript 将有序操作列表合并为一个可观察的

鉴于上面的代码，我正在尝试将

操作

组合成一个

可观察的

，它会发出每个操作的状态。因此，

可观察的

需要执行以下任一操作：

• 发射3次：

  [1,2]，[2,4]，6

• 发射1次：

  [[1,2]，[2,4]，6]

---

您可以使用

Rx.Observable.concat

，但我认为如果没有Rx.java和使用Promise.all，这个简单的例子会更容易

let slow=新承诺（（解决）=>{
设置超时（解析，200，“慢”）；
});
让即时=新承诺（（解决）=>{
setTimeout（解析，0，'即时'）；
});
让快速=新承诺（（解决）=>{
setTimeout（解析，50，‘快速’）；
});
var operation1=函数（）{
从承诺返回可观察的Rx（慢）；
}
var operation2=函数（）{
从承诺（即时）返回可观察的Rx；
}
var operation3=函数（）{
从承诺返回可观察的Rx（快速）；
}
var operations=[operation1（）、operation2（）、operation3（）]；
var源=Rx.可观察到的concat（操作）；
var subscription=source.subscripte(
功能（x）{
console.log（'Next:'+x）；
},
功能（err）{
log（'Error:'+err）；
},
职能（a）{
console.log（'Completed'，a）；
});
//还是有承诺
操作=[缓慢、即时、快速]
承诺。所有（运营）
.then（console.log.bind（console，“Promise all”）

您可以试试（）

---

请检查这是否起作用，稍后我将详细说明这是如何工作的。

问题是我无法按顺序调用这些操作。

Promise.resolve（）

仅用于演示目的。我真正的承诺是延迟解决。我想确保第一个承诺在下一个被调用之前得到解决。promise.all将按照承诺在列表中的顺序解决所有问题。不管是否有延迟，延迟以及承诺得到解决的顺序对我来说都很重要<代码>承诺。所有都不会确保在开始解析下一个承诺之前解析数组中的第一个承诺。我已经更新了我的示例代码，以更好地说明为什么顺序和延迟很重要。首先，如果确实需要，您可以使用

Rx.Observable.concat

。其次，你可以看看这里，更好地理解承诺@否认传递给

Promise的承诺。所有的
都是并行解决的，而不是按照传递的顺序解决。你的意思是，你只想在链中的上一个承诺完成后才进行工作以产生承诺吗？@GregL是的，这是正确的。我已经更新了这个例子来说明这一点。谢谢！这个解决方案很简单，效果很好！关键是在这里使用
Rx.Observable.defer
。
var state = [];
var operation1 = function() {
    return Rx.Observable.fromPromise(new Promise((resolve, reject) => {
        state.push(1, 2);
        setTimeout(resolve, 300, state);
    }));
};
var operation2 = function() {
    return Rx.Observable.fromPromise(new Promise((resolve, reject) => {
        state = state.map(x => x * 2);
        setTimeout(resolve, 200, state);
    }));
};
var operation3 = function() {
    return Rx.Observable.fromPromise(new Promise((resolve, reject) => {
        state = state.reduce( (prev, next) => prev + next );
        setTimeout(resolve, 100, state);
    }));
};
var operations = [operation1, operation2, operation3];

var state = [];
var operation1 = Rx.Observable.defer(function() {
    return Rx.Observable.fromPromise(new Promise((resolve, reject) => {
        state.push(1, 2);
        setTimeout(resolve, 300, state);
    }));
});
var operation2 = Rx.Observable.defer(function() {
    return Rx.Observable.fromPromise(new Promise((resolve, reject) => {
        state = state.map(x => x * 2);
        setTimeout(resolve, 200, state);
    }));
});
var operation3 = Rx.Observable.defer(function() {
    return Rx.Observable.fromPromise(new Promise((resolve, reject) => {
        state = state.reduce( (prev, next) => prev + next );
        setTimeout(resolve, 100, state);
    }));
});
var operations = Rx.Observable.from([operation1, operation2, operation3]).merge(1);
operations.subscribe(function(x){console.log(x)})