JavaScript承诺-在继续之前等待解决方案

我有以下要求：

通过调用内部函数（getLines（））获取“行”列表

选择第一行，执行操作

上一个操作完成后，选择下一行并执行相同的操作

对所有行重复此操作（3-20，取决于用户）

我有以下代码：

App.Lines = response.data;    
for (var _i = 0; _i < App.Lines.length; _i++) {
    var makeCallPromise = new Promise(
        function(resolve, reject) {
            Session.connection.ol.makeCall(App.Lines[_i], callBackFunction(response) {
                //this can take up to 30 seconds to respond...
                resolve(response.data);
            }, errorCallBackFunction(message) {
                reject(message.error);
            }, bareJid);
        }
    )
    makeCallPromise.then(function(fulfilled) {
        console.log("PROMISE WORKED!!!!!", fulfilled);
    })
    .catch(function(error) {
        console.log("PROMISE FAILED!!!!!", error);
    });
}

App.Lines=response.data；
对于（var_i=0；_i

我的希望是，循环将在继续循环之前等待承诺的解决，然而，事实并非如此。 我的问题是，在解决方案完成之前，是否有可能停止循环。 注意-我使用bluebird JS库来实现承诺。 谢谢大家!

亲切问候,

---

Gary

您可以使用bluebird提供的，它会连续遍历一个数组，等待它们解析，然后再移动到数组中的下一个元素

我不知道bluebird，但您可以这样做，创建某种for循环，等待每个承诺在下一次迭代之前结束

这是一个通用示例，它当然可以优化，只是一个快速尝试：

var i = 0;
var performAsyncOperation = function(operationNumber) {
    return new Promise(function(resolve, reject){
    console.log('Operation number', operationNumber);
    resolve();
  });
}

var chainAsyncOperations = function() {
    if(++i < 10) {
        return performAsyncOperation(i).then(chainAsyncOperations);
    }
};
performAsyncOperation(i).then(chainAsyncOperations);

var i=0；
var performAsyncOperation=功能（操作编号）{
返回新承诺（功能（解决、拒绝）{
控制台日志（'操作编号'，操作编号）；
解决（）；
});
}
var chainAsyncOperations=函数（）{
如果（++i<10）{
返回performAsyncOperation（i）。然后返回（chainAsyncOperations）；
}
};
绩效管理（i）。然后（操作）；

---

希望这对你有帮助；）

此用例与ES7功能完美匹配

async await

，如果您可以使用babeljs传输代码，您可以像这样重构您的函数：

function createPromise(line) {
    return new Promise(
       function(resolve, reject) {
          Session.connection.ol.makeCall(line, callBackFunction(response) {
              //this can take up to 30 seconds to respond...
              resolve(response.data);
          }, errorCallBackFunction(message) {
              reject(message.error);
          }, bareJid);
       }
    );
}

App.Lines = response.data;

async function main() {
    for (var _i = 0; _i < App.Lines.length; _i++) {
        try {
           var result = await createPromise(App.Lines[_i]);
           console.log(result);
        } catch (err) {
           console.log(err);
        }
    }
}

main().then(function() {
    console.log('finished');
});

函数createPromise（行）{
回报新的承诺(
功能（解析、拒绝）{
Session.connection.ol.makeCall（行，callBackFunction（响应）{
//这可能需要30秒来响应。。。
解析（response.data）；
}，errorCallBackFunction（消息）{
拒绝（message.error）；
}，bareJid）；
}
);
}
App.Lines=response.data；
异步函数main（）{
对于（var_i=0；_i

您应该使用

蓝鸟#每种

方法：

.each（函数（任意项、int索引、int长度）迭代器）->Promise

迭代一个数组或一个数组的承诺，该数组包含承诺（或承诺和值的组合），给定迭代器函数具有签名（值、索引、长度），其中值是输入数组中相应承诺的解析值。迭代是连续发生的。如果输入数组中的任何承诺被拒绝，则返回的承诺也被拒绝

---

我认为你必须以某种方式回报承诺。就像在本例中，

履行

是您在承诺中使用的关键短语。不要循环整个内容，而是循环makeCallPromise并将这些承诺推送到一个数组中。然后使用Promise.all（数组）并在Promise.all之后添加

Then（）

调用。结果是，在调用第一个

then（）

之前，所有promsie都将被解析，因此所有数据都可以再次循环。或者，完全不要使用循环，而是在前一个问题解决后进行下一个makeCallPromise。@Shilly谢谢，我已经尝试在marvel308提供的答案中使用它，以及Promise.each（）。我的回答是关于我所做的事情和发生的事情。承诺101-承诺不会使异步代码同步：我尝试通过迭代承诺并创建它们的数组（而不是在迭代中解析它们）来使用它。然后我调用了'promiseArray，function（result）{console.log（result）}.then（function（completed）{console.log（“WORKED”）}.catch（function（error）{console.log（“error”）}）；'。问题是，这不起作用，它仍然尝试执行Session.connection.ol.makeCall，而不等待第一个问题解决。您是否使用bluebird？嗯，我已通过将bluebird库包含在中来加载它，但我没有使用node.js，因此我没有完成npm安装或要求。听起来这是必需的？忽略最后一条注释，我正在使用requirejs正确加载它：

requirejs（['bluebird']，function（Promise）{//application code here}）。这仍然不起作用，它在不等待的情况下调用两个makeCall函数。嗨，这不起作用，我真的不明白它在做什么。在一个简单的1行值的情况下，它看起来像是在同一时刻发出了两次
Session.connection.ol.makeCall
，所以我们立即得到了一个失败。当我将其更新为2行时，它会立即发出4个
Session.connection.ol.makeCall
，然后在响应返回后再发出2个。根据您问题中的代码，
App.Lines
是一个行数组，在我的代码中，我使用
Bluebird#each
方法迭代该数组，并为eac调用
Session.connection.ol.makeCal
Promise.each(App.Lines, line => {
    return new Promise((resolve, reject) => {
        Session.connection.ol.makeCall(line, callBackFunction(response) {
            resolve(response.data);
        }, errorCallBackFunction(message) {
            reject(message.error);
        }, bareJid);
    })
    .then(fulfilled => console.log("PROMISE WORKED!!!!!", fulfilled))
    .catch(err => onsole.log("PROMISE FAILED!!!!!", err));
});