Asynchronous JavaScript
JavaScript bersifat single-threaded, tetapi asynchronous programming memungkinkan operasi lambat (I/O, network) berjalan tanpa memblokir. Artikel ini membahas callback, Promise, async/await, event loop, dan best practice error handling.
Pendahuluan
JavaScript adalah bahasa single-threaded — hanya satu operasi yang benar-benar berjalan pada satu waktu. Namun, JavaScript bisa menangani operasi asynchronous (I/O, network request, timer) tanpa memblokir thread utama.
Tanpa asynchronous programming, satu request HTTP yang lambat akan “membekukan” seluruh halaman sampai selesai. Dengan asynchronous, halaman tetap responsif sementara data diambil di latar belakang.
Artikel ini membahas evolusi asynchronous JavaScript:
- Callback — cara lama.
- Promise — cara modern (ES6).
async/await— sintaks paling nyaman (ES2017).- Event loop — bagaimana semuanya bekerja di balik layar.
Asumsi: Anda sudah memahami fungsi, arrow function, object, dan fitur ES6+ dari artikel sebelumnya.
Synchronous vs Asynchronous
Synchronous (Blocking)
Kode dieksekusi berurutan — baris berikutnya menunggu baris sebelumnya selesai.
console.log("1");
console.log("2");
console.log("3");
// Output: 1, 2, 3
Jika salah satu operasi lambat (misalnya membaca file besar), seluruh program menunggu.
Asynchronous (Non-Blocking)
Operasi lambat dijalankan di latar belakang, dan kode berikutnya tetap berjalan. Hasil operasi ditangani nanti melalui callback/Promise.
console.log("1");
setTimeout(() => {
console.log("2 (setelah 1 detik)");
}, 1000);
console.log("3");
// Output: 1, 3, 2 (setelah 1 detik)
setTimeout tidak memblokir — “3” langsung dicetak, dan “2” muncul setelah 1 detik.
Callback
Callback adalah fungsi yang diberikan sebagai argumen dan dipanggil setelah operasi asynchronous selesai.
function ambilData(callback) {
setTimeout(() => {
const data = { id: 1, nama: "Budi" };
callback(data);
}, 1000);
}
ambilData((data) => {
console.log("Data diterima:", data);
});
// Output (setelah 1 detik): Data diterima: { id: 1, nama: "Budi" }
Callback Hell
Jika beberapa operasi asynchronous bergantung satu sama lain, callback bisa bersarang dalam-dalam — dikenal sebagai callback hell atau pyramid of doom.
// ❌ Callback hell
ambilUser(1, (user) => {
ambilPesanan(user.id, (pesanan) => {
ambilDetail(pesanan[0].id, (detail) => {
ambilProduk(detail.produkId, (produk) => {
console.log("Produk:", produk.nama);
// ... makin dalam
});
});
});
});
Masalah callback hell:
- Sulit dibaca dan dipelihara.
- Error handling berulang di setiap level.
- Sulit untuk menjalankan operasi paralel.
Solusi: Promise dan async/await.
Error Handling pada Callback
Konvensi umum: error-first callback — argumen pertama adalah error (atau null).
function ambilData(callback) {
setTimeout(() => {
const error = null;
const data = { id: 1 };
if (error) {
callback(error, null);
} else {
callback(null, data);
}
}, 1000);
}
ambilData((err, data) => {
if (err) {
console.error("Error:", err);
return;
}
console.log("Data:", data);
});
Promise
Promise adalah object yang merepresentasikan hasil operasi asynchronous yang akan datang. Promise diperkenalkan di ES6 untuk mengatasi masalah callback hell.
Tiga State Promise
- Pending — operasi sedang berjalan.
- Fulfilled — operasi berhasil (resolve).
- Rejected — operasi gagal (reject).
Promise yang sudah fulfilled atau rejected bersifat settled (tidak berubah lagi).
Membuat Promise
const promise = new Promise((resolve, reject) => {
// Operasi asynchronous
setTimeout(() => {
const berhasil = true;
if (berhasil) {
resolve({ id: 1, nama: "Budi" }); // fulfilled
} else {
reject(new Error("Gagal mengambil data")); // rejected
}
}, 1000);
});
Menggunakan Promise: then, catch, finally
promise
.then((data) => {
console.log("Berhasil:", data);
return data.id; // bisa di-chain
})
.then((id) => {
console.log("ID:", id);
})
.catch((error) => {
console.error("Error:", error.message);
})
.finally(() => {
console.log("Selesai (selalu dijalankan)");
});
then()— dijalankan saat fulfilled. Mengembalikan Promise baru untuk chaining.catch()— dijalankan saat rejected (atau error dithensebelumnya).finally()— selalu dijalankan, baik fulfilled maupun rejected.
Chaining Promise
then() mengembalikan Promise baru, memungkinkan chaining yang rapi:
function ambilUser(id) {
return fetch(`/api/users/${id}`).then(r => r.json());
}
function ambilPesanan(userId) {
return fetch(`/api/orders?user=${userId}`).then(r => r.json());
}
// ✅ Rapi, tanpa callback hell
ambilUser(1)
.then(user => ambilPesanan(user.id))
.then(pesanan => console.log("Pesanan:", pesanan))
.catch(err => console.error("Error:", err));
Promise Utility: all, allSettled, race, any
Promise.all() — menunggu semua Promise selesai. Gagal jika salah satu reject.
const [user, produk, pesanan] = await Promise.all([
fetch("/api/user").then(r => r.json()),
fetch("/api/produk").then(r => r.json()),
fetch("/api/pesanan").then(r => r.json())
]);
Catatan:
Promise.all()menjalankan Promise paralel — jauh lebih cepat daripada menunggu satu per satu.
Promise.allSettled() — menunggu semua selesai, tidak peduli ada yang reject. Mengembalikan array { status, value/reason }.
const results = await Promise.allSettled([
fetch("/api/a"),
fetch("/api/b"),
fetch("/api/c")
]);
results.forEach(r => {
if (r.status === "fulfilled") {
console.log("OK:", r.value);
} else {
console.log("Gagal:", r.reason);
}
});
Promise.race() — mengembalikan Promise pertama yang settled (fulfilled atau rejected).
// Timeout pattern
const timeout = new Promise((_, reject) =>
setTimeout(() => reject(new Error("Timeout")), 5000)
);
const data = await Promise.race([
fetch("/api/lambat"),
timeout
]);
Promise.any() — mengembalikan Promise pertama yang fulfilled. Gagal hanya jika semua reject.
const fastest = await Promise.any([
fetch("https://server1.com/api"),
fetch("https://server2.com/api"),
fetch("https://server3.com/api")
]);
Perbandingan Promise Utility
| Method | Selesai Saat | Gagal Saat |
|---|---|---|
Promise.all |
Semua fulfilled | Salah satu reject |
Promise.allSettled |
Semua settled | Tidak pernah reject |
Promise.race |
Pertama settled | Pertama reject (jika yang pertama reject) |
Promise.any |
Pertama fulfilled | Semua reject |
async/await
async/await (ES2017) adalah sintaks yang membuat asynchronous code terlihat seperti synchronous, sehingga lebih mudah dibaca.
async — Fungsi yang Mengembalikan Promise
Menambahkan async sebelum fungsi membuat fungsi selalu mengembalikan Promise.
async function sapa() {
return "Halo";
}
sapa().then(console.log); // "Halo"
// Setara dengan:
function sapa2() {
return Promise.resolve("Halo");
}
await — Menunggu Promise
await menjeda eksekusi fungsi async sampai Promise selesai, lalu mengembalikan nilainya.
async function ambilUser(id) {
const response = await fetch(`/api/users/${id}`);
const user = await response.json();
return user;
}
// Penggunaan
ambilUser(1).then(user => console.log(user));
Kode setelah await tidak berjalan sampai Promise selesai — tetapi tidak memblokir thread utama. Fungsi lain tetap bisa berjalan.
Error Handling dengan try...catch
async function ambilData() {
try {
const response = await fetch("/api/data");
if (!response.ok) {
throw new Error(`HTTP ${response.status}`);
}
const data = await response.json();
return data;
} catch (error) {
console.error("Gagal:", error.message);
return null;
} finally {
console.log("Selesai");
}
}
Menjalankan Paralel dengan await
❌ Sequential (lambat):
async function ambilSemua() {
const user = await fetch("/api/user").then(r => r.json());
const produk = await fetch("/api/produk").then(r => r.json());
const pesanan = await fetch("/api/pesanan").then(r => r.json());
return { user, produk, pesanan };
}
// Total waktu = waktu user + waktu produk + waktu pesanan
✅ Parallel (cepat):
async function ambilSemua() {
const [user, produk, pesanan] = await Promise.all([
fetch("/api/user").then(r => r.json()),
fetch("/api/produk").then(r => r.json()),
fetch("/api/pesanan").then(r => r.json())
]);
return { user, produk, pesanan };
}
// Total waktu = waktu terlama dari ketiganya
Tips: Jika operasi tidak saling bergantung, jalankan paralel dengan
Promise.all(). Jika bergantung (hasil satu menjadi input berikutnya), jalankan sequential.
await di Loop
❌ Sequential (lambat):
for (const id of [1, 2, 3, 4, 5]) {
const user = await ambilUser(id); // menunggu satu per satu
console.log(user);
}
✅ Parallel:
const users = await Promise.all([1, 2, 3, 4, 5].map(id => ambilUser(id)));
console.log(users);
async/await vs Promise Chaining
// Promise chaining
function ambilData() {
return fetch("/api/user")
.then(r => r.json())
.then(user => fetch(`/api/orders?user=${user.id}`))
.then(r => r.json())
.catch(err => console.error(err));
}
// async/await — lebih mudah dibaca
async function ambilData() {
try {
const user = await fetch("/api/user").then(r => r.json());
const orders = await fetch(`/api/orders?user=${user.id}`).then(r => r.json());
return orders;
} catch (err) {
console.error(err);
}
}
Rekomendasi: Gunakan
async/awaitsebagai default. Gunakanthen/catchuntuk chaining sederhana atau saat butuhPromise.all/race.
Event Loop
Event loop adalah mekanisme yang memungkinkan JavaScript single-threaded menangani asynchronous operations.
Komponen
- Call Stack — tempat fungsi dieksekusi (LIFO).
- Web APIs —
setTimeout,fetch, DOM events, dll. (disediakan browser/Node.js). - Callback Queue (Task Queue / Macrotask Queue) — callback dari
setTimeout, event, I/O. - Microtask Queue — callback dari Promise (
.then,.catch,queueMicrotask). - Event Loop — memindahkan callback dari queue ke call stack saat stack kosong.
Alur Kerja
- Eksekusi kode synchronous di call stack.
- Operasi asynchronous dikirim ke Web APIs.
- Saat selesai, callback-nya masuk ke queue (microtask atau macrotask).
- Event loop memeriksa: jika call stack kosong, ambil callback dari microtask queue dulu (semua), baru macrotask queue (satu per satu).
Contoh Klasik
console.log("1");
setTimeout(() => console.log("2"), 0);
Promise.resolve().then(() => console.log("3"));
console.log("4");
// Output: 1, 4, 3, 2
Penjelasan:
console.log("1")— synchronous, langsung.setTimeout(..., 0)— callback masuk macrotask queue.Promise.then— callback masuk microtask queue.console.log("4")— synchronous, langsung.- Call stack kosong → event loop ambil microtask dulu → “3”.
- Baru ambil macrotask → “2”.
Microtask vs Macrotask
| Microtask | Macrotask |
|---|---|
Promise.then/catch/finally |
setTimeout, setInterval |
queueMicrotask() |
setImmediate (Node.js) |
MutationObserver |
I/O, UI rendering, event |
Aturan: Semua microtask diproses sebelum macrotask berikutnya. Microtask yang dibuat di dalam microtask juga diproses di siklus yang sama.
console.log("start");
setTimeout(() => console.log("timeout"), 0);
Promise.resolve()
.then(() => {
console.log("promise 1");
Promise.resolve().then(() => console.log("promise 2"));
});
console.log("end");
// Output: start, end, promise 1, promise 2, timeout
Mengapa Penting?
- Microtask yang tak terbatas bisa “membekukan” halaman — macrotask (termasuk rendering) tidak pernah dijalankan.
setTimeout(fn, 0)tidak berarti “langsung” — ia menunggu macrotask queue.- Promise callback selalu dijalankan sebelum
setTimeout, meskipun delay-nya 0.
queueMicrotask()
Menjadwalkan microtask secara eksplisit:
queueMicrotask(() => {
console.log("Microtask");
});
console.log("Sync");
// Output: Sync, Microtask
Contoh Praktis
1. Fetch Data dengan Error Handling
async function ambilProduk() {
try {
const response = await fetch("https://api.example.com/produk");
if (!response.ok) {
throw new Error(`HTTP error: ${response.status}`);
}
const data = await response.json();
return data;
} catch (error) {
if (error.name === "AbortError") {
console.log("Request dibatalkan");
} else if (error instanceof TypeError) {
console.error("Network error:", error.message);
} else {
console.error("Error:", error.message);
}
return [];
}
}
2. Retry dengan Exponential Backoff
async function fetchWithRetry(url, maxRetries = 3) {
for (let i = 0; i < maxRetries; i++) {
try {
const response = await fetch(url);
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
} catch (error) {
if (i === maxRetries - 1) throw error;
const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
console.log(`Retry ${i + 1} dalam ${delay}ms...`);
await new Promise(resolve => setTimeout(resolve, delay));
}
}
}
fetchWithRetry("/api/data")
.then(data => console.log(data))
.catch(err => console.error("Gagal setelah retry:", err));
3. Timeout pada Fetch
async function fetchWithTimeout(url, timeoutMs = 5000) {
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
try {
const response = await fetch(url, { signal: controller.signal });
return await response.json();
} finally {
clearTimeout(timeoutId);
}
}
try {
const data = await fetchWithTimeout("/api/lambat", 3000);
} catch (err) {
if (err.name === "AbortError") {
console.log("Request timeout setelah 3 detik");
}
}
4. Menjalankan Task dengan Batas Konkurensi
async function jalankanDenganBatas(tasks, limit = 3) {
const results = [];
const executing = [];
for (const task of tasks) {
const p = Promise.resolve().then(() => task());
results.push(p);
if (limit <= tasks.length) {
const e = p.then(() => executing.splice(executing.indexOf(e), 1));
executing.push(e);
if (executing.length >= limit) {
await Promise.race(executing);
}
}
}
return Promise.all(results);
}
// Contoh: 10 request, maksimal 3 bersamaan
const tasks = Array.from({ length: 10 }, (_, i) => () =>
fetch(`/api/item/${i}`).then(r => r.json())
);
const results = await jalankanDenganBatas(tasks, 3);
5. Loading State dengan async/await
async function muatData() {
const loading = document.querySelector("#loading");
const container = document.querySelector("#container");
loading.style.display = "block";
container.innerHTML = "";
try {
const data = await fetch("/api/produk").then(r => r.json());
data.forEach(item => {
const div = document.createElement("div");
div.textContent = item.nama;
container.appendChild(div);
});
} catch (error) {
container.textContent = "Gagal memuat data";
} finally {
loading.style.display = "none";
}
}
Tips & Best Practice
-
Gunakan
async/awaitsebagai default — lebih mudah dibaca daripada chaining. -
Jalankan paralel dengan
Promise.all()jika operasi tidak saling bergantung. -
Selalu tangani error —
try/catchuntukasync/await,.catch()untuk Promise. -
Gunakan
AbortControlleruntuk membatalkan request (timeout, navigasi). -
Hindari
awaitdi dalam loop jika operasi bisa paralel — gunakanPromise.all()+map(). -
Pahami event loop — jangan membuat microtask tak terbatas (bisa membekukan UI).
-
Jangan campur callback dan Promise dalam satu alur — pilih satu gaya.
-
Gunakan
Promise.allSettled()jika ingin semua hasil, termasuk yang gagal. -
Hati-hati dengan
Promise.race()— Promise yang kalah tetap berjalan di latar belakang. -
Gunakan
finally()untuk cleanup (hide loading, clear timeout, dll.).
Ringkasan
| Konsep | Poin Penting |
|---|---|
| Callback | Fungsi yang dipanggil setelah operasi async selesai — rentan callback hell |
| Promise | Object representasi hasil async — state: pending, fulfilled, rejected |
then/catch/finally |
Method Promise untuk handling hasil/error |
Promise.all |
Tunggu semua fulfilled (gagal jika satu reject) |
Promise.allSettled |
Tunggu semua settled (tidak pernah reject) |
Promise.race |
Ambil yang pertama settled |
Promise.any |
Ambil yang pertama fulfilled |
async/await |
Sintaks async yang terlihat synchronous |
| Event loop | Mekanisme single-threaded menangani async |
| Microtask | Promise callback — diproses sebelum macrotask |
| Macrotask | setTimeout, event, I/O |
Poin penting:
- JavaScript single-threaded — async mencegah blocking.
- Callback hell diatasi oleh Promise dan
async/await. - Gunakan
Promise.all()untuk operasi paralel. async/awaitmembuat kode lebih mudah dibaca — gunakan sebagai default.- Selalu tangani error —
try/catchatau.catch(). - Microtask (Promise) diproses sebelum macrotask (
setTimeout). - Gunakan
AbortControlleruntuk membatalkan request. - Jangan
awaitdi loop jika bisa paralel.
Pada artikel berikutnya, kita akan membahas Fetch API & AJAX — mengambil data dari server.