Javascript 等待回调完成后再返回给用户

我有一个动态案例，用户将发布一个数据数组，我需要将这些数据插入数据库的不同行中。在将成功或失败返回给用户之前，如何等待回拨完成

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

我试着使用promise，但它返回了这个

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

未处理的PromisejectionWarning:未处理的承诺拒绝 （拒绝id:2）：TypeError:无法读取属性 未定义（节点：6216）的“Symbol（Symbol.iterator）”弃用警告： 未经处理的承诺拒绝被弃用。在未来，承诺 未处理的拒绝将终止Node.js进程 使用非零退出代码

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

我的承诺

req.targetting.forEach(data => {
      let s = {};
      if (data.value == '' || data.value.length == 0) {
        s = 99;
      } else {
        s = data.status;
      }
      let promises =  new Promise((resolve, reject) => {
        XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
            if (err) {
              return reject(err);
            }
            return resolve(data);
          });
      });
      Promise.all(promises).then((err, data) => {
        if (err) {
          return callback(err);
        }
        callback(null, data);
      });
    });
  };

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

我想把承诺放在一边，但拒绝id为3的错误仍然是一样的

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

upsert方法的签名

PersistedModel.upsertWithWhere([where], data, callback)

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

---

我想这样的东西应该没问题（我没有测试这段代码）

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

---

我想这样的东西应该没问题（我没有测试这段代码）

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

---

您需要用另一种方法包装您的迭代。建立一个承诺列表，然后等待它得到解决。如下图所示

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

---

您需要用另一种方法包装您的迭代。建立一个承诺列表，然后等待它得到解决。如下图所示

function orgMethod(){
            let promises =[];
            req.targetting.forEach(data => {
                  let s = {};
                  if (data.value == '' || data.value.length == 0) {
                    s = 99;
                  } else {
                    s = data.status;
                  }
                  promises.push(new Promise((resolve, reject) => {
                    XXX.upsertWithWhere(where clause,data, (err, data) => { // a loopback method
                        if (err) {
                          return reject(err);
                        }
                        return resolve(data);
                      });
                  }));

                });
              };
     Promise.all(promises).then((err, data) => {
                    if (err) {
                      return callback(err);
                    }
                    callback(null, data);
                  });
        }

---

Promise.all（）接受一个不可接受的对象我猜你只是在传递一个承诺。同样从promise.all（）块返回callback（）函数，该函数在哪里声明？它不在

参数中

@KumarShubham有一个错误，我没有得到，我想要的是得到所有承诺，并且只有在回调完成时才返回，未经处理的拒绝是因为您向promise.all（）方法.promise.all（）传递了一个承诺，而不是一个iterable对象我想你只是在传递一个承诺。同样从promise.all（）块返回callback（）函数，该函数在哪里声明？它不在

参数中

@KumarShubham有一个错误，我没有得到，我想要的是得到所有承诺，并且只在回调完成时返回。未经处理的拒绝出现，因为您正在向promise.all（）方法传递一个承诺，而不是一个iterable对象。