Node.js的Async.js出现问题

trouble with Async.js for Node.JS

本文关键字：js 问题 Async Node      更新时间：2023-09-26

我试图对抗回调地狱，但我的代码有问题。

有人知道如何将async.js实现为这样的结构：

for(var i=0;i<array1.length;i++){
 //do something
 for(var j=0;j<array2.length;j++){
  //do something
  for(var k=0;k<array3.length;k++){
   //do something
   bd.findSomethig(array3[k].id, function(err, result){
   });
   bd.findSomethig(array3[k].ref, function(err, result){
   });
  }
 }
}

更新：

我将把实现所需的实际结构放在这里

     var array1 = array;
      var rsp=[];
        for(var i=0;i<array1.length;i++){
          var object1 = new Object();
          object1.a="xx";
          object1.b="xx";
          object1.c="xx";
          object1.d="xx";
            var array2=array1[i].array2;
            var array2Result=[];
            for(var j=0;j<array2.length;j++){
              var object2 = new Object();
                object2.a="xx";
                object2.b="xx";
                object2.c="xx";
                object2.d="xx";
              var array3=array1[i].array2[j].array3;
              var array3Result=[];
              for(var k=0;k<array3.length;k++){
               var object3 = new Object();
               var array4=array1[i].array2[j].array3[l].array4;
                var array3Result4=[];
                for(var l=0;l<array4.length;l++){
                  var object4 = new Object();
                  var array5=array1[i].array2[j].array3[k].array4[l].array5;
                  for (var m=0;m<array5.length;m++){
                    if(someConditional){
                        object4.a="xx";
                        object4.b="xx";
                        object4.c="xx";
                        object4.d="xx";
                        //Here i need to call a BD function to find some rows i need to build the JSON response
                          bd.findSomethig(array5[m].id, function(err, result){
                              object4.e=result;
                           });
                           bd.findSomethig(array5[m].ref, function(err, result){
                              object4.f=result;
                           });
                        array3Result4.push(object4);
                    }
                  }
                object3.a=segments;
                array3Result.push(object3);
              }
                object2.e=array3Result;
              array2Result.push(object2)              
            }
            object1.e=array2Result;
            rsp.push(object1);
          }

您的代码通常如下所示：

async.map(array1, function(item, next){
   var modifiedItem = modify(item);
   next(null, modifiedItem);
}, function(err, results){
   // results is an array of modifiedItem's here
});

为了获得良好的可读性，您必须不按原样编写。
相反，您定义了一些函数，这些函数修改项并调用next回调
此函数称为iterators。

例如：

function doubleIterator(item, next) {
  next(null, 2*item);
}
async.map([1,2,3], doubleIterator, function (err, results) {
  // we have results = [2, 4, 6] here
});

此外，我们可以根据需要生成迭代器：

function getFieldIterator(field) {
   return function (item, next) {
      next(null, item[field]);
   }      
}
async.map([{id: 1}, {id: 7}], getFieldIterator('id'), function(err, results){
  // results = [1, 7]
});

对于应用多维结构，我们可以从迭代器中调用async方法：

   function getMapIt(iterator) {
     return function(item, next) {
       async.map(item, iterator, next);
     };
   }

async.map([[1, 2], [3, 4]], getMapIt(doubleIterator), function(err, results){
  // getMapIt returns iterator which receive two arrays
  // it run async.map on each of them
  // and apply doubleIterator in each
  // so, we have results = [[2, 4], [6, 8]] here
})

有最新问题。在这里，我们只需要构建迭代器，然后运行：）

async.map(array1, mapIterator(mapIterator(searchIterator)), callback);
// assume you have just 3-dimensional array
function mapIterator(iterator) {
  return function(item, next) {
    async.map(item, iterator, next);  
  }
}
//with structure in your question:
function mapField(field, iterator) {
  return function(item, next) {
    async.map(item[field], iterator, next);  
  }
}
// and use it as
// mapField('array2', mapField('array3', searchIterator))
function searchIterator(item, next) {
   async.parallel({
     id: search(item.id),
     ref: search(item.ref)
   }, next);       
}
function search(id) {
  return function(next){
    bd.findSomethig(id, next);
  }
}
function callback(err, results) {
  if (err) return console.error(err);
  console.log('Batch of results: ',results);
  // It should be represented same of array1 structure:
  /*
  [
    [
       [{id: dbRes, ref: dbRes}, {id: dbRes, ref: dbRes}],
       [{id: dbRes, ref: dbRes}, {id: dbRes, ref: dbRes}],
       [{id: dbRes, ref: dbRes}, {id: dbRes, ref: dbRes}]
    ],
    [
       [{id: dbRes, ref: dbRes}, {id: dbRes, ref: dbRes}],
       [{id: dbRes, ref: dbRes}, {id: dbRes, ref: dbRes}]
    ]
  ]
  */
}

可能需要在这里玩极限游戏
但构建这个概念现在应该很清楚了。

相关文章：