Javascript 蓝鸟承诺链

我是一个以承诺的方式工作的人，我被我的用例卡住了。 我有一个transformer函数数组（每个函数都是一个承诺，并修改一些JSON结构）

让我展示一些代码

假设这是我的JSON结构（数组）

transformFunction

是以某种方式修改数据的转换函数的定义。这两个函数将

c

和

d

属性添加到上述JSON结构中：

var transformFunctions = { // 

    transform1: function (data) {  // This function adds `c` property to each object from `a`
        return new Promise(function (resolve) {
             for (var i = 0; i < data.length; i++) {
                 data[i].c = data[i].a;
             }
             return resolve(data);
        })
    },

    transform2: function (data) {  // This function adds `d` property to each object from `c`
        return new Promise(function (resolve) {
             for (var i = 0; i < data.length; i++) {
                 data[i].d = data[i].c;
             }
             return resolve(data);
        })
    },
    ...
}

transform1

方法应修改数据，结果应传递给

transform2

方法

---

我在看：

承诺。所有的

似乎都不关心承诺的顺序，最重要的是它需要将上一个结果传递给下一个承诺。

注意：正如adeneo在评论中指出的，只有在处理异步代码时才使用承诺

创建要执行的函数数组。确保他们都能兑现承诺

然后，通过在每次迭代中返回执行当前承诺返回函数的结果，可以使用将初始值减少为转换后的最终值

最后，您可以附加一个

then

处理程序以获取实际值和一个

catch

处理程序，以防承诺被拒绝

假设我们有两个这样的变换函数

注意：我再说一遍。您不应该将承诺与这些函数一起使用。只有在处理的函数真正异步时，才应该使用承诺

// Just add a property called `c` to all the objects and return a Promise object
function transform1(data) {
    return Promise.resolve(data.map(function(currentObject) {
        currentObject.c = currentObject.a + currentObject.b;
        return currentObject;
    }));
}

// Just add a property called `d` to all the objects and return a Promise object
function transform2(data) {
    return Promise.resolve(data.map(function(currentObject) {
        currentObject.d = currentObject.a + currentObject.b + currentObject.c;
        return currentObject;
    }));
}

然后可以像这样变换原始值

Promise.reduce([transform1, transform2], function (result, currentFunction) {
        return currentFunction(result);
    }, [{a: 1, b: 2}, {a: 3, b: 4}])      // Initial value
    .then(function (transformedData) {
        console.log(transformedData);
    })
    .catch(function (err) {
        console.error(err);
    });

输出

[ { a: 1, b: 2, c: 3, d: 6 }, { a: 3, b: 4, c: 7, d: 14 } ]

---

您可以像往常一样链接承诺：使用

.then（）

假设您有以下两种转换：

function increment(x) {
    return Promise.resolve(x + 1);
}

function double(x) {
    return Promise.resolve(2 * x);
}

在真实场景中，它们将执行异步工作。你可以：

increment(1).then(double)

但是，您不知道转换的顺序或数量。让我们将它们放入一个数组中，然后（）将它们逐个放入：

var transformations = [increment, double]

var promise = Promise.resolve(1);

for (var i = 0; i < transformations.length; i++)
  promise = promise.then(transformations[i]);

var转换=[increment，double]
var promise=promise.resolve（1）；
对于（var i=0；i

您可以在开始之前、完成之后甚至每次转换之前附加一个

catch（）

处理程序

---

如果要应用成百上千的转换，这是没有效率的。在这种情况下，你应该使用

reduce（）

，正如他在回答中建议的那样。

我只是想问一下，但是为什么你要使用承诺，这不是异步的`我简化了这个问题，在实际的用例中，我可以在那里进行db请求或ajax调用。我不确定，但从你描述的方式来看，听起来你只是想通过管道传输数据什么的。也许有人有更多的经验使用蓝鸟会回答，我只是用它一点点的承诺中间件等，管道是我照顾的效果，但从一系列的承诺。谢谢你的意见

increment(1).then(double)

var transformations = [increment, double]

var promise = Promise.resolve(1);

for (var i = 0; i < transformations.length; i++)
  promise = promise.then(transformations[i]);