Чи обробляється 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])
}

Переваги: ​​Змінні в циклі можуть бути спільними для кожної ітерації. Поводиться як звичайний імперативний синхронний код.

Відповідь Бергі зібрала мене на правильному шляху за допомогою 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);
});

не чекав завершення передачі перед початком іншого, а також текст "Усі передані файли" надходив ще до того, як почалася перша передача файлів.

Не впевнений, що я зробив не так, але хотів поділитися тим, що працювало на мене.

Редагувати: з моменту написання цього повідомлення я тепер розумію, чому перша версія не працювала. тоді () очікує, що функція повертає обіцянку. Отже, вам слід передати ім'я функції без дужок! Тепер моя функція хоче аргументу, тому мені потрібно загорнути анонімну функцію, не беручи аргументів!

просто уточнити відповідь @ Бергі (що дуже лаконічно, але складно зрозуміти;)

Цей код запустить кожен елемент у масиві та додасть наступний ', а потім ланцюжок' до кінця;

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"))

За допомогою асинхроніки очікуйте, що масив обіцянок легко виконується послідовно:

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();

запустивши код, він консолірує "CALLED" на всі шість обіцянок, і коли вони будуть вирішені, він консолірує кожні 6 відповідей після таймауту одночасно

NodeJS не виконує обіцянки паралельно, він виконує їх одночасно, оскільки це єдина архітектура циклу подій. Існує можливість запускати речі паралельно, створюючи новий дочірній процес, щоб скористатися багатоядерним процесором.

Паралельний V-конспект

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

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

Нарешті, щоб відповісти на ваше запитання, Promise.allвиконується не паралельно, ні послідовно, але одночасно.

Відповідь Берджі допомогла мені зробити дзвінок синхронним. Я додав приклад нижче, де ми викликаємо кожну функцію після виклику попередньої функції.

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: повторна збірка фрагментів файлів. В основному: у мене є масив імен файлів. Мені потрібно додати всі ці файли у правильному порядку, щоб створити один великий файл. Я повинен це робити асинхронно.

Модуль '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 {
        }
    });
});

Я сподіваюся, що це комусь допоможе.