Javascript 如何'；$。全部'；一套充满活力的承诺？

假设我们有3个承诺，我们将它们传递给$q.all。这将返回一个新的承诺，该承诺在3个承诺得到解决时得到解决

现在，如果在三个承诺得到解决之前，我真的决定我想要第四个承诺也得到解决，这能做到吗

我试过这样的方法：

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);
promises.push(promise4);

在上面的例子中，

allDone

在前3个承诺得到解决后立即得到解决，但我希望它也能等待第4个承诺

还是我错过了承诺的重点？也许我不应该在这种情况下使用承诺

---

更新：正如回答的那样，$q.all不能做我想做的事。我的问题是：是否有其他方法可以知道何时解决了一组动态承诺，因此即使该承诺发生了变化？

如果您可以检查函数的源代码，您将看到它只是使用forEach（）传递所有承诺，并返回另一个承诺，稍后将解决所有结果

---

因此，如果您将另一个承诺推入数组，它将完全不起作用，因为它已经设置了所有承诺并使用承诺数组完成了操作。

如果您可以检查函数的源代码，您将看到它只是使用forEach（）传递所有承诺，并返回另一个承诺，稍后将解析所有结果

---

因此，如果将另一个承诺推送到数组中，它将完全不起作用，因为它已经设置了所有承诺并完成了承诺数组。

您不能在事实发生后将承诺添加到数组中，并期望它影响前面的

.all（）

。

.all（）

不是这样工作的。相反，您可以这样做：

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);

$q.all([allDone, promise4]).then(function() {
    // all four promises are done here
}); 

或者，您可以放弃

allDone

承诺，重新制作一个新的

.all（）

，如下所示：

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);

promises.push(promise4);
var all4Done = $q.all(promises);

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);
allDone.then(function(results) {
    // if no new promises have been added to the array
    if (promises.length === results.length) {
        // call our final handler
        return allDoneNow(results);
    } else {
        // wait for any new promises
        return $q.all(promises).then(allDoneNow);
    }
});

promises.push(promise4);

---

根据你的评论，这里有另一种可能性。假设您希望调用的最终完成处理程序位于名为

allDoneNow（）

的函数中。然后，你可以这样做：

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);

promises.push(promise4);
var all4Done = $q.all(promises);

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);
allDone.then(function(results) {
    // if no new promises have been added to the array
    if (promises.length === results.length) {
        // call our final handler
        return allDoneNow(results);
    } else {
        // wait for any new promises
        return $q.all(promises).then(allDoneNow);
    }
});

promises.push(promise4);

---

或者，如果您希望它是递归的，因此它会不断检查更多内容，您可以将它放入这样一个可以递归使用的函数中：

function waitAll(promiseArray) {
    return $q.all(promiseArray).then(function(results) {
        if (promiseArray.length <= results.length) {
            // everything currently in the promiseArray is now done
            return results;
        } else {
            // there are some new things in the promiseArray so
            // wait until they are done
            return waitAll(promiseArray);
        }
    });
}


var promises = [promise1, promise2, promise3];
waitAll(promises).then(function(results) {
    // all promises currently in the promises array are done
});

promises.push(promise4);

函数waitAll（promiseArray）{
返回$q.all（promiseArray）。然后返回（函数（结果）{
如果（promiseArray.length您不能在事件发生后向数组添加承诺，并期望它影响先前的
.all（）
。这不是
.all（）
的工作方式。您可以改为：

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);

$q.all([allDone, promise4]).then(function() {
    // all four promises are done here
}); 

或者，您可以放弃
allDone
承诺，重新制作一个新的
.all（）
，如下所示：

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);

promises.push(promise4);
var all4Done = $q.all(promises);

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);
allDone.then(function(results) {
    // if no new promises have been added to the array
    if (promises.length === results.length) {
        // call our final handler
        return allDoneNow(results);
    } else {
        // wait for any new promises
        return $q.all(promises).then(allDoneNow);
    }
});

promises.push(promise4);


根据您的评论，这里有另一种可能性。假设您希望调用的最终完成处理程序位于名为
allDoneNow（）
的函数中。然后，您可以执行以下操作：

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);

promises.push(promise4);
var all4Done = $q.all(promises);

var promises = [promise1, promise2, promise3];
var allDone = $q.all(promises);
allDone.then(function(results) {
    // if no new promises have been added to the array
    if (promises.length === results.length) {
        // call our final handler
        return allDoneNow(results);
    } else {
        // wait for any new promises
        return $q.all(promises).then(allDoneNow);
    }
});

promises.push(promise4);


或者，如果您希望它是递归的，因此它会不断检查更多内容，您可以将它放入这样一个可以递归使用的函数中：

function waitAll(promiseArray) {
    return $q.all(promiseArray).then(function(results) {
        if (promiseArray.length <= results.length) {
            // everything currently in the promiseArray is now done
            return results;
        } else {
            // there are some new things in the promiseArray so
            // wait until they are done
            return waitAll(promiseArray);
        }
    });
}


var promises = [promise1, promise2, promise3];
waitAll(promises).then(function(results) {
    // all promises currently in the promises array are done
});

promises.push(promise4);

函数waitAll（promiseArray）{
返回$q.all（promiseArray）。然后返回（函数（结果）{
if（promiseArray.length谢谢！我想我实际的问题是：有没有一种方法可以让我做出这样的行为？谢谢！我想我实际的问题是：有没有一种方法可以让我做出这样的行为？嗯，但这需要我以某种方式取消附加到第一个$q.all的任何.then（）回调。我希望得到一个更简单的解决方案：-）@user125661-您已经注册了一个处理程序来完成三个承诺。您不能更改。您可以添加新的处理程序来通知您新创建的条件。如果在您有前三个承诺时，您知道在前三个承诺完成之前您可能有更多的承诺，那么请不要注册最终的处理程序。注册一个虚拟处理程序，其任务是检查是否还有其他承诺需要等待，如果没有，则可以调用该处理程序。这是有意义的！我想的另一个解决方案可能是在四个承诺的集合中添加一个虚拟承诺。一旦我知道原始承诺集合应该更改，我就可以拒绝该虚拟promise，并按照上面的建议设置一个新的$q.all。@user125661-我在我的答案中添加了一个示例。@user125661-我在我的答案中添加了一个递归实现。嗯，但这需要我以某种方式取消附加到第一个$q.all的任何.then（）回调。我希望有一个更简单的解决方案：-）@user125661-您已经注册了一个处理程序来完成三个承诺。您不能更改。您可以添加新的处理程序来通知您新创建的条件。如果在您有前三个承诺时，您知道在前三个承诺完成之前您可能有更多的承诺，那么请不要注册最终的处理程序。注册一个虚拟处理程序，其任务是检查是否还有其他承诺需要等待，如果没有，则可以调用该处理程序。这是有意义的！我想的另一个解决方案可能是在四个承诺的集合中添加一个虚拟承诺。一旦我知道原始承诺集合应该更改，我就可以拒绝该虚拟promise，并按照上面的建议设置一个新的$q.all。@user125661-我在我的答案中添加了一个示例。@user125661-我在我的答案中添加了一个递归实现。