在蓝鸟承诺中使用异步包

Question

我想知道我是否在 promise 中使用异步，如下所示：

new Promise(function(resolve, reject) {
 async.mapLimit(files, 3000, function(file, callback) {
   //
   //
 }, function(result) {
   //
 });
});

我这样做是因为我最多需要处理 3000 个文件，但如果超过 9000 个，我需要在调用堆栈中的其他函数之前处理所有文件。

例如，我使用的是新的 Promise，但我在实际代码中使用的是 promisifyAll。哪个是 "same"

我有这个 MainObject：

var MyObject = {}

内部，我有 4 个步骤，我正在使用 promisifyAll，因为我需要等待一个步骤完成，然后再调用另一个步骤，如下所示：

var MyObject = {
  stepOne: function(files, callback) {
  },

  stepTwo: function(files, callback) {
  },

  stepThree: function(files, callback) {
  },

  stepFour: function(files, callback) {
  }
};

Promise.promisifyAll(MyObject);

问题是，在哪一步（我在这里处理文件）我只允许程序运行 3.000 异步，所以为了实现这个，我使用以下内容：

async.mapLimit(files, 3000, function() {

}, function(result) {
});

因此，最终代码将是：

var MyObject = {
  stepOne: function(files, callback) {
    async.mapLimit(files, 3000, function() {

     }, function(result) {
    });
  },

  stepTwo: function(files, callback) {
    async.mapLimit(files, 3000, function() {

     }, function(result) {
    });
  },

  stepThree: function(files, callback) {
    async.mapLimit(files, 3000, function() {

     }, function(result) {
    });
  },

  stepFour: function(files, callback) {
    async.mapLimit(files, 3000, function() {

     }, function(result) {
    });
  }
};

Answer 1

只需使用 Bluebird 的 Promise.map() 并传递并发选项：

Promise.map(files, function(file) {
    // process the file here, return result or promise of result
}, {concurrency: 3000}).then(...)

文档和代码示例 here。

当然，您可以在 promise 中使用异步，但我不推荐这样做：

var p = new Promise(function(resolve, reject) {
 async.mapLimit(files, 3000, function(file, callback) {
   //
   //
   callback(null, result);
 }, function(err, results) {
     if (err) {
         reject(err);
     } else {
         resolve(results);
     }
 });
});

同样，我建议使用 Promise.map():

var MyObject = {
  stepOne: function(files) {
    return Promise.map(files, function(file) {
        // process a file
        // return result or promise of result
    }, {concurrency: 3000});
  },

  stepTwo: function(files) {
    return Promise.map(files, function(file) {
        // process a file
        // return result or promise of result
    }, {concurrency: 3000});
  },

  stepThree: function(files) {
    return Promise.map(files, function(file) {
        // process a file
        // return result or promise of result
    }, {concurrency: 3000});
  },

  stepFour: function(files) {
    return Promise.map(files, function(file) {
        // process a file
        // return result or promise of result
    }, {concurrency: 3000});
};

那么，就不需要 promisifyAll()，因为这些方法已经使用了 promises。

MyObject.stepOne(files).then(MyObject.stepTwo).then(MyObject.stepThree).then(MyObject.stepFour);

在蓝鸟承诺中使用异步包

Using async package inside blue bird promises

javascript

asynchronous

bluebird