Node JS Promise.all dan forEach

Saya memiliki struktur seperti array yang memperlihatkan metode async. Metode asinkron memanggil struktur larik yang dikembalikan yang pada gilirannya mengekspos lebih banyak metode asinkron. Saya membuat objek JSON lain untuk menyimpan nilai yang diperoleh dari struktur ini, jadi saya harus berhati-hati dalam melacak referensi di callback.

Saya telah membuat kode solusi brute force, tetapi saya ingin mempelajari solusi yang lebih idiomatis atau bersih.

1. Pola tersebut harus dapat diulang untuk n tingkat penumpukan.
2. Saya perlu menggunakan promise.all atau beberapa teknik serupa untuk menentukan kapan harus menyelesaikan rutinitas penutup.
3. Tidak setiap elemen harus melibatkan pembuatan panggilan asinkron. Jadi dalam janji bersarang saya tidak bisa begitu saja membuat tugas ke elemen array JSON saya berdasarkan indeks. Namun demikian, saya perlu menggunakan sesuatu seperti promise.all di forEach bersarang untuk memastikan bahwa semua penugasan properti telah dilakukan sebelum menyelesaikan rutinitas pelampiran.
4. Saya menggunakan lib promise bluebird tetapi ini bukan persyaratan

Berikut adalah beberapa kode parsial -

var jsonItems = [];

items.forEach(function(item){

  var jsonItem = {};
  jsonItem.name = item.name;
  item.getThings().then(function(things){
  // or Promise.all(allItemGetThingCalls, function(things){

    things.forEach(function(thing, index){

      jsonItems[index].thingName = thing.name;
      if(thing.type === 'file'){

        thing.getFile().then(function(file){ //or promise.all?

          jsonItems[index].filesize = file.getSize();

Ini cukup mudah dengan beberapa aturan sederhana:

• Kapan pun Anda membuat janji di sebuah then, kembalikan - janji apa pun yang tidak Anda kembalikan tidak akan ditunggu di luar.
• Setiap kali Anda membuat beberapa janji, .allitu - dengan cara itu menunggu semua janji dan tidak ada kesalahan dari salah satunya yang dibungkam.
• Kapanpun Anda bersarang then, Anda biasanya dapat kembali ke tengah - thenrantai biasanya sedalam paling banyak 1 tingkat.
• Kapan pun Anda melakukan IO, itu harus dengan janji - baik itu harus dalam janji atau harus menggunakan janji untuk menandakan penyelesaiannya.

Dan beberapa tip:

• Pemetaan lebih baik dilakukan dengan .map daripada denganfor/push - jika Anda memetakan nilai dengan suatu fungsi, mapmemungkinkan Anda secara ringkas mengekspresikan gagasan tentang menerapkan tindakan satu per satu dan menggabungkan hasilnya.
• Concurrency lebih baik daripada eksekusi berurutan jika gratis - lebih baik mengeksekusi sesuatu secara bersamaan dan menunggu Promise.alldaripada mengeksekusi sesuatu satu demi satu - masing-masing menunggu sebelum yang berikutnya.

Oke, jadi mari kita mulai:

var items = [1, 2, 3, 4, 5];
var fn = function asyncMultiplyBy2(v){ // sample async action
    return new Promise(resolve => setTimeout(() => resolve(v * 2), 100));
};
// map over forEach since it returns

var actions = items.map(fn); // run the function over all items

// we now have a promises array and we want to wait for it

var results = Promise.all(actions); // pass array of promises

results.then(data => // or just .then(console.log)
    console.log(data) // [2, 4, 6, 8, 10]
);

// we can nest this of course, as I said, `then` chains:

var res2 = Promise.all([1, 2, 3, 4, 5].map(fn)).then(
    data => Promise.all(data.map(fn))
).then(function(data){
    // the next `then` is executed after the promise has returned from the previous
    // `then` fulfilled, in this case it's an aggregate promise because of 
    // the `.all` 
    return Promise.all(data.map(fn));
}).then(function(data){
    // just for good measure
    return Promise.all(data.map(fn));
});

// now to get the results:

res2.then(function(data){
    console.log(data); // [16, 32, 48, 64, 80]
});

Berikut adalah contoh sederhana menggunakan reduce. Ini berjalan secara serial, memelihara urutan penyisipan, dan tidak memerlukan Bluebird.

/**
 * 
 * @param items An array of items.
 * @param fn A function that accepts an item from the array and returns a promise.
 * @returns {Promise}
 */
function forEachPromise(items, fn) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item);
        });
    }, Promise.resolve());
}

Dan gunakan seperti ini:

var items = ['a', 'b', 'c'];

function logItem(item) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            resolve();
        })
    });
}

forEachPromise(items, logItem).then(() => {
    console.log('done');
});

Kami merasa berguna untuk mengirim konteks opsional ke dalam loop. Konteksnya opsional dan dibagikan oleh semua iterasi.

function forEachPromise(items, fn, context) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item, context);
        });
    }, Promise.resolve());
}

Fungsi promise Anda akan terlihat seperti ini:

function logItem(item, context) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            context.itemCount++;
            resolve();
        })
    });
}

Saya telah melalui situasi yang sama. Saya menyelesaikannya menggunakan dua Promise.All ().

Saya pikir itu solusi yang sangat bagus, jadi saya menerbitkannya di npm: https://www.npmjs.com/package/promise-foreach

Saya pikir kode Anda akan menjadi seperti ini

var promiseForeach = require('promise-foreach')
var jsonItems = [];
promiseForeach.each(jsonItems,
    [function (jsonItems){
        return new Promise(function(resolve, reject){
            if(jsonItems.type === 'file'){
                jsonItems.getFile().then(function(file){ //or promise.all?
                    resolve(file.getSize())
                })
            }
        })
    }],
    function (result, current) {
        return {
            type: current.type,
            size: jsonItems.result[0]
        }
    },
    function (err, newList) {
        if (err) {
            console.error(err)
            return;
        }
        console.log('new jsonItems : ', newList)
    })

Hanya untuk menambah solusi yang disajikan, dalam kasus saya, saya ingin mengambil banyak data dari Firebase untuk daftar produk. Inilah cara saya melakukannya:

useEffect(() => {
  const fn = p => firebase.firestore().doc(`products/${p.id}`).get();
  const actions = data.occasion.products.map(fn);
  const results = Promise.all(actions);
  results.then(data => {
    const newProducts = [];
    data.forEach(p => {
      newProducts.push({ id: p.id, ...p.data() });
    });
    setProducts(newProducts);
  });
}, [data]);