Является ли Node.js нативной обработкой Promise.all параллельно или последовательно?

Я хотел бы прояснить этот момент, так как документация не слишком ясна по этому поводу;

Q1:Promise.all(iterable) выполняется ли обработка всех обещаний последовательно или параллельно? Или, более конкретно, это эквивалент выполнения цепных обещаний, таких как

p1.then(p2).then(p3).then(p4).then(p5)....

или это какой - то другой вид алгоритма , где все p1, p2, p3, p4, p5и т.д. называют одновременно (параллельно) и результаты возвращаются , как только все решимостью (или одного брака)?

Q2: Если Promise.allработает параллельно, есть ли удобный способ запустить итерацию последовательно?

Примечание : я не хочу использовать Q или Bluebird, но все нативные спецификации ES6.

Promise.all(iterable)Выполняет ли все обещания?

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

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

Есть ли удобный способ запустить итерацию последовательно?

Если у вас уже есть свои обещания, вы ничего не можете сделать, но Promise.all([p1, p2, p3, …])(который не имеет понятия последовательности). Но если у вас есть итеративные асинхронные функции, вы действительно можете запускать их последовательно. В основном вам нужно получить от

[fn1, fn2, fn3, …]

в

fn1().then(fn2).then(fn3).then(…)

и решение для этого использует Array::reduce:

iterable.reduce((p, fn) => p.then(fn), Promise.resolve())

В параллели

await Promise.all(items.map(async item => { await fetchItem(item) }))

Преимущества: быстрее. Все итерации будут выполнены, даже если одна не удалась.

В последовательности

for (let i = 0; i < items.length; i++) {
    await fetchItem(items[i])
}

Преимущества: переменные в цикле могут быть общими для каждой итерации. Ведет себя как обычный императивный синхронный код.

Ответ Bergis вывел меня на правильный путь, используя Array.reduce.

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

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

Вот чем я закончил.

getAllFiles().then( (files) => {
    return files.reduce((p, theFile) => {
        return p.then(() => {
            return transferFile(theFile); //function returns a promise
        });
    }, Promise.resolve()).then(()=>{
        console.log("All files transferred");
    });
}).catch((error)=>{
    console.log(error);
});

Как предлагают предыдущие ответы, используя:

getAllFiles().then( (files) => {
    return files.reduce((p, theFile) => {
        return p.then(transferFile(theFile));
    }, Promise.resolve()).then(()=>{
        console.log("All files transferred");
    });
}).catch((error)=>{
    console.log(error);
});

не дождался завершения передачи, прежде чем начать другую, а также текст «Все файлы передан» появился еще до начала первой передачи файла.

Не уверен, что я сделал не так, но хотел поделиться тем, что сработало для меня.

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

просто чтобы уточнить ответ @ Bergi (что очень лаконично, но сложно понять;)

Этот код будет запускать каждый элемент в массиве и добавлять следующую «цепочку» в конец;

function eachorder(prev,order) {
        return prev.then(function() {
          return get_order(order)
            .then(check_order)
            .then(update_order);
        });
    }
orderArray.reduce(eachorder,Promise.resolve());

надеюсь, что это имеет смысл.

Вы также можете последовательно обработать итерацию с помощью асинхронной функции, используя рекурсивную функцию. Например, заданный массив aдля обработки с асинхронной функцией someAsyncFunction():

var a = [1, 2, 3, 4, 5, 6]

function someAsyncFunction(n) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("someAsyncFunction: ", n)
      resolve(n)
    }, Math.random() * 1500)
  })
}

//You can run each array sequentially with: 

function sequential(arr, index = 0) {
  if (index >= arr.length) return Promise.resolve()
  return someAsyncFunction(arr[index])
    .then(r => {
      console.log("got value: ", r)
      return sequential(arr, index + 1)
    })
}

sequential(a).then(() => console.log("done"))

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

Параллельный против Concurent

Фактически, что Promise.allпроисходит, складывая функцию обещаний в соответствующей очереди (см. Архитектуру цикла событий), одновременно выполняя их (вызывая P1, P2, ...), затем ожидая каждого результата, затем разрешая Promise.all со всеми обещаниями полученные результаты. Promise.all потерпит неудачу при первом неисполнении обещания, если вы сами не справитесь с отклонением.

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

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

Использование асинхронного ожидания массива обещаний может быть легко выполнено последовательно:

let a = [promise1, promise2, promise3];

async function func() {
  for(let i=0; i<a.length; i++){
    await a[i]();
  }  
}

func();

Примечание. В приведенной выше реализации, если обещание отклонено, остальное не будет выполнено. Если вы хотите, чтобы все ваши обещания были выполнены, оберните await a[i]();внутреннюю частьtry catch

параллельно

увидеть этот пример

const resolveAfterTimeout = async i => {
  return new Promise(resolve => {
    console.log("CALLED");
    setTimeout(() => {
      resolve("RESOLVED", i);
    }, 5000);
  });
};

const call = async () => {
  const res = await Promise.all([
    resolveAfterTimeout(1),
    resolveAfterTimeout(2),
    resolveAfterTimeout(3),
    resolveAfterTimeout(4),
    resolveAfterTimeout(5),
    resolveAfterTimeout(6)
  ]);
  console.log({ res });
};

call();

запустив код, он утешит «ВЫЗОВ» для всех шести обещаний, а когда они будут решены, он будет утешать каждые 6 ответов после тайм-аута одновременно

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

function func1 (param1) {
    console.log("function1 : " + param1);
}
function func2 () {
    console.log("function2");
}
function func3 (param2, param3) {
    console.log("function3 : " + param2 + ", " + param3);
}

function func4 (param4) {
    console.log("function4 : " + param4);
}
param4 = "Kate";

//adding 3 functions to array

a=[
    ()=>func1("Hi"),
    ()=>func2(),
    ()=>func3("Lindsay",param4)
  ];

//adding 4th function

a.push(()=>func4("dad"));

//below does func1().then(func2).then(func3).then(func4)

a.reduce((p, fn) => p.then(fn), Promise.resolve());

Вы можете сделать это за цикл.

Асинхронная функция возвращает обещание

async function createClient(client) {
    return await Client.create(client);
}

let clients = [client1, client2, client3];

если вы пишете следующий код, то клиент создается параллельно

const createdClientsArray = yield Promise.all(clients.map((client) =>
    createClient(client);
));

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

const createdClientsArray = [];
for(let i = 0; i < clients.length; i++) {
    const createdClient = yield createClient(clients[i]);
    createdClientsArray.push(createdClient);
}

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

счастливого кодирования :)

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

async function run() {
    for (let val of arr) {
        const res = await someQuery(val)
        console.log(val)
    }
}

run().then().catch()

это может ответить на часть вашего вопроса.

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

function tester1(a) {
  return new Promise(function(done) {
    setTimeout(function() {
      done(a + 1);
    }, 1000);
  })
}

function tester2(a) {
  return new Promise(function(done) {
    setTimeout(function() {
      done(a * 5);
    }, 1000);
  })
}

function promise_chain(args, list, results) {

  return new Promise(function(done, errs) {
    var fn = list.shift();
    if (results === undefined) results = [];
    if (typeof fn === 'function') {
      fn(args).then(function(result) {
        results.push(result);
        console.log(result);
        promise_chain(result, list, results).then(done);
      }, errs);
    } else {
      done(results);
    }

  });

}

promise_chain(0, [tester1, tester2, tester1, tester2, tester2]).then(console.log.bind(console), console.error.bind(console));

Я наткнулся на эту страницу, пытаясь решить проблему в NodeJS: повторную сборку файловых блоков. В основном: у меня есть массив имен файлов. Мне нужно добавить все эти файлы в правильном порядке, чтобы создать один большой файл. Я должен сделать это асинхронно.

Модуль Node 'fs' предоставляет appendFileSync, но я не хотел блокировать сервер во время этой операции. Я хотел использовать модуль fs.promises и найти способ связать все это вместе. Примеры на этой странице мне не помогли, потому что на самом деле мне потребовалось две операции: fsPromises.read () для чтения в чанке файла и fsPromises.appendFile () для конкатенации в файл назначения. Возможно, если бы я был лучше с javascript, я мог бы заставить предыдущие ответы работать на меня. ;-)

Я наткнулся на это ... https://css-tricks.com/why-using-reduce-to-sequentially-resolve-promises-works/ ... и я смог взломать рабочее решение.

TLDR:

/**
 * sequentially append a list of files into a specified destination file
 */
exports.append_files = function (destinationFile, arrayOfFilenames) {
    return arrayOfFilenames.reduce((previousPromise, currentFile) => {
        return previousPromise.then(() => {
            return fsPromises.readFile(currentFile).then(fileContents => {
                return fsPromises.appendFile(destinationFile, fileContents);
            });
        });
    }, Promise.resolve());
};

И вот жасмин юнит-тест для него:

const fsPromises = require('fs').promises;
const fsUtils = require( ... );
const TEMPDIR = 'temp';

describe("test append_files", function() {
    it('append_files should work', async function(done) {
        try {
            // setup: create some files
            await fsPromises.mkdir(TEMPDIR);
            await fsPromises.writeFile(path.join(TEMPDIR, '1'), 'one');
            await fsPromises.writeFile(path.join(TEMPDIR, '2'), 'two');
            await fsPromises.writeFile(path.join(TEMPDIR, '3'), 'three');
            await fsPromises.writeFile(path.join(TEMPDIR, '4'), 'four');
            await fsPromises.writeFile(path.join(TEMPDIR, '5'), 'five');

            const filenameArray = [];
            for (var i=1; i < 6; i++) {
                filenameArray.push(path.join(TEMPDIR, i.toString()));
            }

            const DESTFILE = path.join(TEMPDIR, 'final');
            await fsUtils.append_files(DESTFILE, filenameArray);

            // confirm "final" file exists    
            const fsStat = await fsPromises.stat(DESTFILE);
            expect(fsStat.isFile()).toBeTruthy();

            // confirm content of the "final" file
            const expectedContent = new Buffer('onetwothreefourfive', 'utf8');
            var fileContents = await fsPromises.readFile(DESTFILE);
            expect(fileContents).toEqual(expectedContent);

            done();
        }
        catch (err) {
            fail(err);
        }
        finally {
        }
    });
});

Надеюсь, это кому-нибудь поможет.