Javascript 是否可以将一系列返回承诺的函数依次排队？

举下一个例子：

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循环中调用一个匿名函数，我冒险停止它的执行，不管我的承诺是否返回了正确的答案。 该匿名函数用作承诺工厂，请查看：

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

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

---

有一种方法可以让承诺排队。我过去排队承诺的方式是通过数组循环，并将它们与

链接在一起。然后

子句：

前

因此，您的案例可能如下所示：

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!");
});

---

非常感谢。一定会尝试的！这个答案基本上是正确的，但我不得不稍微调整一下它才能工作！

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!");
});