Nodo js + più funzioni interne nidificate con callback

Question

Ho funzioni interne nidificate con callback che si trovano nella singola funzione (abcd).

Devo chiamare la funzione abcd dall'esterno utilizzando async e restituire la risposta.

var listFunctions = { 
    test1 : function(objectData, callbackData) { 
     //have logic and retrun data 
     callbackData(null, "a"); 
    }, 
    test2 : function(objectData, callbackData) { 
     //have logic and retrun data 
     callbackData(null, "b"); 
    }, 
    test3 : function(objectData, callbackData) { 
     //have logic and retrun data 
     callbackData(null, "c"); 
    }, 
    test4 : function(objectData, callbackData) { 
     //have logic and retrun data 
     callbackData(null, "d"); 
    }, 
    test5 : function(objectData, callbackData) { 
     //have logic and retrun data 
     callbackData(null, "e"); 
    } 
}; 

function abcd(objectData, clb) { 

    listFunctions.test1(objectData, function(err, data1) { 
     listFunctions.test1(data1, function(err, data2) { 
      listFunctions.test1(data2, function(err, data3) { 
       listFunctions.test1(data3, function(err, data4) { 
        listFunctions.test1(data4, function(err, data5) { 
         return clb; 
        }); 
       }); 
      }); 
     }); 
    }); 
}; 

oggetto dati in matrice

var objectData = [{"id":1, "name" : "abcd"},{"id":2, "name" : "abc2d"},{"id":3, "name" : "3abcd"},{"id":4, "name" : "4abcd"}]; 

initalFunction(objectData, function(response) { 
    console.log(response); 
}); 

function initalFunction(objectData, result) { 

    async.each(objectData, function(dataValues, callback) { 
     abcd(dataValues, function(response) { 
      console.log(response); 
     }); 

    }, function(err) { 
     return result; 
     //Need to re 
    }); 
} 

necessario iterare tutti array di oggetti utilizzando nodo js asincrona utilizzando funzione initalFunction.

In quanto sopra ho aggiunto il mio codice, Si prega di suggerire il modo corretto.

Answer 1

Non sono sicuro di aver capito esattamente cosa stai cercando di ottenere, ma ci provo.

Il primo problema è che non è possibile impostare return un valore per la funzione esterna all'interno di una funzione di callback interna (vedere https://stackoverflow.com/a/6847754/3173842 per ulteriori informazioni al riguardo).

Inoltre si sta restituendo la funzione di callback non il risultato.

Questo è ciò che penso che in realtà voleva fare:

var async = require("async"); 

var listFunctions = { 
    test1: function(objectData, callbackData) { 
     objectData.name += ":a"; 
     callbackData(null, objectData); 
    }, 
    test2: function(objectData, callbackData) { 
     objectData.name += ":b"; 
     objectData.foo = "bar"; 
     callbackData(null, objectData); 
    }, 
    test3: function(objectData, callbackData) { 
     objectData.name += ":c"; 
     callbackData(null, objectData); 
    }, 
    test4: function(objectData, callbackData) { 
     objectData.name += ":d"; 
     callbackData(null, objectData); 
    }, 
    test5: function(objectData, callbackData) { 
     objectData.name += ":e"; 
     callbackData(null, objectData); 
    } 
}; 

function abcd(objectData, cb) { 
    listFunctions.test1(objectData, function(err, data1) { 
     listFunctions.test2(data1, function(err, data2) { 
      listFunctions.test3(data2, function(err, data3) { 
       listFunctions.test4(data3, function(err, data4) { 
        listFunctions.test5(data4, function(err, data5) { 
         cb(err, data5); 
        }); 
       }); 
      }); 
     }); 
    }); 
} 

function initalFunction(objectData, cb) { 
    var results = []; 

    async.each(objectData, function(dataValues, done) { 
     abcd(dataValues, function(err, response) { 
      results.push(response); 
      done(); 
     }); 
    }, function(err) { 
     cb(err, results); 
    }); 
} 

var objectData = [{id:1,name:"abcd"},{id:2,name:"abc2d"},{id:3,name:"3abcd"},{id:4,name:"4abcd"}]; 

initalFunction(objectData, function(err, response) { 
    if (err) { 
     console.log(err.stack); 
     return; 
    } 
    console.log("Result:", response); 
}); 

Ora lascia uso async.seq e async.map per semplificare questo:

var async = require("async"); 

var listFunctions = { 
    test1: function(objectData, callbackData) { 
     objectData.name += ":a"; 
     callbackData(null, objectData); 
    }, 
    test2: function(objectData, callbackData) { 
     objectData.name += ":b"; 
     objectData.foo = "bar"; 
     callbackData(null, objectData); 
    }, 
    test3: function(objectData, callbackData) { 
     objectData.name += ":c"; 
     callbackData(null, objectData); 
    }, 
    test4: function(objectData, callbackData) { 
     objectData.name += ":d"; 
     callbackData(null, objectData); 
    }, 
    test5: function(objectData, callbackData) { 
     objectData.name += ":e"; 
     callbackData(null, objectData); 
    } 
}; 

var abcd=async.seq.apply(null, [ 
    listFunctions.test1, 
    listFunctions.test2, 
    listFunctions.test3, 
    listFunctions.test4, 
    listFunctions.test5 
]); 

function initialFunction(objectData, cb) { 
    async.map(objectData, abcd, cb); 
} 

var objectData = [{id:1,name:"abcd"},{id:2,name:"abc2d"},{id:3,name:"3abcd"},{id:4,name:"4abcd"}]; 

initialFunction(objectData, function(err, response) { 
    if (err) { 
     console.log(err.stack); 
     return; 
    } 
    console.log("Result:", response); 
}); 

Se è possibile modificare listFunctions da oggetto a matrice :

var async = require("async"); 

var listFunctions = [ 
    function test1(objectData, callbackData) { 
     objectData.name += ":a"; 
     callbackData(null, objectData); 
    }, 
    function test2(objectData, callbackData) { 
     objectData.name += ":b"; 
     objectData.foo = "bar"; 
     callbackData(null, objectData); 
    }, 
    function test3(objectData, callbackData) { 
     objectData.name += ":c"; 
     callbackData(null, objectData); 
    }, 
    function test4(objectData, callbackData) { 
     objectData.name += ":d"; 
     callbackData(null, objectData); 
    }, 
    function test5(objectData, callbackData) { 
     objectData.name += ":e"; 
     callbackData(null, objectData); 
    } 
]; 

function initialFunction(objectData, cb) { 
    async.map(objectData, async.seq.apply(null, listFunctions), cb); 
} 

var objectData = [{id:1,name:"abcd"},{id:2,name:"abc2d"},{id:3,name:"3abcd"},{id:4,name:"4abcd"}]; 

initialFunction(objectData, function(err, response) { 
    if (err) { 
     return console.error(err.stack); 
    } 
    console.log("Result:", response); 
}); 

se non, ma hanno ancora bisogno di gestire le dinamiche listFunctions:

function initialFunction(objectData, cb) { 
    var list = Object.keys(listFunctions).map(function(name) { 
     return listFunctions[name]; 
    }); 
    async.map(objectData, async.seq.apply(null, list), cb); 
} 

Spero che questo aiuta.