是否可以连续排队 return 承诺的函数数组？

Question

有下一个例子：

function exec()
{
    var dfd = $.Deferred();

    asyncStuff().then(
    function(res)
    {
        if(res)
        {
            dfd.resolve(true);
        }
        else
        {
            dfd.resolve(false);
        }
    });

 return dfd.promise();
}

var promise_arr = [];
promise_arr.push( exec() );
promise_arr.push( exec() );
promise_arr.push( exec() );
promise_arr.push( exec() );

Promise.all( promise_arr ).then(
function(res)
{
    console.log("finished!");
});

所以数组里面的函数几乎是同时执行的。这个不好。只有在另一个按顺序完成后才能调用一个。有办法让他们排队吗？

编辑：

为了让它工作，我不得不在 for 循环中调用一个匿名函数，并且我冒险停止它的执行，无论我的承诺是否返回正确的答案。该匿名函数用作承诺工厂，查看：https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

此外，当我推送函数时，我必须移除大括号，以便它们在将它们推送到数组中时停止执行。

function Exec()
{
    var dfd = $.Deferred();
    
    setTimeout(
    function()
    { 
        console.log("executing OK"); 
        var res_obj = {};
        res_obj.res_value = true;
        dfd.resolve(res_obj);
    }, 1000);
    
    return dfd.promise();
}

function ExecNO()
{
    var dfd = $.Deferred();
    
    setTimeout(
    function()
    { 
        console.log("Executing ERROR"); 
        var res_obj = {};
        res_obj.res_value = false;
        res_obj.res_error = "Ima error func";
        dfd.resolve(res_obj);
    }, 1000);
    
    return dfd.promise();
}

function ExecSincroProcess( promise_arr )
{
    var res_obj = {};
    res_obj.res_value = true;

    var result = Promise.resolve(res_obj);

    promise_arr.forEach(
        function (promiseFunction) 
        {
            result = 
            result.then(
            function(res)
            {
                if (res.res_value)
                {
                    return promiseFunction();
                }
                else
                {
                    return res;
                }
            });
        });

        result.then(
    function(res)
    {
        console.log(res.res_error);
        console.log("finished!");
    });
}

function ExecAll()
{
    var pr_Arr = [];
    pr_Arr.push(Exec);
    pr_Arr.push(Exec);
    pr_Arr.push(ExecNO);
    pr_Arr.push(Exec);
    pr_Arr.push(Exec);
    
    ExecSincroProcess(pr_Arr);
}

Answer 1

有一种方法可以对承诺进行排队。我过去排队承诺的方式是遍历数组并将它们与 .then 子句链接在一起：

例如

let promiseChain = Promise.resolve()
promiseFunctionArray.forEach(promiseFunction => {
    promiseChain = promiseChain.then(promiseFunction)
})

promiseChain.then(() => {/* do what you want to with the results */})

因此您的情况可能如下所示：

function exec()
{
    var dfd = $.Deferred();

    asyncStuff().then(
    function(res)
    {
        if(res)
        {
            dfd.resolve(true);
        }
        else
        {
            dfd.resolve(false);
        }
    });

 return dfd.promise();
}

var promise_arr = [];
promise_arr.push(exec);
promise_arr.push(exec);
promise_arr.push(exec);
promise_arr.push(exec);

var promiseChain = Promise.resolve()
promise_arr.forEach(promiseFunction => {
    promiseChain = promiseChain.then(promiseFunction)
})

promiseChain.then(
function(res)
{
    console.log("finished!");
});

是否可以连续排队 return 承诺的函数数组？

Is it possible to queue in succesion an array of functions that return promises?

javascript

queue

jquery

jquery-deferred