Apakah Node.js asli Promise.all memproses secara paralel atau berurutan?

Saya ingin memperjelas hal ini, karena dokumentasinya tidak terlalu jelas tentang hal itu;

T1: Apakah Promise.all(iterable)memproses semua janji secara berurutan atau paralel? Atau, lebih khusus, apakah itu setara dengan menjalankan janji dirantai seperti

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

atau itu beberapa jenis lain dari algoritma di mana semua p1, p2, p3, p4, p5, dll dipanggil pada waktu yang sama (secara paralel) dan hasilnya dikembalikan segera setelah semua tekad (atau satu menolak)?

T2: Jika Promise.allberjalan secara paralel, apakah ada cara yang nyaman untuk menjalankan iterable secara berurutan?

Catatan : Saya tidak ingin menggunakan Q, atau Bluebird, tetapi semua spesifikasi ES6 asli.

Apakah Promise.all(iterable)melaksanakan semua janji?

Tidak, janji tidak bisa "dieksekusi". Mereka memulai tugas mereka ketika sedang dibuat - mereka hanya mewakili hasil - dan Anda mengeksekusi semuanya secara paralel bahkan sebelum meneruskannya Promise.all.

Promise.alltidak hanya menunggu beberapa janji. Tidak peduli urutan apa yang mereka selesaikan, atau apakah perhitungannya berjalan secara paralel.

apakah ada cara mudah untuk menjalankan iterable secara berurutan?

Jika Anda sudah memiliki janji, Anda tidak bisa berbuat banyak tetapi Promise.all([p1, p2, p3, …])(yang tidak memiliki urutan). Tetapi jika Anda memang memiliki iterable fungsi asinkron, Anda memang dapat menjalankannya secara berurutan. Pada dasarnya Anda harus mendapatkannya

[fn1, fn2, fn3, …]

untuk

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

dan solusi untuk melakukannya adalah menggunakan Array::reduce:

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

Sejajar

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

Keuntungan: Lebih cepat. Semua iterasi akan dieksekusi bahkan jika salah satu gagal.

Berurutan

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

Keuntungan: Variabel dalam loop dapat dibagi oleh setiap iterasi. Berperilaku seperti kode sinkron imperatif normal.

Jawaban Bergis membuat saya di jalur yang benar menggunakan Array.reduce.

Namun, untuk benar-benar mendapatkan fungsi mengembalikan janji saya untuk mengeksekusi satu demi satu, saya harus menambahkan beberapa lagi bersarang.

Kasing asli saya adalah array file yang harus saya transfer satu demi satu karena keterbatasan downstream ...

Inilah yang akhirnya saya dapatkan.

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

Seperti yang disarankan oleh jawaban sebelumnya, gunakan:

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

tidak menunggu untuk menyelesaikan transfer sebelum memulai yang lain dan juga teks "Semua file yang ditransfer" datang bahkan sebelum transfer file pertama dimulai.

Tidak yakin apa yang saya lakukan salah, tetapi ingin berbagi apa yang berhasil untuk saya.

Sunting: Sejak saya menulis posting ini, saya sekarang mengerti mengapa versi pertama tidak berfungsi. lalu () mengharapkan fungsi mengembalikan janji. Jadi, Anda harus memasukkan nama fungsi tanpa tanda kurung! Sekarang, fungsi saya ingin argumen jadi saya perlu membungkus dalam fungsi anonim tanpa mengambil argumen!

hanya untuk menguraikan jawaban @ Bergi (yang sangat ringkas, tetapi sulit dipahami;)

Kode ini akan menjalankan setiap item dalam array dan menambahkan 'rantai kemudian' berikutnya ke akhir;

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

harapan itu masuk akal.

Anda juga dapat memproses iterable secara berurutan dengan fungsi async menggunakan fungsi rekursif. Misalnya, diberikan array auntuk diproses dengan fungsi asinkron 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 tidak menjalankan janji secara paralel, ia menjalankannya secara bersamaan karena ini adalah arsitektur loop peristiwa tunggal berulir. Ada kemungkinan untuk menjalankan berbagai hal secara paralel dengan menciptakan proses anak baru untuk memanfaatkan CPU multi-core.

Parallel Vs Concurent

Pada kenyataannya, apa yang Promise.alldilakukan adalah, menumpuk fungsi janji dalam antrian yang sesuai (lihat arsitektur loop acara) menjalankannya secara bersamaan (panggilan P1, P2, ...) kemudian menunggu setiap hasil, kemudian menyelesaikan Janji. Semua dengan semua janji hasil. Promise.all akan gagal pada janji pertama yang gagal, kecuali jika Anda sendiri yang mengelola penolakannya.

Ada perbedaan besar antara paralel dan konkuren, yang pertama akan menjalankan perhitungan yang berbeda dalam proses yang terpisah pada waktu yang sama persis dan mereka akan berkembang di sana, sementara yang lain akan menjalankan perhitungan yang berbeda satu demi satu tanpa menunggu yang sebelumnya. perhitungan untuk menyelesaikan dan maju pada saat yang sama tanpa tergantung satu sama lain

Akhirnya, untuk menjawab pertanyaan Anda, Promise.alltidak akan mengeksekusi baik secara paralel atau berurutan tetapi bersamaan.

Menggunakan async menunggu berbagai janji dapat dengan mudah dieksekusi secara berurutan:

let a = [promise1, promise2, promise3];

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

func();

Catatan: Dalam implementasi di atas, jika janji ditolak, sisanya tidak akan dieksekusi. Jika Anda ingin semua janji Anda dieksekusi, maka bungkus await a[i]();bagian dalam Andatry catch

paralel

lihat contoh ini

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

dengan menjalankan kode itu akan menghibur "DISEBUT" untuk semua enam janji dan ketika mereka diselesaikan itu akan menghibur setiap 6 tanggapan setelah batas waktu pada waktu yang sama

Jawaban Bergi membantu saya untuk membuat panggilan sinkron. Saya telah menambahkan contoh di bawah ini di mana kita memanggil setiap fungsi setelah fungsi sebelumnya dipanggil.

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

Anda dapat melakukannya dengan for loop.

fungsi async mengembalikan janji

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

let clients = [client1, client2, client3];

jika Anda menulis kode berikut maka klien dibuat paralel

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

maka semua klien dibuat sejajar. tetapi jika Anda ingin membuat klien secara berurutan maka Anda harus menggunakan untuk loop

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

maka semua klien dibuat secara berurutan.

selamat coding :)

Saya telah menggunakan untuk untuk menyelesaikan janji-janji berurutan. Saya tidak yakin apakah ini membantu di sini, tetapi inilah yang saya lakukan.

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

run().then().catch()

ini mungkin menjawab sebagian dari pertanyaan Anda.

ya, Anda dapat rantai array janji mengembalikan fungsi sebagai berikut ... (ini meneruskan hasil dari masing-masing fungsi ke yang berikutnya). Anda tentu saja dapat mengeditnya untuk memberikan argumen yang sama (atau tanpa argumen) ke setiap fungsi.

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

Saya sengaja menemukan halaman ini ketika mencoba untuk memecahkan masalah di NodeJS: reassembly potongan file. Pada dasarnya: Saya memiliki berbagai nama file. Saya perlu menambahkan semua file itu, dalam urutan yang benar, untuk membuat satu file besar. Saya harus melakukan ini secara tidak sinkron.

Modul 'fs' Node memang menyediakan appendFileSync tapi saya tidak ingin memblokir server selama operasi ini. Saya ingin menggunakan modul fs.promises dan menemukan cara untuk menyatukan semua ini. Contoh-contoh pada halaman ini tidak cukup berhasil bagi saya karena saya benar-benar membutuhkan dua operasi: fsPromises.read () untuk membaca file chunk, dan fsPromises.appendFile () untuk menyesuaikan dengan file tujuan. Mungkin jika saya lebih baik dengan javascript saya bisa membuat jawaban sebelumnya berfungsi untuk saya. ;-)

Saya sengaja menemukan ini ... https://css-tricks.com/why-using-reduce-to- berikutnyaally- resolve-promises- works/ ... dan saya dapat meretas bersama solusi yang berfungsi.

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

Dan inilah tes unit melati untuknya:

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 {
        }
    });
});

Saya harap ini membantu seseorang.