Используйте Array.prototype.reduce и не забудьте обернуть свои обещания функцией, иначе они уже будут запущены!

// array of Promise providers

const providers = [
  function(){
     return Promise.resolve(1);
  },
  function(){
     return Promise.resolve(2);
  },
  function(){
     return Promise.resolve(3);
  }
]


const seed = Promise.resolve(null);

const inSeries = function(providers){
  return providers.reduce(function(a,b){
      return a.then(b);
  }, seed);
};

приятно и легко ... вы должны иметь возможность повторно использовать то же самое семена для производительности и т. д.

Мой ответ основан на https://stackoverflow.com/a/31070150/7542429 .

Promise.series = function series(arrayOfPromises) {
    var results = [];
    return arrayOfPromises.reduce(function(seriesPromise, promise) {
      return seriesPromise.then(function() {
        return promise
        .then(function(result) {
          results.push(result);
        });
      });
    }, Promise.resolve())
    .then(function() {
      return results;
    });
  };

Это решение возвращает результаты в виде массива, такого как Promise.all ().

Использование:

Promise.series([array of promises])
.then(function(results) { 
  // do stuff with results here
});

Я создал этот простой метод для объекта Promise:

Создает и добавляет метод Promise.sequence к объекту Promise

Promise.sequence = function (chain) {
    var results = [];
    var entries = chain;
    if (entries.entries) entries = entries.entries();
    return new Promise(function (yes, no) {
        var next = function () {
            var entry = entries.next();
            if(entry.done) yes(results);
            else {
                results.push(entry.value[1]().then(next, function() { no(results); } ));
            }
        };
        next();
    });
};

Использование:

var todo = [];

todo.push(firstPromise);
if (someCriterium) todo.push(optionalPromise);
todo.push(lastPromise);

// Invoking them
Promise.sequence(todo)
    .then(function(results) {}, function(results) {});

Лучшее в этом расширении объекта Promise заключается в том, что оно соответствует стилю обещаний. Promise.all и Promise.sequence вызываются одинаково, но имеют разную семантику.

Внимание

Последовательное выполнение обещаний обычно не является очень хорошим способом использования обещаний. Обычно лучше использовать Promise.all, и пусть браузер запускает код как можно быстрее. Однако для этого существуют реальные варианты использования - например, при написании мобильного приложения с использованием javascript.

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

// first take your work
const urls = ['/url1', '/url2', '/url3', '/url4']

// next convert each item to a function that returns a promise
const functions = urls.map((url) => {
  // For every url we return a new function
  return () => {
    return new Promise((resolve) => {
      // random wait in milliseconds
      const randomWait = parseInt((Math.random() * 1000),10)
      console.log('waiting to resolve in ms', randomWait)
      setTimeout(()=>resolve({randomWait, url}),randomWait)
    })
  }
})


const promiseReduce = (acc, next) => {
  // we wait for the accumulator to resolve it's promise
  return acc.then((accResult) => {
    // and then we return a new promise that will become
    // the new value for the accumulator
    return next().then((nextResult) => {
      // that eventually will resolve to a new array containing
      // the value of the two promises
      return accResult.concat(nextResult)
    })
  })
};
// the accumulator will always be a promise that resolves to an array
const accumulator = Promise.resolve([])

// we call reduce with the reduce function and the accumulator initial value
functions.reduce(promiseReduce, accumulator)
  .then((result) => {
    // let's display the final value here
    console.log('=== The final result ===')
    console.log(result)
  })

Это небольшое изменение другого ответа выше. Использование собственных обещаний:

function inSequence(tasks) {
    return tasks.reduce((p, task) => p.then(task), Promise.resolve())
}

Объяснение

Если у вас есть эти задачи [t1, t2, t3], то приведенное выше эквивалентно Promise.resolve().then(t1).then(t2).then(t3). Это поведение сокращения.

Как использовать

Сначала Вам нужно составить список задач! Задача - это функция, которая не принимает аргументов. Если вам нужно передать аргументы своей функции, используйте bind или другие методы для создания задачи. Например:

var tasks = files.map(file => processFile.bind(null, file))
inSequence(tasks).then(...)

Ваш подход не плох, но у него есть две проблемы: он проглатывает ошибки, и в нем используется Explicit Construction Antipattern.

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

var Q = require("q");

var readFile = function(file) {
  ... // Returns a promise.
};

var readFiles = function(files) {
  var readSequential = function(index) {
    if (index < files.length) {
      return readFile(files[index]).then(function() {
        return readSequential(index + 1);
      });
    }
  };

  // using Promise.resolve() here in case files.length is 0
  return Promise.resolve(readSequential(0)); // Start!
};

Этот вопрос старый, но мы живем в мире ES6 и функциональном JavaScript, поэтому давайте посмотрим, как мы можем улучшить.

Поскольку обещания выполняются немедленно, мы не можем просто создать массив обещаний , все они будут запускаться параллельно.

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

Мы можем решить это несколькими способами, но мой любимый способ - использовать reduce.

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

Суть этой функции заключается в использовании reduce, начиная с начального значения из Promise.resolve([]) или обещание, содержащее пустой массив.

Это обещание будет передано в метод reduce как promise. Это ключ к последовательному объединению каждого обещания. Следующее обещание выполнить func, а когда then срабатывает, результаты конкатенируются и затем возвращается обещание, выполняя цикл reduce со следующей функцией обещания.

Как только все обещания

Пример ES6 (один лайнер)

/*
 * serial executes Promises sequentially.
 * @param {funcs} An array of funcs that return promises.
 * @example
 * const urls = ['/url1', '/url2', '/url3']
 * serial(urls.map(url => () => $.ajax(url)))
 *     .then(console.log.bind(console))
 */
const serial = funcs =>
    funcs.reduce((promise, func) =>
        promise.then(result => func().then(Array.prototype.concat.bind(result))), Promise.resolve([]))

ES6 Пример (с разбивкой)

// broken down to for easier understanding

const concat = list => Array.prototype.concat.bind(list)
const promiseConcat = f => x => f().then(concat(x))
const promiseReduce = (acc, x) => acc.then(promiseConcat(x))
/*
 * serial executes Promises sequentially.
 * @param {funcs} An array of funcs that return promises.
 * @example
 * const urls = ['/url1', '/url2', '/url3']
 * serial(urls.map(url => () => $.ajax(url)))
 *     .then(console.log.bind(console))
 */
const serial = funcs => funcs.reduce(promiseReduce, Promise.resolve([]))

Использование:

// first take your work
const urls = ['/url1', '/url2', '/url3', '/url4']

// next convert each item to a function that returns a promise
const funcs = urls.map(url => () => $.ajax(url))

// execute them serially
serial(funcs)
    .then(console.log.bind(console))

Я использую следующий код для расширения объекта Promise. Он обрабатывает отклонение обещаний и возвращает массив результатов

Код

/*
    Runs tasks in sequence and resolves a promise upon finish

    tasks: an array of functions that return a promise upon call.
    parameters: an array of arrays corresponding to the parameters to be passed on each function call.
    context: Object to use as context to call each function. (The 'this' keyword that may be used inside the function definition)
*/
Promise.sequence = function(tasks, parameters = [], context = null) {
    return new Promise((resolve, reject)=>{

        var nextTask = tasks.splice(0,1)[0].apply(context, parameters[0]); //Dequeue and call the first task
        var output = new Array(tasks.length + 1);
        var errorFlag = false;

        tasks.forEach((task, index) => {
            nextTask = nextTask.then(r => {
                output[index] = r;
                return task.apply(context, parameters[index+1]);
            }, e=>{
                output[index] = e;
                errorFlag = true;
                return task.apply(context, parameters[index+1]);
            });
        });

        // Last task
        nextTask.then(r=>{
            output[output.length - 1] = r;
            if (errorFlag) reject(output); else resolve(output);
        })
        .catch(e=>{
            output[output.length - 1] = e;
            reject(output);
        });
    });
};

Пример

function functionThatReturnsAPromise(n) {
    return new Promise((resolve, reject)=>{
        //Emulating real life delays, like a web request
        setTimeout(()=>{
            resolve(n);
        }, 1000);
    });
}

var arrayOfArguments = [['a'],['b'],['c'],['d']];
var arrayOfFunctions = (new Array(4)).fill(functionThatReturnsAPromise);


Promise.sequence(arrayOfFunctions, arrayOfArguments)
.then(console.log)
.catch(console.error);

Самое лучшее решение, которое я смог выяснить, было с обещаниями bluebird. Вы можете просто сделать Promise.resolve(files).each(fs.readFileAsync);, который гарантирует, что обещания разрешаются последовательно в порядке.

Мое предпочтительное решение:

function processArray(arr, fn) {
    return arr.reduce(
        (p, v) => p.then((a) => fn(v).then(r => a.concat([r]))),
        Promise.resolve([])
    );
}

Это не принципиально отличается от других, опубликованных здесь, но:

• Применяет функцию к элементам серии
• Разрешает массив результатов
• Не требует async / await (поддержка все еще довольно ограничена, около 2017)
• Использует функции стрелок;

Пример использования:

const numbers = [0, 4, 20, 100];
const multiplyBy3 = (x) => new Promise(res => res(x * 3));

// Prints [ 0, 12, 60, 300 ]
processArray(numbers, multiplyBy3).then(console.log);

Проверено на разумные текущие версии Chrome (v59) и NodeJS (v8.1.2).

Простая утилита для стандартного обещания Node.js:

function sequence(tasks, fn) {
    return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve());
}

UPDATE

items-prom - это готовый к использованию пакет NPM, который делает то же самое .

Исходя из названия вопроса: «Решение обещает одно за другим (то есть в последовательности)?», мы могли бы понять, что ОП больше интересуется последовательной обработкой обещаний по расчету, чем последовательными вызовами per se .

Этот ответ предлагается:

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

Если одновременные вызовы действительно не нужны, см. ответ Бенджамина Грюнбаума, который охватывает последовательные вызовы (и т. д.) всесторонне.

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

Заманчиво думать, что вам нужно использовать Promise.all(arr.map(fn)).then(fn) (как я делал много раз), или саунд-мотив Promise lib (особенно Bluebird's), однако (с учетом этой статьи ) шаблон arr.map(fn).reduce(fn) выполнит это задание с теми преимуществами, которые он имеет:

• работает с любыми обеими версиями jQuery lib - даже предсовместимыми версиями - используется только .then().
• дает гибкость для пропуска пропусков или остановки при ошибке, в зависимости от того, что вы хотите с помощью однострочного мод.

Здесь он написан для Q.

var readFiles = function(files) {
    return files.map(readFile) //Make calls in parallel.
    .reduce(function(sequence, filePromise) {
        return sequence.then(function() {
            return filePromise;
        }).then(function(file) {
            //Do stuff with file ... in the correct sequence!
        }, function(error) {
            console.log(error); //optional
            return sequence;//skip-over-error. To stop-on-error, `return error` (jQuery), or `throw  error` (Promises/A+).
        });
    }, Q()).then(function() {
        // all done.
    });
};

Примечание: только тот фрагмент, Q(), специфичен для Q. Для jQuery вам необходимо убедиться, что readFile () возвращает обещание jQuery. С помощью A + libs будут усваиваться иностранные обещания.

Ключевым моментом является обещание сокращения sequence, в котором последовательности обработки readFile обещают, но а не их создание.

И как только вы впитаете это, возможно, слегка раздумывая, когда вы понимаете, что этап .map() на самом деле не нужен! Вся работа, параллельные вызовы плюс последовательная обработка в правильном порядке, может быть достигнута только с помощью reduce() плюс дополнительное преимущество дальнейшей гибкости:

• конвертировать из параллельных асинхронных вызовов в последовательный асинхронный звонки, просто перемещая одну строку - потенциально полезную во время разработки.

Здесь он снова для Q.

var readFiles = function(files) {
    return files.reduce(function(sequence, f) {
        var filePromise = readFile(f);//Make calls in parallel. To call sequentially, move this line down one.
        return sequence.then(function() {
            return filePromise;
        }).then(function(file) {
            //Do stuff with file ... in the correct sequence!
        }, function(error) {
            console.log(error); //optional
            return sequence;//Skip over any errors. To stop-on-error, `return error` (jQuery), or `throw  error` (Promises/A+).
        });
    }, Q()).then(function() {
        // all done.
    });
};

Это базовый шаблон. Если вы захотите также предоставить данные (например, файлы или некоторые их преобразования) вызывающему, вам понадобится мягкий вариант.