Apakah itu anti-pola untuk menggunakan async / await di dalam konstruktor Promise () baru?

Saya menggunakan async.eachLimitfungsi untuk mengontrol jumlah operasi maksimum dalam satu waktu.

const { eachLimit } = require("async");

function myFunction() {
 return new Promise(async (resolve, reject) => {
   eachLimit((await getAsyncArray), 500, (item, callback) => {
     // do other things that use native promises.
   }, (error) => {
     if (error) return reject(error);
     // resolve here passing the next value.
   });
 });
}

Seperti yang Anda lihat, saya tidak bisa mendeklarasikan myFunctionfungsi sebagai async karena saya tidak memiliki akses ke nilai di dalam callback kedua dari eachLimitfungsi tersebut.

Anda secara efektif menggunakan promise di dalam fungsi pelaksana konstruktor promise, jadi ini adalah anti-pola konstruktor Promise .

Kode Anda adalah contoh bagus dari risiko utama: tidak menyebarkan semua kesalahan dengan aman. Baca alasannya di sana .

Selain itu, penggunaan async/ awaitdapat membuat perangkap yang sama menjadi lebih mengejutkan. Membandingkan:

let p = new Promise(resolve => {
  ""(); // TypeError
  resolve();
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e)); // Catches it.

dengan asyncpadanan yang naif (salah) :

let p = new Promise(async resolve => {
  ""(); // TypeError
  resolve();
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e)); // Doesn't catch it!

Lihat di konsol web browser Anda untuk yang terakhir.

Yang pertama berfungsi karena setiap pengecualian langsung dalam fungsi pelaksana konstruktor Promise dengan mudah menolak janji yang baru dibuat (tetapi di dalam apa pun .thenAnda sendiri).

Yang kedua tidak berfungsi karena ada pengecualian langsung dalam suatu asyncfungsi menolak janji implisit yang dikembalikan oleh asyncfungsi itu sendiri .

Karena nilai hasil dari fungsi pelaksana konstruktor promise tidak digunakan, itu berita buruk!

Kode Anda

Tidak ada alasan Anda tidak dapat mendefinisikan myFunctionsebagai async:

async function myFunction() {
  let array = await getAsyncArray();
  return new Promise((resolve, reject) => {
    eachLimit(array, 500, (item, callback) => {
      // do other things that use native promises.
    }, error => {
      if (error) return reject(error);
      // resolve here passing the next value.
    });
  });
}

Meskipun mengapa menggunakan pustaka kontrol konkurensi yang sudah ketinggalan zaman await?

Saya setuju dengan jawaban yang diberikan di atas dan tetap saja, terkadang lebih baik untuk memiliki asinkron di dalam janji Anda, terutama jika Anda ingin merangkai beberapa operasi yang mengembalikan janji dan menghindari then().then()neraka. Saya akan mempertimbangkan untuk menggunakan sesuatu seperti ini dalam situasi itu:

const operation1 = Promise.resolve(5)
const operation2 = Promise.resolve(15)
const publishResult = () => Promise.reject(`Can't publish`)

let p = new Promise((resolve, reject) => {
  (async () => {
    try {
      const op1 = await operation1;
      const op2 = await operation2;

      if (op2 == null) {
         throw new Error('Validation error');
      }

      const res = op1 + op2;
      const result = await publishResult(res);
      resolve(result)
    } catch (err) {
      reject(err)
    }
  })()
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e));

1. Fungsi yang diteruskan ke Promisekonstruktor tidak asinkron, jadi linter tidak menampilkan kesalahan.
2. Semua fungsi asinkron dapat dipanggil secara berurutan menggunakan await.
3. Kesalahan khusus dapat ditambahkan untuk memvalidasi hasil operasi asinkron
4. Kesalahan akhirnya tertangkap dengan baik.

Kekurangannya adalah Anda harus ingat meletakkan try/catchdan memasangnya reject.

static getPosts(){
    return new Promise( (resolve, reject) =>{
        try {
            const res =  axios.get(url);
            const data = res.data;
            resolve(
                data.map(post => ({
                    ...post,
                    createdAt: new Date(post.createdAt)
                }))
            )
        } catch (err) {
            reject(err);                
        }
    })
}

hapus await dan async akan menyelesaikan masalah ini. karena kamu sudah mengaplikasikan objek Promise, itu sudah cukup.