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:

  1. Callback — cara lama.
  2. Promise — cara modern (ES6).
  3. async/await — sintaks paling nyaman (ES2017).
  4. 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 di then sebelumnya).
  • 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/await sebagai default. Gunakan then/catch untuk chaining sederhana atau saat butuh Promise.all/race.


Event Loop

Event loop adalah mekanisme yang memungkinkan JavaScript single-threaded menangani asynchronous operations.

Komponen

  1. Call Stack — tempat fungsi dieksekusi (LIFO).
  2. Web APIs — setTimeout, fetch, DOM events, dll. (disediakan browser/Node.js).
  3. Callback Queue (Task Queue / Macrotask Queue) — callback dari setTimeout, event, I/O.
  4. Microtask Queue — callback dari Promise (.then, .catch, queueMicrotask).
  5. Event Loop — memindahkan callback dari queue ke call stack saat stack kosong.

Alur Kerja

  1. Eksekusi kode synchronous di call stack.
  2. Operasi asynchronous dikirim ke Web APIs.
  3. Saat selesai, callback-nya masuk ke queue (microtask atau macrotask).
  4. 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:

  1. console.log("1") — synchronous, langsung.
  2. setTimeout(..., 0) — callback masuk macrotask queue.
  3. Promise.then — callback masuk microtask queue.
  4. console.log("4") — synchronous, langsung.
  5. Call stack kosong → event loop ambil microtask dulu → “3”.
  6. 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

  1. Gunakan async/await sebagai default — lebih mudah dibaca daripada chaining.

  2. Jalankan paralel dengan Promise.all() jika operasi tidak saling bergantung.

  3. Selalu tangani error — try/catch untuk async/await, .catch() untuk Promise.

  4. Gunakan AbortController untuk membatalkan request (timeout, navigasi).

  5. Hindari await di dalam loop jika operasi bisa paralel — gunakan Promise.all() + map().

  6. Pahami event loop — jangan membuat microtask tak terbatas (bisa membekukan UI).

  7. Jangan campur callback dan Promise dalam satu alur — pilih satu gaya.

  8. Gunakan Promise.allSettled() jika ingin semua hasil, termasuk yang gagal.

  9. Hati-hati dengan Promise.race() — Promise yang kalah tetap berjalan di latar belakang.

  10. 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/await membuat kode lebih mudah dibaca — gunakan sebagai default.
  • Selalu tangani error — try/catch atau .catch().
  • Microtask (Promise) diproses sebelum macrotask (setTimeout).
  • Gunakan AbortController untuk membatalkan request.
  • Jangan await di loop jika bisa paralel.

Pada artikel berikutnya, kita akan membahas Fetch API & AJAX — mengambil data dari server.

Top