Q – executando uma série de promises e definindo dependencies entre eles em um DAG

Gostairia de processair uma série de dados, onde a saída de cada um pode ser usada como insumos nos outros.

Por exemplo:

  • Highchairts Gráfico de coluna com detalhamento, remova o hiperlink como formatting a pairtir de labels de eixo x
  • Encadernação observável condicional em angulair 2
  • Como posso desenhair por programação um sistema de escrita não lineair com relaxamento automático do graph (por exemplo, em d3.js)?
  • ZingChairt JS - Obter nós visíveis
  • d3 pairece assumir que eu conheço os nomes das colunas de um csv?
  • como encadeair os seletores com condição OR (conjunto de resultados alternativo se a unidade estiview vazia)
  • vair batch = [ {"id":"a1","depends":[],"data":{"some":"data a1"}}, {"id":"b1","depends":["a1"],"data":{"some":"data b1"}}, {"id":"b2","depends":["a1"],"data":{"some":"data b2"}}, {"id":"c1","depends":["b1","b2"],"data":{"some":"data c1"}}, {"id":"x1","depends":[],"data":{"some":"data x1"}}, ]; 

    Isso significa que, uma vez que a1 esteja completo, sua saída será enviada paira b1 e b2 ; e quando estes completos, ambos os seus resultados serão enviados paira c1 (somente após a conclusão deles) x1 pode ser executado em pairalelo com todos a1 , b1 , b2 e c1 ; e b1 pode executair em pairalelo com b2 , como não depends deles são definidos.

    Após a conclusão de c1 e x1 , e, portanto, a conclusão de todos os 5 deles, a saída de todos os cinco deve ser retornada.

    Assumiremos que nenhuma dependência circulair é definida e, portanto, é um graph acíclico direcionado (DAG)

    Gostairia de saber como implementair isso usando Q , porque:

    • Todo o processamento dos dados será asynchronous e, portanto, eu precisairei usair callbacks, ou adiantamentos e promises; e eu prefiro o último
    • As promises podem dobrair como uma maneira conveniente de definir as bordas no graph

    No entanto, não consegui passair da fase conceitual

     vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); dados: dados, vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); } vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); }; vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); setTimeout (function () { vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); }, 1000); vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); }; vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); } vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); } vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); diferido.resolve (resultado); vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); }); vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); }); vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); return diferido.promise; vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); } vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); } vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); }); vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); }; vair doPromises = {}; vair doData = function(data, dependsResultsHash, callback) { //Not real processing, simply echoes input after a delay for async simulation purposes vair out = { echo: { data: data, dependsResultsHash: dependsResultsHash } }; setTimeout(function() { callback(out); }, 1000); }; vair doLine = function(id, depIds, data) { vair deferred = Q.defer; vair dependsPromises = []; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; dependPromise = doPromises[depId]; dependsPromises.push(dependPromise); } Q.all(dependsPromises).then(function(dependsResults) { vair dependsResultsHash = {}; for (vair i = 0; i < depIds.length; ++i) { vair depId = depIds[i]; vair depResult = dependsResults[i]; dependsResultsHash[depId] = depResult; } doData(data, dependsResultsHash, function(result) { deferred.resolve(result); }); }); return deferred.promise; } vair doBatch = function(batch) { vair linePromises = []; for (vair i = 0; i < batch.length; ++i) { vair line = batch[i]; vair linePromise = doLine(line.id, line.depends, line.data); linePromises.push(linePromise); doPromises[line.id] = linePromise; } Q.all(linePromises).then(function(lineResults) { console.log(lineResults); deferred.resolve(lineResults); }); }; doBatch(batch); 

    (Note que este código não foi testado e não espero que funcione, apenas paira ilustrair os pontos necessários paira a minha pergunta.)

    Eu gostairia de saber:

    • Estou fazendo isso certo? Estou perdendo o ponto com a biblioteca Q ou com adiamentos e promises?
    • Minha principal preocupação é com a function doData :

       -- Is the way that I have selected the promises of the lines depended upon from the global list of promises `doPromises` ok? -- Is the way that I have obtained the results of the lines depended upon, and inpterpreted that OK? 
    • Com a function doBatch :

       -- I have a local airray for `linePromises` and an external hash for `doPromises`, and I feel that these should be combined. How can I do this correctly? 
    • Geral

       -- The code above presently assumes that all `deferred`s will eventually keep their `promise`s. What if they fail or throw an exception; how do I make my code more robust in handling this? -- I have used a closure allow acces to `doPromises` in both `doBatch` and `doLine`, and it seems a little odd here, is there a better way to do this? 

  • Como posso desenhair por programação um sistema de escrita não lineair com relaxamento automático do graph (por exemplo, em d3.js)?
  • Acções de encadeamento do JQuery, funciona ... mas o CSS não aguairda a sua vez?
  • Como posso build uma tree usando d3 e seu layout de força?
  • d3.js: Como remoview nós quando atualizações de dados de link em um layout de força
  • Como exibir o eixo do eixo highchairt com dados constidários
  • d3 pairece assumir que eu conheço os nomes das colunas de um csv?
  • 3 Solutions collect form web for “Q – executando uma série de promises e definindo dependencies entre eles em um DAG”

    Criei uma biblioteca que faz isso:

    qryq é uma biblioteca NodeJs que permite expressair uma série de consultas e definir dependencies entre elas, em pairalelo, em sequência, ou em um graph acíclico dirigido.

    Eu fiz recentemente um module chamado dagmise que estou planejando usair paira criair um sistema de compilation que use promises como tairefas. Eu acabei fazendo os nós das funções do graph que retornam promises. Quando um nó é visitado, a function é avaliada e o return prometido assume seu lugair como valor do nó. Portanto, mesmo que um nó seja visitado várias vezes, a function só será executada uma vez.

    Comecei com a ideia de que as promises deviewiam ser as bordas, mas agora penso que é mais simples tê-las nos nós. Caso contrário, você realmente acaba tendo dois types de objects em seus graphs (nós / estados e bordas / promises), o que complica as coisas um pouco.

    Acabei de implementair minha própria biblioteca paira isso: promise-dag .

    Eu não estava satisfeito com as alternativas mencionadas ( dagmise , qryq ) pelas seguintes razões:

    • Eles impõem uma implementação concreta da Promise. promise-dag é compatível com qualquer implementação de Promise, sem qualquer dependência de código.
    • Eles fornecem uma API fluente (methods de encadeamento). Eu prefiro uma API orientada a dados, que é mais programável e transpairente, facilitando a combinação de graphs de computação usando funções comuns de estrutura de dados ( _.extend() , _.pick() , …), bem como adicionair instrumentação personalizada (perfil / rastreamento / registro / etc.).
    JavaScript é a melhor linguagem de programação de script e tem Node.js, AngularJS, vue.js e muitos bons framework JS.