Как связать переменное количество обещаний в Q по порядку?

Есть хороший чистый способ сделать это с помощью [].reduce < / а>.

var chain = itemsToProcess.reduce(function (previous, item) {
    return previous.then(function (previousValue) {
        // do what you want with previous value
        // return your async operation
        return Q.delay(100);
    })
}, Q.resolve(/* set the first "previousValue" here */));

chain.then(function (lastResult) {
    // ...
});

reduce выполняет итерацию по массиву, передавая в возвращенном значении предыдущей итерации. В этом случае вы возвращаете обещания, и поэтому каждый раз, когда вы связываете then. Вы даете первоначальное обещание (как и в случае с q.resolve("start")), чтобы начать работу.

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

Мне так больше нравится:

var q = require('q'),
    itemsToProcess =  ["one", "two", "three", "four", "five"];

function getDeferredResult(a) {
  return (function (items) {
    var deferred;

    // end
    if (items.length === 0) {
      return q.resolve(true);
    }

    deferred = q.defer();

    // any async function (setTimeout for now will do, $.ajax() later)
    setTimeout(function () {
      var a = items[0];
      console.log(a);
      // pop one item off the array of workitems
      deferred.resolve(items.splice(1));
    }, 600);

    return deferred.promise.then(getDeferredResult);
  }(a));
}

q.resolve(itemsToProcess)
  .then(getDeferredResult);

Ключевым моментом здесь является вызов .then() на deferred.promise с объединенной версией массива рабочих элементов. Этот then запускается после разрешения начального отложенного обещания, которое находится в fn для setTimeout. В более реалистичном сценарии отложенное обещание будет разрешено в обратном вызове http-клиента.

Начальный q.resolve(itemsToProcess) начинает работу, передавая рабочие элементы первому вызову работы fn.

Я добавил это в надежде, что это поможет другим.

Вот концепция конечного автомата, определенная с помощью Q.

Предположим, у вас определена функция HTTP, поэтому она возвращает объект обещания Q:

var Q_http = function (url, options) {
  return Q.when($.ajax(url, options));
}

Вы можете определить рекурсивную функцию nextState следующим образом:

var states = [...]; // an array of states in the system.

// this is a state machine to control what url to get data from
// at the current state 
function nextState(current) {
  if (is_terminal_state(current))
    return Q(true);

  return Q_http(current.url, current.data).then(function (result) {
    var next = process(current, result);
    return nextState(next);
  });
}

Где function process(current, result) - это функция для определения следующего шага в соответствии с состоянием current и result из HTTP-вызова.

Когда вы его используете, используйте его как:

nextState(initial).then(function () {
  // all requests are successful.
}, function (reason) {
  // for some unexpected reason the request sequence fails in the middle.
});

Я предлагаю другие решения, которые мне кажутся более понятными. Вы делаете то же самое, что и при прямом связывании обещаний: promise.then(doSomethingFunction).then(doAnotherThingFunction);

Если мы поместим это в цикл, мы получим следующее:

var chain = Q.when();
for(...) {
  chain = chain.then(functionToCall.bind(this, arg1, arg2));
};
chain.then(function() {
    console.log("whole chain resolved");
});


var functionToCall = function(arg1, arg2, resultFromPreviousPromise) {
}

Мы используем функцию каррирования для использования нескольких аргументов. В нашем примере functionToCall.bind(this, arg1, arg2) вернет функцию с одним аргументом: functionToCall(resultFromPreviousPromise) Вам не нужно использовать результат из предыдущего обещания.