Fetch API & AJAX

Fetch API adalah cara modern mengambil data dari server tanpa reload halaman. Artikel ini membahas request GET/POST/PUT/DELETE, mengirim JSON, error handling, AbortController, CORS, dan alternatif Axios.

Pendahuluan

AJAX (Asynchronous JavaScript and XML) adalah teknik mengambil data dari server tanpa reload halaman. Meskipun namanya mengandung “XML”, saat ini format yang dominan adalah JSON.

Fetch API adalah cara modern (built-in browser) untuk melakukan HTTP request. Fetch menggantikan XMLHttpRequest (XHR) yang lebih tua dan verbose.

Dengan Fetch, kita bisa:

  • Mengambil data dari REST API.
  • Mengirim form/data ke server.
  • Upload file.
  • Berkomunikasi dengan backend (Node.js, PHP, Python, dll.).

Artikel ini membahas Fetch API secara lengkap: request dasar, method HTTP, header, error handling, AbortController, CORS, dan alternatif seperti Axios.

Asumsi: Anda sudah memahami Promise dan async/await dari artikel sebelumnya.


Fetch Dasar

Sintaks

fetch(url, options)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));

Atau dengan async/await:

async function ambilData() {
  const response = await fetch(url);
  const data = await response.json();
  return data;
}

Contoh GET Sederhana

async function ambilProduk() {
  const response = await fetch("https://api.example.com/produk");
  const data = await response.json();
  console.log(data);
}

ambilProduk();

Response Object

fetch() mengembalikan Promise yang resolve ke Response object. Response berisi:

Properti/Method Arti
response.ok true jika status 200–299
response.status Status code (200, 404, 500, dll.)
response.statusText Teks status (“OK”, “Not Found”)
response.headers Header response (Headers object)
response.url URL final (setelah redirect)
response.redirected Apakah terjadi redirect
response.json() Parse body sebagai JSON (Promise)
response.text() Parse body sebagai teks (Promise)
response.blob() Parse body sebagai Blob (file)
response.arrayBuffer() Parse body sebagai ArrayBuffer
response.formData() Parse body sebagai FormData
response.clone() Clone response (untuk dibaca dua kali)

Penting: Body response hanya bisa dibaca sekali. Jika perlu membaca dua kali, gunakan response.clone().

const response = await fetch("/api/data");
const clone = response.clone();

const json = await response.json();
const text = await clone.text();

Method HTTP

GET — Mengambil Data

// Default method adalah GET
const response = await fetch("/api/produk");
const produk = await response.json();

Dengan query string:

const params = new URLSearchParams({
  kategori: "elektronik",
  page: 2,
  limit: 10
});

const response = await fetch(`/api/produk?${params}`);

Atau manual:

const response = await fetch("/api/produk?kategori=elektronik&page=2");

Tips: Gunakan URLSearchParams untuk encoding otomatis (spasi, karakter khusus).

POST — Mengirim Data Baru

const response = await fetch("/api/produk", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    nama: "Keyboard Mechanical",
    harga: 450000,
    stok: 25
  })
});

const hasil = await response.json();
console.log(hasil);

PUT — Mengganti Data (Full Update)

const response = await fetch("/api/produk/1", {
  method: "PUT",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    nama: "Keyboard Mechanical RGB",
    harga: 550000,
    stok: 20
  })
});

PATCH — Mengubah Sebagian Data

const response = await fetch("/api/produk/1", {
  method: "PATCH",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    harga: 500000
  })
});

DELETE — Menghapus Data

const response = await fetch("/api/produk/1", {
  method: "DELETE"
});

if (response.ok) {
  console.log("Produk dihapus");
}

Perbandingan Method HTTP

Method Kegunaan Body Idempotent
GET Mengambil data ❌ ✅
POST Membuat data baru ✅ ❌
PUT Mengganti seluruh data ✅ ✅
PATCH Mengubah sebagian data ✅ ❌
DELETE Menghapus data ❌ ✅

Idempotent berarti request yang sama bisa diulang tanpa efek samping berbeda. GET, PUT, DELETE idempotent; POST tidak.


Mengirim Header

const response = await fetch("/api/data", {
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer token123",
    "Accept": "application/json",
    "X-Custom-Header": "nilai"
  }
});

Header Umum

Header Kegunaan
Content-Type Tipe body request (application/json, text/plain, multipart/form-data)
Accept Tipe response yang diharapkan
Authorization Kredensial (Bearer token, Basic base64)
X-Requested-With Menandai AJAX (XMLHttpRequest)
Cache-Control Kontrol caching

Membaca Header Response

const response = await fetch("/api/data");

console.log(response.headers.get("Content-Type"));
console.log(response.headers.get("X-RateLimit-Remaining"));

// Iterasi semua header
response.headers.forEach((value, key) => {
  console.log(`${key}: ${value}`);
});

Catatan: Beberapa header tidak bisa dibaca dari JavaScript karena alasan keamanan (misalnya Set-Cookie).


Mengirim JSON

Pola paling umum — mengirim dan menerima JSON:

async function kirimData(url, data) {
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify(data)
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}`);
  }

  return response.json();
}

// Penggunaan
const hasil = await kirimData("/api/produk", {
  nama: "Mouse",
  harga: 150000
});

Error Handling

Fetch Tidak Reject pada HTTP Error

Penting: fetch() hanya reject jika terjadi network error (server tidak bisa dihubungi, DNS gagal, CORS). Untuk HTTP error (404, 500), Promise tetap resolve — Anda harus cek response.ok secara manual.

// ❌ Tidak menangkap 404/500
try {
  const response = await fetch("/api/tidak-ada");
  const data = await response.json(); // error jika body bukan JSON
} catch (error) {
  // Hanya menangkap network error
}

// ✅ Cek response.ok
async function fetchData(url) {
  const response = await fetch(url);

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
  }

  return response.json();
}

try {
  const data = await fetchData("/api/tidak-ada");
} catch (error) {
  console.error("Gagal:", error.message);
  // "HTTP 404: Not Found"
}

Error Handling Lengkap

async function ambilData(url) {
  try {
    const response = await fetch(url);

    if (!response.ok) {
      // Coba baca pesan error dari body
      let pesan = `HTTP ${response.status}`;
      try {
        const errorBody = await response.json();
        pesan = errorBody.message || pesan;
      } catch {
        // Body bukan JSON — abaikan
      }
      throw new Error(pesan);
    }

    return await response.json();
  } 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);
    }
    throw error;
  }
}

Jenis Error pada Fetch

Error Penyebab
TypeError: Failed to fetch Network error, CORS, server tidak bisa dihubungi
AbortError Request dibatalkan via AbortController
SyntaxError response.json() gagal karena body bukan JSON
HTTP error (404, 500) Tidak throw — harus cek response.ok

AbortController — Membatalkan Request

AbortController memungkinkan membatalkan request yang sedang berjalan — berguna untuk timeout, navigasi, atau pencarian real-time.

Sintaks

const controller = new AbortController();
const signal = controller.signal;

fetch(url, { signal })
  .then(response => response.json())
  .catch(error => {
    if (error.name === "AbortError") {
      console.log("Request dibatalkan");
    }
  });

// Batalkan
controller.abort();

Timeout

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 (error) {
  if (error.name === "AbortError") {
    console.log("Timeout setelah 3 detik");
  }
}

Tips: AbortSignal.timeout(ms) (modern) menyederhanakan timeout:

const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
let controller = null;

async function cariProduk(keyword) {
  // Batalkan request sebelumnya
  if (controller) controller.abort();
  controller = new AbortController();

  try {
    const response = await fetch(`/api/produk?q=${keyword}`, {
      signal: controller.signal
    });
    const data = await response.json();
    renderHasil(data);
  } catch (error) {
    if (error.name !== "AbortError") {
      console.error(error);
    }
  }
}

// Setiap ketikan membatalkan request sebelumnya
searchInput.addEventListener("input", (e) => {
  cariProduk(e.target.value);
});

Upload File

FormData — Upload File & Data

<input type="file" id="file-input">
<button id="btn-upload">Upload</button>
document.querySelector("#btn-upload").addEventListener("click", async () => {
  const file = document.querySelector("#file-input").files[0];
  if (!file) return;

  const formData = new FormData();
  formData.append("file", file);
  formData.append("nama", "Foto Profil");

  try {
    const response = await fetch("/api/upload", {
      method: "POST",
      body: formData
      // Jangan set Content-Type — browser otomatis set dengan boundary
    });

    const hasil = await response.json();
    console.log("Upload berhasil:", hasil);
  } catch (error) {
    console.error("Upload gagal:", error);
  }
});

⚠️ Peringatan: Jangan set Content-Type: multipart/form-data secara manual — browser perlu menambahkan boundary. Biarkan browser mengaturnya.

Upload dengan Progress

fetch() tidak mendukung progress upload secara langsung. Gunakan XMLHttpRequest atau library seperti Axios:

// Dengan XMLHttpRequest
const xhr = new XMLHttpRequest();
xhr.upload.addEventListener("progress", (e) => {
  if (e.lengthComputable) {
    const persen = (e.loaded / e.total) * 100;
    console.log(`Upload: ${persen.toFixed(1)}%`);
  }
});

xhr.open("POST", "/api/upload");
xhr.send(formData);
// Dengan Axios
await axios.post("/api/upload", formData, {
  onUploadProgress: (e) => {
    const persen = (e.loaded / e.total) * 100;
    console.log(`Upload: ${persen.toFixed(1)}%`);
  }
});

CORS — Cross-Origin Resource Sharing

CORS adalah mekanisme keamanan browser yang membatasi request lintas origin (domain, port, atau protocol berbeda).

Apa Itu Origin?

Dua URL memiliki origin yang sama jika protocol + domain + port sama:

URL A URL B Same Origin?
https://example.com/a https://example.com/b ✅
https://example.com http://example.com ❌ (protocol)
https://example.com https://api.example.com ❌ (subdomain)
https://example.com https://example.com:8080 ❌ (port)

CORS Error

Jika frontend (http://localhost:3000) memanggil API (http://localhost:5000), browser akan memblokir kecuali server mengizinkan:

Access to fetch at 'http://localhost:5000/api' from origin 'http://localhost:3000'
has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present
on the requested resource.

Cara Mengatasi CORS

Dari sisi server (bukan client) — tambahkan header:

Access-Control-Allow-Origin: http://localhost:3000
Access-Control-Allow-Methods: GET, POST, PUT, DELETE
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Allow-Credentials: true

Contoh di Express.js (Node.js):

const cors = require("cors");
app.use(cors({
  origin: "http://localhost:3000",
  credentials: true
}));

Contoh di PHP:

header("Access-Control-Allow-Origin: http://localhost:3000");
header("Access-Control-Allow-Methods: GET, POST, PUT, DELETE");
header("Access-Control-Allow-Headers: Content-Type, Authorization");

Preflight Request

Untuk request “kompleks” (method selain GET/POST sederhana, atau header kustom), browser mengirim preflight OPTIONS request terlebih dahulu:

OPTIONS /api/data
Origin: http://localhost:3000
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: Content-Type

Server harus merespons dengan header CORS yang sesuai, baru request sebenarnya dikirim.

mode: "no-cors"

fetch(url, { mode: "no-cors" });

⚠️ Peringatan: no-cors bukan solusi untuk CORS. Mode ini mengembalikan opaque response — Anda tidak bisa membaca body atau status. Gunakan hanya untuk request “fire-and-forget” (misalnya analytics). Solusi sebenarnya adalah konfigurasi server.


Alternatif: Axios

Axios adalah library HTTP populer — sering digunakan karena API lebih nyaman daripada Fetch.

Instalasi

npm install axios

Perbandingan Fetch vs Axios

Aspek Fetch Axios
Bawaan browser ✅ ❌ (perlu install)
JSON otomatis ❌ (perlu JSON.stringify/.json()) ✅
Reject pada HTTP error ❌ ✅
Timeout Manual (AbortController) Built-in
Progress upload ❌ ✅
Interceptor ❌ ✅
Browser + Node.js ✅ (Node 18+) ✅

Contoh Axios

import axios from "axios";

// GET
const { data } = await axios.get("/api/produk");

// POST
const { data } = await axios.post("/api/produk", {
  nama: "Keyboard",
  harga: 450000
});

// Error handling — axios reject pada 4xx/5xx
try {
  const { data } = await axios.get("/api/tidak-ada");
} catch (error) {
  if (error.response) {
    console.log("Status:", error.response.status);
    console.log("Data:", error.response.data);
  } else if (error.request) {
    console.log("Tidak ada response");
  } else {
    console.log("Error:", error.message);
  }
}

// Timeout
await axios.get("/api/lambat", { timeout: 5000 });

// Interceptor
axios.interceptors.request.use(config => {
  config.headers.Authorization = `Bearer ${getToken()}`;
  return config;
});

Rekomendasi: Untuk proyek kecil, Fetch sudah cukup. Untuk proyek besar dengan banyak request, Axios menawarkan fitur yang menghemat waktu (interceptor, timeout built-in, progress).


Contoh Praktis

1. CRUD Lengkap dengan Fetch

const API = "https://api.example.com/produk";

const produkAPI = {
  async getAll() {
    const res = await fetch(API);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  },

  async getById(id) {
    const res = await fetch(`${API}/${id}`);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  },

  async create(data) {
    const res = await fetch(API, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(data)
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  },

  async update(id, data) {
    const res = await fetch(`${API}/${id}`, {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(data)
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  },

  async remove(id) {
    const res = await fetch(`${API}/${id}`, { method: "DELETE" });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return true;
  }
};

// Penggunaan
const produk = await produkAPI.getAll();
const baru = await produkAPI.create({ nama: "Mouse", harga: 150000 });
await produkAPI.update(baru.id, { harga: 175000 });
await produkAPI.remove(baru.id);

2. Menampilkan Data dengan Loading & Error State

async function muatProduk() {
  const container = document.querySelector("#container");
  const loading = document.querySelector("#loading");
  const errorEl = document.querySelector("#error");

  loading.style.display = "block";
  errorEl.textContent = "";
  container.innerHTML = "";

  try {
    const res = await fetch("/api/produk");
    if (!res.ok) throw new Error(`HTTP ${res.status}`);

    const data = await res.json();

    if (data.length === 0) {
      container.textContent = "Belum ada produk";
      return;
    }

    data.forEach(item => {
      const card = document.createElement("div");
      card.className = "card";
      card.innerHTML = `
        <h3>${item.nama}</h3>
        <p>Rp${item.harga.toLocaleString("id-ID")}</p>
      `;
      container.appendChild(card);
    });
  } catch (error) {
    errorEl.textContent = `Gagal memuat: ${error.message}`;
  } finally {
    loading.style.display = "none";
  }
}

3. Search dengan Debounce dan AbortController

function debounce(fn, delay) {
  let timeout;
  return (...args) => {
    clearTimeout(timeout);
    timeout = setTimeout(() => fn(...args), delay);
  };
}

let controller;

const searchProduk = debounce(async (keyword) => {
  if (controller) controller.abort();
  controller = new AbortController();

  try {
    const res = await fetch(`/api/produk?q=${encodeURIComponent(keyword)}`, {
      signal: controller.signal
    });
    const data = await res.json();
    renderHasil(data);
  } catch (error) {
    if (error.name !== "AbortError") {
      console.error(error);
    }
  }
}, 300);

document.querySelector("#search").addEventListener("input", (e) => {
  searchProduk(e.target.value);
});

4. Upload File dengan Preview

<input type="file" id="file" accept="image/*">
<img id="preview" style="max-width: 200px">
<button id="upload">Upload</button>

<script>
  const fileInput = document.querySelector("#file");
  const preview = document.querySelector("#preview");

  fileInput.addEventListener("change", () => {
    const file = fileInput.files[0];
    if (file) {
      preview.src = URL.createObjectURL(file);
    }
  });

  document.querySelector("#upload").addEventListener("click", async () => {
    const file = fileInput.files[0];
    if (!file) return alert("Pilih file dulu");

    const formData = new FormData();
    formData.append("foto", file);

    try {
      const res = await fetch("/api/upload", {
        method: "POST",
        body: formData
      });
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      const hasil = await res.json();
      alert(`Upload berhasil: ${hasil.url}`);
    } catch (err) {
      alert(`Upload gagal: ${err.message}`);
    }
  });
</script>

Tips & Best Practice

  1. Selalu cek response.ok — fetch tidak reject pada HTTP error.

  2. Gunakan async/await — lebih mudah dibaca daripada chaining .then().

  3. Gunakan URLSearchParams untuk query string — encoding otomatis.

  4. Jangan set Content-Type manual untuk FormData — browser mengatur boundary.

  5. Gunakan AbortController untuk timeout dan membatalkan request (search, navigasi).

  6. Debounce input search — hindari request berlebihan.

  7. Gunakan Promise.all() untuk request paralel.

  8. Simpan token di cookie HttpOnly, bukan localStorage — keamanan.

  9. CORS adalah tanggung jawab server — mode: "no-cors" bukan solusi.

  10. Untuk progress upload, gunakan XHR atau Axios — Fetch belum mendukungnya secara native.


Ringkasan

Konsep Poin Penting
fetch(url, options) Mengambil data — Promise
Method GET, POST, PUT, PATCH, DELETE
response.ok true jika status 200–299
response.json() Parse body sebagai JSON
Content-Type Tipe body request
AbortController Membatalkan request & timeout
FormData Upload file & data
CORS Batasan request lintas origin (diatur server)
Axios Library alternatif dengan fitur lebih

Poin penting:

  • fetch tidak reject pada HTTP error — selalu cek response.ok.
  • Body response hanya bisa dibaca sekali — gunakan clone() jika perlu dua kali.
  • Gunakan URLSearchParams untuk query string.
  • AbortController untuk timeout dan membatalkan request (search real-time).
  • CORS diatasi di server — bukan dengan mode: "no-cors".
  • FormData untuk upload file — jangan set Content-Type manual.
  • Axios menawarkan timeout, progress, dan interceptor — alternatif untuk proyek besar.

Pada artikel berikutnya, kita akan membahas Node.js & npm Dasar — menjalankan JavaScript di sisi server.

Top