解决方案：

Question

我想知道是否有人知道用javascript递归进行一次调用的方法。我正在尝试一次将大量数据上传到cloudant数据库500个项目。我不知道json的文件长度（在2000-4000之间），所以我创建了一个递归函数将其拆分为500个块并上传。

insertDBBulkData: function(trgtDB, dbDocData, callback) {

    // if length > 500, recursively upload 500 at a time
    if(dbDocData.length > 500) {
        console.log("File too big. Length " + dbDocData.length)
        module.exports.insertDBBulkData(trgtDB, dbDocData.slice(500, dbDocData.length), function(err, body) {
            if(err) {   
                console.log(err);
                callback(err, body)
            } else {
                // only callback on last one
                callback(err, body);
            }
        });

        dbDocData = dbDocData.slice(0, 500);
    }

    trgtDB.bulk({"docs": dbDocData}, function(err, body) {
        if(err) {
            callback(err);
        } else {
            console.log("Successfully uploaded " + dbDocData.length + " users. ")
            callback(null, "Success!")
        }
    });
},

问题是：由于我不知道哪个呼叫会最后结束，所以我不知道何时将响应发送回服务器（我只能执行一次）。我已经尝试过使用Promises，但是据我所知，我无法在此递归方法中使用Promises，因为我没有固定次数调用该方法。兑现承诺可以实现这一点吗？

感谢您的帮助。谢谢！

解决方案：

感谢JonasW。我能够在for循环中以多个promise来执行此操作。它不使用递归，但效果更好。这是我的解决方案：

insertDBBulkData: function(trgtDB, dbDocData, callback) {
    const promises = [];

    for(let start = 0; start < dbDocData.length; start += 500) {
        console.log("File too big. Index: " + start);

        var dbBulkDataPromise = new Promise(function(resolve, reject) {
            trgtDB.bulk({"docs": dbDocData.slice(start, start+500)}, function(err, body) {
                if(err) {
                    reject(err);
                } else {
                    resolve("Success")
                }
            });
        });

        promises.push(dbBulkDataPromise);
    }

    Promise.all(promises).then(function(values) {
        console.log(values);
        var completed = true;

        for (message in values) {
            if (message != "Success") {
                completed = false;
            }
        }

        if (completed) {
            callback(null, values)
        } else {
            console.log("Partial upload")
            callback("Partial upload only", null)
        }


    }).catch(function(err) {
        console.log("Error uploading data: " + err);
        callback(err, null)
    });
},

Answer 1

如果您将一个插入的内容包装到promise中：

function insert(docs) {
   return new Promise((resolve, reject) => {
      trgtDB.bulk({ docs }, function(err, body) {
        if(err) {
          reject(err);
        } else {
           console.log("Successfully uploaded " + docs.length + " users. ")
           resolve("Success!")
       }
   });
  });
}

现在您可以遍历大批量数据，将其切成块，为每个块开始插入，然后等待所有承诺：

const promises = [], size = 500;

for(let start = 0; start < dbDocData.length; start += size)
  promises.push(insert( dbDocData.slice(start, start + size) ));

Promise.all(promises).then(() => {
  console.log("all done");
}).catch(/* handle errors */);

Answer 2

这是一个使用诺言的简单示例：

    function insertData(trgtDB, dbDocData, callback) {
      var batchSize = 500;

      while (dbDocData.length > 0) {
        var batch = dbDocData.slice(0, batchSize);
        dbDocData.splice(0, batchSize);

        insertBatch(targetDB, dbDocData.slice(500, dbDocData.length))
          .then(function(result) {
            // everything inserted just fine
            if (dbDocData.length < 1){
              callback(yourParams);
            }
          })
          .error(function(err) {
            // handle your error
          });
      }

    }

    function insertBatch(trgtBD, batch) {
      // return a new promise 
      return new Promise(function(resolve, reject) {
        // load into the db
        trgtDB.bulk({
          "docs": batch
        }, function(err, body) {
          if (err) {
            // there was an error reject the promise
            reject(err);
          } else {
            // everything is good, 
            resolve("Success!")
          }
        });
      })
    }

有没有一种方法可以仅通过一个回调调用来递归地进行异步调用？

解决方案：

2 个答案: