Node.js 在以下情况下决定或拒绝承诺：；请求/ajax"；答复是'；成功'；蓝知更鸟

我对使用蓝鸟的承诺还不熟悉。 当状态响应从api更改为“成功”时，我试图解决一个承诺。 下面是我的代码：

exports.getdata(taskCreation, headers) {
  var deferred = Promise.pending();

  var headers = {
    "Authorization": "Secret xxxxxxxxxxxxxxxxx"
  };

  while (true) {
    request.get({
      url: "https://dragon.stupeflix.com/v2/status",
      qs: {
        tasks: taskCreation[0]["key"]
      },
      headers: headers,
      json: true
    }, function (error, httpObj, taskStatusAndResult) {
      if (!error && httpObj.statusCode == 200) {
        console.log(taskStatusAndResult[0]["status"]); //contains either "queued", "executing", "success", or "error"
        if (taskStatusAndResult[0]["status"] == "success")
          deferred.resolve(taskStatusAndResult);

      } else {
        deferred.reject(error);
      }
    })
  }
        return deferred.promise;
}

---

api需要几秒钟的时间来处理视频，生成videourl，并将状态设置为“成功”。在此之前，我想反复调用api，只有在状态为“成功”时才能解决承诺。我的无限while循环代码不起作用。关于如何以最佳方式实现此要求的任何建议。

您不能将

while（）

循环与异步操作一起使用。它将在任何一个API调用完成之前启动大量API调用。相反，你必须对事情进行排序。进行一次API调用。当您得到结果时，在结果处理程序中决定下一步要做什么

另外，你没有对你正在创建的承诺做任何事情，所以我决定从你的函数中返回承诺

而且，您的

exports.getData

声明不是正确的函数声明

---

这里有一个想法，您返回一个承诺，如果您最终找到“成功”状态，承诺将得到解决，如果出现错误情况，承诺将被拒绝

这实现了以下逻辑：

进行API调用。当你得到回应时，做四件事中的一件

如果响应是错误的，则拒绝带有该错误的承诺

如果回答是成功的，用结果来解决承诺

如果响应不是错误，但尚未成功，并且您已超过最大重试次数，则使用最大重试次数拒绝

如果响应不是错误，但尚未成功，并且您尚未超过最大重试次数，请重试

从函数返回一个承诺，这样调用方就可以在承诺上使用

。然后（）

，从操作中获取结果或错误

代码如下：

exports.getdata = function (taskCreation, headers) {
    var headers = {"Authorization": "Secret xxxxxxxxxxxxxxxxx"};
    var cntr = 0;
    var maxRetries = 20;

    return new Promise(function (resolve, reject) {
        function next() {
            ++cntr;
            request.get({
                url: "https://dragon.stupeflix.com/v2/status",
                qs: {tasks: taskCreation[0]["key"]},
                headers: headers,
                json: true
            }, function (error, httpObj, taskStatusAndResult) {
                if (!error && httpObj.statusCode == 200) {
                    console.log(taskStatusAndResult[0]["status"]); //contains either "queued", "executing", "success", or "error"
                    if (taskStatusAndResult[0]["status"] === "success") {
                        // found success to resolve the promise
                        resolve(taskStatusAndResult);
                    } else {
                        // if not "success" yet, then try again
                        if (cntr > maxRetries) {
                            reject(new Error("max retries exceeded"));
                        } else {
                            // try again
                            next();
                        }
                    }
                } else {
                    // got some kind of error here, so stop further processing
                    reject(error);
                }
            })
        }
        // start the first request
        next();
    });
}

---

不能将

while（）

循环与异步操作一起使用。它将在任何一个API调用完成之前启动大量API调用。相反，你必须对事情进行排序。进行一次API调用。当您得到结果时，在结果处理程序中决定下一步要做什么

另外，你没有对你正在创建的承诺做任何事情，所以我决定从你的函数中返回承诺

而且，您的

exports.getData

声明不是正确的函数声明

---

这里有一个想法，您返回一个承诺，如果您最终找到“成功”状态，承诺将得到解决，如果出现错误情况，承诺将被拒绝

这实现了以下逻辑：

进行API调用。当你得到回应时，做四件事中的一件

如果响应是错误的，则拒绝带有该错误的承诺

如果回答是成功的，用结果来解决承诺

如果响应不是错误，但尚未成功，并且您已超过最大重试次数，则使用最大重试次数拒绝

如果响应不是错误，但尚未成功，并且您尚未超过最大重试次数，请重试

从函数返回一个承诺，这样调用方就可以在承诺上使用

。然后（）

，从操作中获取结果或错误

代码如下：

exports.getdata = function (taskCreation, headers) {
    var headers = {"Authorization": "Secret xxxxxxxxxxxxxxxxx"};
    var cntr = 0;
    var maxRetries = 20;

    return new Promise(function (resolve, reject) {
        function next() {
            ++cntr;
            request.get({
                url: "https://dragon.stupeflix.com/v2/status",
                qs: {tasks: taskCreation[0]["key"]},
                headers: headers,
                json: true
            }, function (error, httpObj, taskStatusAndResult) {
                if (!error && httpObj.statusCode == 200) {
                    console.log(taskStatusAndResult[0]["status"]); //contains either "queued", "executing", "success", or "error"
                    if (taskStatusAndResult[0]["status"] === "success") {
                        // found success to resolve the promise
                        resolve(taskStatusAndResult);
                    } else {
                        // if not "success" yet, then try again
                        if (cntr > maxRetries) {
                            reject(new Error("max retries exceeded"));
                        } else {
                            // try again
                            next();
                        }
                    }
                } else {
                    // got some kind of error here, so stop further processing
                    reject(error);
                }
            })
        }
        // start the first request
        next();
    });
}

---

不能将

while（）

循环与异步操作一起使用。它将在任何一个API调用完成之前启动大量API调用。相反，你必须对事情进行排序。进行一次API调用。当您得到结果时，在结果处理程序中决定下一步要做什么

另外，你没有对你正在创建的承诺做任何事情，所以我决定从你的函数中返回承诺

而且，您的

exports.getData

声明不是正确的函数声明

---

这里有一个想法，您返回一个承诺，如果您最终找到“成功”状态，承诺将得到解决，如果出现错误情况，承诺将被拒绝

这实现了以下逻辑：

进行API调用。当你得到回应时，做四件事中的一件

如果响应是错误的，则拒绝带有该错误的承诺

如果回答是成功的，用结果来解决承诺

如果响应不是错误，但尚未成功，并且您已超过最大重试次数，则使用最大重试次数拒绝

如果响应不是错误，但尚未成功，并且您尚未超过最大重试次数，请重试

从函数返回一个承诺，这样调用方就可以在承诺上使用

。然后（）

，从操作中获取结果或错误

代码如下：

exports.getdata = function (taskCreation, headers) {
    var headers = {"Authorization": "Secret xxxxxxxxxxxxxxxxx"};
    var cntr = 0;
    var maxRetries = 20;

    return new Promise(function (resolve, reject) {
        function next() {
            ++cntr;
            request.get({
                url: "https://dragon.stupeflix.com/v2/status",
                qs: {tasks: taskCreation[0]["key"]},
                headers: headers,
                json: true
            }, function (error, httpObj, taskStatusAndResult) {
                if (!error && httpObj.statusCode == 200) {
                    console.log(taskStatusAndResult[0]["status"]); //contains either "queued", "executing", "success", or "error"
                    if (taskStatusAndResult[0]["status"] === "success") {
                        // found success to resolve the promise
                        resolve(taskStatusAndResult);
                    } else {
                        // if not "success" yet, then try again
                        if (cntr > maxRetries) {
                            reject(new Error("max retries exceeded"));
                        } else {
                            // try again
                            next();
                        }
                    }
                } else {
                    // got some kind of error here, so stop further processing
                    reject(error);
                }
            })
        }
        // start the first request
        next();
    });
}

---

不能将

while（）

循环与异步操作一起使用。它将在任何一个API调用完成之前启动大量API调用。相反，你必须对事情进行排序。进行一次API调用。当您得到结果时，在结果处理程序中决定下一步要做什么

另外，你没有对你正在创建的承诺做任何事情，所以我决定从你的函数中返回承诺

而且，您的

exports.getData

声明不是正确的函数声明

---

这里有一个想法，您返回一个承诺，如果您最终找到“成功”状态，承诺将得到解决，如果出现错误情况，承诺将被拒绝

这实现了以下逻辑：

进行API调用。当你得到回应时，做四件事中的一件

如果响应是错误的，则拒绝带有该错误的承诺

如果回答是成功的，用结果来解决承诺

如果响应不是错误，但尚未成功，并且您已超过最大重试次数，则使用最大重试次数拒绝

如果响应不是错误，但尚未成功，并且您尚未超过最大重试次数，请重试