Fungsi asinkron memungkinkan Anda menulis kode berbasis promise seolah-olah kode tersebut sinkron.
Fungsi asinkron diaktifkan secara default di Chrome, Edge, Firefox, dan Safari. Fungsi tersebut benar-benar luar biasa. Fungsi ini memungkinkan Anda menulis kode berbasis promise seolah-olah kode tersebut sinkron, tetapi tanpa memblokir thread utama. Fungsi ini membuat kode asinkron Anda kurang "cerdas" dan lebih mudah dibaca.
Fungsi asinkron berfungsi seperti ini:
async function myFirstAsyncFunction() {
try {
const fulfilledValue = await promise;
} catch (rejectedValue) {
// …
}
}
Jika menggunakan kata kunci async
sebelum definisi fungsi, Anda dapat menggunakan await
dalam fungsi tersebut. Saat Anda melakukan await
pada promise, fungsi tersebut akan dijeda dengan cara yang tidak memblokir hingga promise selesai. Jika promise terpenuhi, Anda akan mendapatkan nilai kembali. Jika promise ditolak, nilai yang ditolak akan dibuang.
Dukungan browser
Contoh: mencatat pengambilan
Misalnya Anda ingin mengambil URL dan mencatat responsnya sebagai teks. Berikut ini tampilannya menggunakan promise:
function logFetch(url) {
return fetch(url)
.then((response) => response.text())
.then((text) => {
console.log(text);
})
.catch((err) => {
console.error('fetch failed', err);
});
}
Dan berikut adalah hal yang sama dengan menggunakan fungsi asinkron:
async function logFetch(url) {
try {
const response = await fetch(url);
console.log(await response.text());
} catch (err) {
console.log('fetch failed', err);
}
}
Jumlah barisnya sama, tetapi semua callback hilang. Hal ini membuatnya lebih mudah untuk dibaca, terutama bagi mereka yang belum familier dengan promise.
Nilai yang ditampilkan asinkron
Fungsi asinkron selalu menampilkan promise, baik Anda menggunakan await
maupun tidak. Promise tersebut di-resolve dengan apa pun yang ditampilkan oleh fungsi asinkron, atau ditolak dengan apa pun yang ditampilkan oleh fungsi asinkron. Jadi dengan:
// wait ms milliseconds
function wait(ms) {
return new Promise((r) => setTimeout(r, ms));
}
async function hello() {
await wait(500);
return 'world';
}
...memanggil hello()
menampilkan promise yang dipenuhi dengan "world"
.
async function foo() {
await wait(500);
throw Error('bar');
}
...memanggil foo()
menampilkan promise yang ditolak dengan Error('bar')
.
Contoh: men-streaming respons
Manfaat fungsi asinkron meningkat pada contoh yang lebih kompleks. Misalnya Anda ingin melakukan streaming respons saat logout dari potongan, dan menampilkan ukuran akhir.
Berikut ini dengan promise:
function getResponseSize(url) {
return fetch(url).then((response) => {
const reader = response.body.getReader();
let total = 0;
return reader.read().then(function processResult(result) {
if (result.done) return total;
const value = result.value;
total += value.length;
console.log('Received chunk', value);
return reader.read().then(processResult);
});
});
}
Lihat saya, Jake "wielder of promises" Archibald. Lihat cara saya memanggil
processResult()
di dalam dirinya sendiri untuk menyiapkan loop asinkron? Menulis hal itu membuat
saya merasa sangat pintar. Tapi seperti kebanyakan kode "cerdas", Anda harus menatapnya
dalam rentang waktu untuk mencari tahu apa yang dilakukannya, seperti salah satu gambar mata ajaib dari
tahun 90-an.
Mari kita coba lagi dengan fungsi asinkron:
async function getResponseSize(url) {
const response = await fetch(url);
const reader = response.body.getReader();
let result = await reader.read();
let total = 0;
while (!result.done) {
const value = result.value;
total += value.length;
console.log('Received chunk', value);
// get the next result
result = await reader.read();
}
return total;
}
Semua "kecerdasan" hilang. Loop asinkron yang membuat saya merasa begitu puas
telah diganti dengan some yang tepercaya dan membosankan. Jauh lebih baik. Di masa mendatang, Anda akan mendapatkan iterator asinkron, yang akan menggantikan loop while
dengan loop for-of, sehingga menjadikannya lebih rapi.
Sintaksis fungsi asinkron lainnya
Saya telah menunjukkan kepada Anda async function() {}
, tetapi kata kunci async
dapat digunakan dengan sintaksis fungsi lain:
Fungsi panah
// map some URLs to json-promises
const jsonPromises = urls.map(async (url) => {
const response = await fetch(url);
return response.json();
});
Metode objek
const storage = {
async getAvatar(name) {
const cache = await caches.open('avatars');
return cache.match(`/avatars/${name}.jpg`);
}
};
storage.getAvatar('jaffathecake').then(…);
Metode class
class Storage {
constructor() {
this.cachePromise = caches.open('avatars');
}
async getAvatar(name) {
const cache = await this.cachePromise;
return cache.match(`/avatars/${name}.jpg`);
}
}
const storage = new Storage();
storage.getAvatar('jaffathecake').then(…);
Hati-hati! Hindari terlalu berurutan
Meskipun Anda menulis kode yang terlihat sinkron, pastikan Anda tidak melewatkan kesempatan untuk melakukan hal-hal secara paralel.
async function series() {
await wait(500); // Wait 500ms…
await wait(500); // …then wait another 500ms.
return 'done!';
}
Fungsi di atas membutuhkan waktu 1.000 md untuk diselesaikan, sedangkan:
async function parallel() {
const wait1 = wait(500); // Start a 500ms timer asynchronously…
const wait2 = wait(500); // …meaning this timer happens in parallel.
await Promise.all([wait1, wait2]); // Wait for both timers in parallel.
return 'done!';
}
Proses di atas memerlukan waktu 500 md, karena kedua proses tunggu terjadi secara bersamaan. Mari kita lihat sebuah contoh praktis.
Contoh: menghasilkan output secara berurutan
Misalnya Anda ingin mengambil serangkaian URL dan mencatatnya ke dalam log sesegera mungkin, dengan urutan yang benar.
Tarik napas dalam-dalam - inilah tampilannya dengan promise:
function markHandled(promise) {
promise.catch(() => {});
return promise;
}
function logInOrder(urls) {
// fetch all the URLs
const textPromises = urls.map((url) => {
return markHandled(fetch(url).then((response) => response.text()));
});
// log them in order
return textPromises.reduce((chain, textPromise) => {
return chain.then(() => textPromise).then((text) => console.log(text));
}, Promise.resolve());
}
Ya, benar, saya menggunakan reduce
untuk merangkai urutan promise. Saya sangat
cerdas. Namun, ini adalah coding yang sedikit rumit dan sebaiknya Anda tidak menggunakannya.
Namun, saat mengonversi fungsi di atas menjadi fungsi asinkron, Anda mungkin tergoda untuk terlalu berurutan:
async function logInOrder(urls) { for (const url of urls) { const response = await fetch(url); console.log(await response.text()); } }
function markHandled(...promises) { Promise.allSettled(promises); } async function logInOrder(urls) { // fetch all the URLs in parallel const textPromises = urls.map(async (url) => { const response = await fetch(url); return response.text(); }); markHandled(...textPromises); // log them in sequence for (const textPromise of textPromises) { console.log(await textPromise); } }
Solusi dukungan browser: generator
Jika Anda menargetkan browser yang mendukung generator (yang mencakup versi terbaru dari setiap browser utama), Anda dapat mengurutkan fungsi asinkron polyfill.
Babel akan melakukannya untuk Anda, berikut contohnya melalui Babel REPL
- mencatat seberapa mirip dengan kode yang ditranspilasi. Transformasi ini merupakan bagian dari preset es2017 Babel.
Sebaiknya gunakan pendekatan transpiling, karena Anda dapat menonaktifkannya setelah browser target mendukung fungsi asinkron. Namun, jika benar-benar tidak ingin menggunakan transpiler, Anda dapat mengambil polyfill Babel dan menggunakannya sendiri. Daripada:
async function slowEcho(val) {
await wait(1000);
return val;
}
...Anda akan menyertakan polyfill dan menulis:
const slowEcho = createAsyncFunction(function* (val) {
yield wait(1000);
return val;
});
Perhatikan bahwa Anda harus meneruskan generator (function*
) ke createAsyncFunction
,
dan menggunakan yield
, bukan await
. Selain itu, cara kerjanya sama.
Solusi: regenerator
Jika Anda menargetkan browser lama, Babel juga dapat melakukan transpile generator, sehingga Anda dapat menggunakan fungsi asinkron hingga IE8. Untuk melakukannya, Anda memerlukan preset es2017 Babel dan preset es2015.
Outputnya tidak begitu bagus, jadi waspadalah terhadap penggelembungan kode.
Lakukan asinkron pada semua hal.
Setelah fungsi asinkron berada di semua browser, gunakan fungsi tersebut di setiap fungsi yang menampilkan promise. Fungsi ini tidak hanya membuat kode Anda lebih rapi, tetapi juga memastikan bahwa fungsi tersebut akan selalu menampilkan promise.
Saya sangat bersemangat dengan fungsi asinkron pada tahun 2014, dan saya senang melihatnya hadir, secara nyata, di browser. Aduh!