Цикл с нативными промисами;

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

С .thenReturn немного лучше, но да:

function readFile(index) {
    return new Promise(function(resolve) {
        setTimeout(function() {
            console.log("Read file number " + (index +1));
            resolve();
        }, 500);
    });
}

// The loop initialization
Promise.resolve(0).then(function loop(i) {
    // The loop check
    if (i < len) {              // The post iteration increment
        return readFile(i).thenReturn(i + 1).then(loop);
    }
}).then(function() {
    console.log("done");
}).catch(function(e) {
    console.log("error", e);
});

См. это в jsfiddle http://jsfiddle.net/fd1wc1ra/.

Это почти точно эквивалентно:

try {
    for (var i = 0; i < len; ++i) {
        readFile(i);
    }
    console.log("done");
} catch (e) {
    console.log("error", e);
}

Если вы хотите сделать вложенные циклы, это точно так же:

http://jsfiddle.net/fd1wc1ra/1/

function printItem(item) {
    return new Promise(function(resolve) {
        setTimeout(function() {
            console.log("Item " + item);
            resolve();
        }, 500);
    });
}

var mdArray = [[1,2], [3,4], [5,6]];
Promise.resolve(0).then(function loop(i) {
    if (i < mdArray.length) {
        var array = mdArray[i];
        return Promise.resolve(0).then(function innerLoop(j) {
            if (j < array.length) {
                var item = array[j];
                return printItem(item).thenReturn(j + 1).then(innerLoop);
            }
        }).thenReturn(i + 1).then(loop);
    }
}).then(function() {
    console.log("done");
}).catch(function(e) {
    console.log("error", e);
});

Если все, что вы пытаетесь сделать, это сосчитать до 7 с обещаниями, то это сделает это:

function f(p, i) {
  return p.then(function() {
    return new Promise(function(r) { return setTimeout(r, 300); });
  })
  .then(function() { console.log(i); });
}

var p = Promise.resolve();
for (var i = 0; i < 8; i++) {
  p = f(p, i);
}
p.then(function() { console.log('fin'); })
 .catch(function(e) { console.log(e.message); });

Зацикливаться с промисами сложно, потому что почти невозможно не попасть в замыкания JavaScript в петлевая ловушка, но это выполнимо. Вышеупомянутое работает, потому что оно выталкивает все использование .then() в подфункцию f цикла (т.е. вне цикла).

Более безопасное решение, которое я использую, состоит в том, чтобы вообще отказаться от циклов и искать такие шаблоны, как forEach и reduce, когда я могу, потому что они эффективно навязывают вам подфункцию:

[0,1,2,3,4,5,6,7].reduce(f, Promise.resolve())
.then(function() { console.log('fin'); })
.catch(function(e) { console.log(e.message); });

здесь f — та же функция, что и выше. Попробуйте.

Обновление: В ES6 вы также можете использовать for (let i = 0; i < 8; i++), чтобы избежать ловушки "замыкания в цикле" без помещения кода в подфункцию f.

PS: ошибка в вашем примере .then(main(), - должно быть .then(function() { return new Promise(main()); },, но на самом деле, я думаю, вы неправильно используете шаблон. main() должен вернуть обещание, а не быть обернутым одним.

Попробуйте регистрировать err.stack вместо err при обнаружении ошибок промисов.

В этом случае похоже, что resolve и reject не определены в анонимной функции, которая возвращает результат от main после завершения начальной итерации. Я не могу полностью следовать вашему потоку управления, но это, кажется, имеет смысл - после завершения 7 итераций больше не должно быть никаких новых обещаний. Тем не менее, похоже, что код все еще пытается работать, как будто есть еще обещания для решения.

Изменить: это проблема .then(main(),function (err) {. Вызов main сам по себе приведет к тому, что resolve и reject внутри анонимной функции будут неопределенными. Насколько я понял, main можно вызывать только в качестве аргумента конструктора Promise.

У меня была аналогичная потребность, и я попробовал принятый ответ, но у меня возникла проблема с порядком операций. Promise.all это решение.

function work(context) {
  return new Promise((resolve, reject) => {
    operation(context)
      .then(result => resolve(result)
      .catch(err => reject(err));
  });
}

Promise
  .all(arrayOfContext.map(context => work(context)))
  .then(results => console.log(results))
  .catch(err => console.error(err));

Я также искал различные решения и не смог найти то, которое меня удовлетворило бы, поэтому в итоге я создал свое собственное. Вот, вдруг кому пригодится:

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

В моем случае вспомогательная функция просто так:

function promiseChain(chain) {
    let output = new Promise((resolve, reject) => { resolve(); });
    for (let i = 0; i < chain.length; i++) {
        let f = chain[i];
        output = output.then(f);
    }
    return output;
}

Затем, например, чтобы загрузить несколько URL-адресов один за другим, код будет таким:

// First build the array of promise generators:

let urls = [......];
let chain = [];
for (let i = 0; i < urls.length; i++) {
    chain.push(() => {
        return fetch(urls[i]);
    });
}

// Then execute the promises one after another:

promiseChain(chain).then(() => {
    console.info('All done');
});

Преимущество этого подхода в том, что он создает код, который относительно близок к обычному циклу for и с минимальными отступами.