javascript中带promise的批处理模式

我需要处理很多数据。对于每个数据条目，我们都需要向mysql提交查询。我目前的解决方案如下：

    var Q = require('q');
    function process(entry){
        ...
        var defered=Q.defer();
        connection.query(sql,defered.makeNodeResolver());
        return defered.promise;
    }
    function ProcessAll(results ) {
        var waitfor=[];
        for( var i=0;i< results.length;i++){
            waitfor.push( process(results[i]));
        }
        Q.all(waitfor).then(function(results) {
            notifySuc(results);
        },function(results){
            notifyFail(results);
        });
    }

我怎样才能把它分成小批量？例如，我们每次可以处理1000个条目。在他们都是一个，我们继续休息。如何使用回调函数实现这一点

---

此外，我们可以并行处理多个条目吗？

您可以使用类似的方法来完成此操作。您可以使用Bacon.fromPromise（promise[，abort][，eventTransformer]）创建事件流，然后使用stream.bufferWithCount（count）将处理分解为批BaconJS是一个小型函数式反应式编程库。要了解有关FRP的更多信息，您可以阅读快速入门指南。

如果错误不是由于

notifySuc

造成的，您可以按如下方式一次轻松处理一批

var Q = require('q');
function process(entry){
    ...
    var defered=Q.defer();
    connection.query(sql,defered.makeNodeResolver());
    return defered.promise;
}
function processBatch(batch) {
    return Q.all(batch.map(item => process(item)));
}
function ProcessAll(results) {
    var batchSize = 1000;
    var pos = 0;
    var promises = Q([]); // initial promise of empty array
    while (pos < results.length) {
        (function(pos) {
            promises = promises.then(result => processBatch(results.slice(pos, batchSize)).then(results => result.concat(results)));
        })(pos);
        pos += batchSize;
    }
    promises.then(function(results) {
        notifySuc(results);
    },function(results){
        notifyFail(results);
    });
}

var Q=require（'Q'）；
功能流程（条目）{
...
var defered=Q.defer（）；
query（sql，defered.makeNodeResolver（））；
延期归还。承诺；
}
函数processBatch（批处理）{
返回Q.all（batch.map（item=>process（item））；
}
函数ProcessAll（结果）{
var-batchSize=1000；
var-pos=0；
var promises=Q（[]）；//空数组的初始承诺
而（位置<结果长度）{
（功能（pos）{
promises=promises.then（result=>processBatch（results.slice（pos，batchSize））。然后（results=>result.concat（results））；
})（pos）；
pos+=批量大小；
}
承诺。然后（功能（结果）{
通知SUC（结果）；
}，功能（结果）{
通知失败（结果）；
});
}

您确定需要向数据库提交多个查询吗？难道不可能进行一个大查询，然后处理该查询的结果吗？

我们可以并行处理多个条目吗。。。它们是并行处理的（尽可能多地使用javascript）。。。你的代码触发了尽可能多的
连接。查询
，因为数组中有元素。我无法将多个查询合并为一个查询，因为数据太大。如果我有100k个条目，那么对于每个条目，我需要编写1K字节的查询，组合的100M查询将太大，无法提交到数据库。此外，分解成小批量的主要目的是每次只需要1k个条目的内存，而不是一次加载所有100M。似乎当同步调用results.slice时，pos已经达到results.length。因此，processBatch总是传递一个空数组。啊啊啊，poop。。。忘记我的生活：p
var Q = require('q');
function process(entry){
    ...
    var defered=Q.defer();
    connection.query(sql,defered.makeNodeResolver());
    return defered.promise;
}
function processBatch(batch) {
    return Q.all(batch.map(item => process(item)));
}
function ProcessAll(results) {
    var batchSize = 1000;
    var pos = 0;
    var promises = Q([]); // initial promise of empty array
    while (pos < results.length) {
        (function(pos) {
            promises = promises.then(result => processBatch(results.slice(pos, batchSize)).then(results => result.concat(results)));
        })(pos);
        pos += batchSize;
    }
    promises.then(function(results) {
        notifySuc(results);
    },function(results){
        notifyFail(results);
    });
}