以编程方式向 Promise 添加参数

Question

我需要创建一个函数，它接收一个 Promise 作为第一个参数及其参数的数组（如果它至少有一个），如果没有，则为 null。

我的函数看起来是这样的：

var executeMappingStep = (promiseStatus, myPromise, myPromiseParams) => {
    return new Promise((resolve, reject) => {
        //if the execution was success, there's no need to invoke myPromise again
        if(promiseStatus.success == true)
           return resolve(promiseStatus.previousResponseSaved);

        if (myPromiseParams!= null) {
            //how I resolve this logic is my doubt
            myPromise.addArrayOfParameters(myPromiseParams);
        }

        myPromise().then(result => resolve(result)).catch(err => reject(err));
    });
};

我正在阅读 .bind() 函数，该函数适用于函数，但不适用于 this question 的承诺。我还看到了一些关于 .apply() 函数的内容，但这似乎不是我所需要的。

编辑

当没有参数时，我的函数像 myFirstPromise 一样被调用，而当我至少有一个参数时，像 mySecondPromise 一样：

var executePromises = (myFirstPromise, mySecondPromisePromise) => {
    return new Promise((resolve, reject) => {
        //retrieve an array of every promise status
        var promisesStatus = getPromisesStatus();

        executeMappingStep(promisesStatus[0], myFirstPromise, null).then(result => {
                return convertToXml(result);
        }).then(result => {

            var parameters = {
                value1 : result,
                value2: [1,2,3],
                value3: "some string",
                value4: 10
            };  

            return executeMappingStep(promisesStatus[1], mySecondPromisePromise, parameters);
        }).then(result => resolve(result)).catch(err => reject(err));
    });
};

var myFirstPromise = function() {
    return new Promise(function (resolve, reject) { 
        //some logic for first promise
    });
}

var mySecondPromise = function(firstParam, secondParam, thirdParam, fourthParam) {
    return new Promise(function (resolve, reject) { 
        //some logic for second promise with its params
    });
}

可能，在函数 addArrayOfParameters 中，我需要循环到对象上的每个属性（我意识到数组不起作用），例如 this

有没有办法在数组解析之前以编程方式添加参数？

编辑 2

这个逻辑背后的原因很复杂，但这正是我需要解决的问题。基本上，在我的代码中，每个 promise 都可以在错误的情况下执行，并且 executePromises 函数中涉及一个逻辑，它返回每个 promise 的状态，无论是否成功执行。这个逻辑涉及超过 10 个链接的 Promise，如果其中一些失败，例如：Promise 编号 5，然后是 6,7 等，将不得不在某个管理后端再次调用。

我不会为每个承诺复制逻辑，因此我想创建 executeMappingStep 函数来封装该逻辑。 可能很难解释，我尽量简化。我做了一些改动来解释我刚才所说的。

Answer 1

可能使用异步库可以解决您的问题。尝试在您的控制台上运行代码并查看它。

使用异步库：

var async = require("async");
async.waterfall([
    function (callback) {
        var methodParam = [1, 2, 3];
        console.log("first method called");
        callback(null, methodParam);
    },
    function (methodParams, callback) {
        var newParams = [4, 5, 6];
        newParams = methodParams.concat(newParams);
        console.log("second method called", methodParams);
        callback(null, newParams);
    }
], function (err, res) {
    if (err) {
        console.log("error occured");
    } else {
        console.log("final result", res);
    }
});

承诺：

var promise1 = (() => {
    return new Promise((resolve, reject) => {
        var methodParam = [1, 2, 3];
        console.log("first promise called");
        resolve(methodParam);
    });
});

var promise2 = ((methodParams) => {
    return new Promise((resolve, reject) => {
        var newParams = [4, 5, 6];
        newParams = methodParams.concat(newParams);
        console.log("second promise called", methodParams);
        resolve(newParams);
    });
});

promise1()
    .then((resPromise1) => {
        return promise2(resPromise1);
    }).then((resPromise2) => {
        console.log("final result", resPromise2);
    });

Answer 2

可能，我在这里做了很多复杂的事情，但无论如何，这就是我想要的解决方案。 很高兴知道 .then 函数可以在其他地方调用，并且可以使用所需的参数创建 Promise，然后作为参数发送。

话虽如此：

var executePromises = (myFirstPromise, mySecondPromisePromise) => {
    return new Promise((resolve, reject) => {
        //retrieve an array of every promise status
        var promisesStatus = getPromisesStatus();

        executeMappingStep(promisesStatus[0], myFirstPromise()).then(result => {
                return convertToXml(result);
        }).then(result => {

            var mySecondPromisePromiseParameter = mySecondPromise(result, [1,2,3], "some string", 10);   

            return executeMappingStep(promisesStatus[1], mySecondPromisePromiseParameter);
        }).then(result => resolve(result)).catch(err => reject(err));
    });
};

然后，executeMappingStep 只是接收到 Promise 并在内部调用 .then，这样：

var executeMappingStep = (promiseStatus, myPromise) => {
    return new Promise((resolve, reject) => {
        //if the execution was success, there's no need to invoke myPromise again
        if(promiseStatus.success == true)
           return resolve(promiseStatus.previousResponseSaved);    

        myPromise.then(result => resolve(result)).catch(err => reject(err));
    });
};