Как разрешить обещание извне с помощью eventEmitter в nodeJS?

Promise.all очень полезен, если вы хотите делать несколько вещей одновременно. Если вы хотите делать что-то линейным образом, вы можете связать обещания.

Итак, я мог бы сделать фрагмент, я только что сделал притворную асинхронную функцию, которая имеет значение sqr, а затем я добавляю их все в конце.

Вы также можете сделать более продвинутую версию, например. Bluebird Promises имеет функцию карты, которая имеет параметр параллелизма.

var somethings = [12,1,33,23,44,22,11,32,12,44,22,32];

function asyncSqr(v) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () { resolve(v*v); }, 200);
  });
}


function myFunc(a) {
  var sum = 0;
  return new Promise(function (resolve, reject) {
    function doNext() {
      var next = a.shift();    
      if (!next) return resolve(sum);
      console.log('sending: ' + next);
      return asyncSqr(next).then(function (r) { sum += r; doNext(); });
    }  
    doNext();    
  });
}

myFunc(somethings).then(function (r) {
  console.log('result: ' + r);
});

Кажется, нет никакой веской причины использовать eventEmitter и вызывать его в следующей строке, просто вместо этого используйте Promise.all, а поскольку auxFunc.asyncFunc, похоже, возвращает значение, вы, вероятно, могли бы просто вернуть его на карте

function myFunc(objectToTest, testArray) {
    var promises = testArray.filter(function(item) {
        return objectToTest.name == item.name;
    }).map(function(itemInArray) {
        return auxFunc.asyncFunc(itemInArray);
    });

    Promise.all(promises).then(function(results) {
        console.log("Finished With All Async work!");
        // results would be all the results
    });
}

Если вам нужно ждать каждого вызова, рекурсивная функция, которая просто сдвигает элементы массива, кажется проще.

function myFunc(objectToTest, testArray) {
    return new Promise(function (resolve, reject) {
        var array = testArray.filter(function(item) {
            return objectToTest.name == item.name;
        });

        (function processArray(itemInArray) {
            auxFunc.asyncFunc(itemInArray).then(function (asyncResult) {
                if (array.length > 0) {
                    processArray(array.shift());
                } else {
                    resolve('all done');
                }
            });
        })(array.shift());
    });
}

EventEmmitters здесь совершенно не нужны. Стандартная цепочка обещаний будет выполнять работу по упорядочиванию асинхронных задач. На самом деле это основная смысл существования цепочки промисов (другим аспектом является обработка ошибок).

Для этой работы шаблон работает следующим образом:

function myFunc(objectToTest, testArray) {
    // first, pre-filter testArray.
    var array = testArray.filter(function() {
        return objectToTest.name == item.name;
    });

    // now use .reduce() to build a promise chain from the filtered array.
    return array.reduce(function(chain, item) {
        return chain.then(function(previousResult) {
            return auxFunc.asyncFunc(item).then(function(result) {
                // Triggered when asyncFunc promise is resolved
                // ... do something with the result ...
                return result; // make this step's result available to next step in the chain (if required).
            });
        });
    }, Promise.resolve(intialValue));
}

Сделав еще один шаг вперед, действие фильтрации может выполняться на лету при сокращении - нет необходимости в предварительной фильтрации.

function myFunc(objectToTest, testArray) {
    return testArray.reduce(function(chain, item) {
        if(objectToTest.name !== item.name) {
            // Filter on-the-fly
            // Don't extend the chain at this iteration of .reduce()
            return chain;
        } else {
            // item.name meets the criterion, so add an async task to the chain.
            return chain.then(function(previousResult) {
                return auxFunc.asyncFunc(item).then(function(result) {
                    // Triggered when asyncFunc promise is resolved
                    // ...
                    return result; // make result available to next step in the chain.
                });
            });
        }
    }, Promise.resolve(intialValue));
}