DOM Manipulation
DOM adalah representasi halaman web yang bisa dimanipulasi JavaScript. Artikel ini membahas cara memilih elemen, mengubah konten, mengelola atribut dan style, serta membuat dan menghapus elemen secara dinamis.
Pendahuluan
DOM (Document Object Model) adalah representasi struktur halaman HTML sebagai pohon object yang bisa dimanipulasi JavaScript. Setiap elemen HTML — <div>, <p>, <button> — menjadi object yang bisa diubah: teksnya, warnanya, atributnya, bahkan posisinya di halaman.
DOM manipulation adalah inti dari JavaScript di browser. Dengan DOM, kita bisa:
- Mengubah teks dan HTML secara dinamis.
- Menambah, menghapus, dan memindahkan elemen.
- Mengubah style dan class.
- Membuat aplikasi web interaktif (to-do list, form validation, modal, dll.).
Artikel ini membahas semua aspek DOM manipulation dengan contoh praktis.
Asumsi: Anda sudah memahami variabel, fungsi, array, dan object dari artikel sebelumnya. Gunakan browser dengan DevTools untuk mencoba contoh.
Memahami DOM
Saat browser memuat HTML, ia membangun DOM tree — struktur pohon yang merepresentasikan halaman.
<!DOCTYPE html>
<html>
<head>
<title>Latihan DOM</title>
</head>
<body>
<h1 id="judul">Halo!</h1>
<ul class="daftar">
<li>Item 1</li>
<li>Item 2</li>
</ul>
<button class="tombol">Klik</button>
</body>
</html>
DOM tree-nya:
document
└── html
├── head
│ └── title
│ └── "Latihan DOM"
└── body
├── h1#judul
│ └── "Halo!"
├── ul.daftar
│ ├── li
│ │ └── "Item 1"
│ └── li
│ └── "Item 2"
└── button.tombol
└── "Klik"
Semua manipulasi DOM dimulai dari object global document.
Menyeleksi Elemen
Untuk memanipulasi elemen, kita harus memilih-nya terlebih dahulu. JavaScript menyediakan beberapa cara.
querySelector() — Satu Elemen Pertama (Rekomendasikan)
Menerima selector CSS dan mengembalikan elemen pertama yang cocok.
// By ID
const judul = document.querySelector("#judul");
// By class
const tombol = document.querySelector(".tombol");
// By tag
const h1 = document.querySelector("h1");
// Selector kompleks
const itemPertama = document.querySelector("ul.daftar > li:first-child");
const inputEmail = document.querySelector('input[type="email"]');
querySelectorAll() — Semua Elemen
Mengembalikan NodeList (array-like) berisi semua elemen yang cocok.
const semuaLi = document.querySelectorAll("li");
console.log(semuaLi.length); // 2
// Iterasi dengan forEach
semuaLi.forEach(li => console.log(li.textContent));
// Atau dengan for...of
for (const li of semuaLi) {
console.log(li.textContent);
}
Catatan:
querySelectorAll()mengembalikan NodeList statis — tidak berubah jika DOM berubah setelah seleksi.
getElementById() — By ID (Cepat)
const judul = document.getElementById("judul");
Lebih cepat dari querySelector("#judul") untuk ID, tetapi kurang fleksibel.
getElementsByClassName() — By Class (Live HTMLCollection)
const tombol = document.getElementsByClassName("tombol");
console.log(tombol.length); // 1
⚠️ Peringatan:
getElementsByClassName()mengembalikan HTMLCollection live — otomatis diperbarui jika DOM berubah. Ini bisa membingungkan dalam loop.
getElementsByTagName() — By Tag (Live HTMLCollection)
const semuaLi = document.getElementsByTagName("li");
Perbandingan Method Seleksi
| Method | Mengembalikan | Selector CSS | Live? |
|---|---|---|---|
querySelector() |
Element | ✅ | ❌ |
querySelectorAll() |
NodeList | ✅ | ❌ (statis) |
getElementById() |
Element | ❌ (ID saja) | ❌ |
getElementsByClassName() |
HTMLCollection | ❌ | ✅ |
getElementsByTagName() |
HTMLCollection | ❌ | ✅ |
Rekomendasi: Gunakan
querySelector()/querySelectorAll()sebagai default — selector CSS lebih fleksibel dan konsisten.
Seleksi Relatif (Navigasi DOM)
Dari elemen yang sudah dipilih, kita bisa menavigasi ke elemen lain.
const ul = document.querySelector(".daftar");
// Anak
console.log(ul.children); // HTMLCollection anak langsung
console.log(ul.firstElementChild); // li pertama
console.log(ul.lastElementChild); // li terakhir
console.log(ul.children[1]); // li kedua
// Induk
const li = ul.firstElementChild;
console.log(li.parentElement); // ul
// Saudara
console.log(li.nextElementSibling); // li kedua
console.log(li.previousElementSibling); // null (tidak ada)
Catatan:
children,firstElementChild, dll. hanya mengembalikan element (bukan text node). Sebaliknya,childNodes,firstChildmengembalikan semua node termasuk text/comment.
Mengubah Konten
textContent — Teks Murni
Mengambil atau mengubah teks tanpa memproses HTML.
const judul = document.querySelector("#judul");
// Baca
console.log(judul.textContent); // "Halo!"
// Ubah
judul.textContent = "Halo, DOM!";
Aman dari XSS karena HTML tidak diproses.
innerHTML — HTML di Dalam Elemen
Mengambil atau mengubah HTML di dalam elemen.
const container = document.querySelector("#container");
// Baca
console.log(container.innerHTML);
// Ubah — HTML diproses
container.innerHTML = "<p>Paragraf <strong>baru</strong></p>";
⚠️ Peringatan XSS: Jangan pernah memasukkan input user langsung ke
innerHTML— bisa menyebabkan Cross-Site Scripting (XSS). GunakantextContentuntuk teks dari user.
// ❌ BAHAYA — XSS
container.innerHTML = `<p>${userInput}</p>`;
// ✅ AMAN
container.textContent = userInput;
// ✅ AMAN jika perlu HTML — gunakan DOM API
const p = document.createElement("p");
p.textContent = userInput;
container.appendChild(p);
innerText vs textContent
| Aspek | textContent |
innerText |
|---|---|---|
| Memproses CSS | ❌ | ✅ (menghormati display: none) |
| Performa | Lebih cepat | Lebih lambat (reflow) |
| Mengembalikan | Semua teks (termasuk tersembunyi) | Teks yang terlihat |
| Rekomendasi | Default pilihan | Hanya jika butuh teks terlihat |
// <div id="x">Hello <span style="display:none">Hidden</span> World</div>
console.log(x.textContent); // "Hello Hidden World"
console.log(x.innerText); // "Hello World" (span tersembunyi dilewati)
outerHTML — HTML Elemen Itu Sendiri
const judul = document.querySelector("#judul");
console.log(judul.outerHTML); // '<h1 id="judul">Halo!</h1>'
// Mengganti elemen sepenuhnya
judul.outerHTML = '<h2 id="judul">Halo Baru!</h2>';
Catatan: Setelah
outerHTMLdiubah, referensi ke elemen lama menjadi stale (tidak terhubung ke DOM).
Mengubah Atribut
getAttribute() dan setAttribute()
const link = document.querySelector("a");
console.log(link.getAttribute("href")); // "https://example.com"
link.setAttribute("href", "https://example.org");
link.setAttribute("target", "_blank");
removeAttribute()
link.removeAttribute("target");
hasAttribute()
console.log(link.hasAttribute("href")); // true
console.log(link.hasAttribute("target")); // false
Properti Langsung
Banyak atribut HTML punya properti JavaScript yang setara:
const input = document.querySelector("input");
input.value = "Hello"; // atribut value
input.disabled = true; // atribut disabled
input.placeholder = "Ketik..."; // atribut placeholder
const img = document.querySelector("img");
img.src = "gambar.jpg";
img.alt = "Deskripsi gambar";
const checkbox = document.querySelector('input[type="checkbox"]');
checkbox.checked = true;
Perbedaan atribut vs properti:
<input type="text" value="awal">
const input = document.querySelector("input");
console.log(input.getAttribute("value")); // "awal" (nilai awal di HTML)
input.value = "baru";
console.log(input.value); // "baru" (nilai saat ini)
console.log(input.getAttribute("value")); // "awal" (atribut tidak berubah)
Tips: Untuk form, gunakan properti (
input.value) karena mencerminkan state saat ini. GunakangetAttribute()untuk nilai awal di HTML.
Mengubah Style
style — Inline Style
const kotak = document.querySelector(".kotak");
kotak.style.backgroundColor = "blue";
kotak.style.color = "white";
kotak.style.padding = "20px";
kotak.style.borderRadius = "8px";
// CSS property dengan tanda hubung → camelCase
kotak.style.fontSize = "18px"; // font-size
kotak.style.marginTop = "10px"; // margin-top
Menghapus style:
kotak.style.backgroundColor = ""; // reset ke default
Mengatur beberapa style sekaligus:
Object.assign(kotak.style, {
backgroundColor: "blue",
color: "white",
padding: "20px"
});
Membaca computed style (style aktual setelah CSS diterapkan):
const style = getComputedStyle(kotak);
console.log(style.backgroundColor); // "rgb(0, 0, 255)"
console.log(style.fontSize); // "18px"
cssText — Beberapa Style sebagai String
kotak.style.cssText = "background: blue; color: white; padding: 20px;";
Catatan:
cssTextmenimpa semua inline style yang ada.
Best practice: Untuk style yang kompleks, gunakan class (via
classList) daripada inline style. Inline style sulit dipelihara dan tidak bisa di-cache browser.
classList — Mengelola Class
classList adalah interface modern untuk mengelola class CSS pada elemen.
Method classList
const el = document.querySelector(".kotak");
// Tambah class
el.classList.add("aktif");
el.classList.add("besar", "merah"); // beberapa sekaligus
// Hapus class
el.classList.remove("aktif");
// Toggle — tambah jika belum ada, hapus jika sudah ada
el.classList.toggle("aktif");
// Cek apakah punya class
console.log(el.classList.contains("aktif")); // true/false
// Ganti class
el.classList.replace("lama", "baru");
// Jumlah class
console.log(el.classList.length);
Iterasi Class
el.classList.forEach(cls => console.log(cls));
className vs classList
// className — string, menimpa semua class
el.className = "kotak besar merah";
// classList — lebih aman, method untuk add/remove/toggle
el.classList.add("baru");
Rekomendasi: Gunakan
classList— lebih aman dan ekspresif daripada memanipulasi stringclassName.
dataset — Data Attributes
Data attributes (data-*) memungkinkan menyimpan data kustom pada elemen HTML.
<div id="user" data-id="123" data-role="admin" data-nama-lengkap="Budi Santoso">
Budi
</div>
Mengakses via dataset
const user = document.querySelector("#user");
console.log(user.dataset.id); // "123"
console.log(user.dataset.role); // "admin"
console.log(user.dataset.namaLengkap); // "Budi Santoso" (camelCase!)
Catatan:
data-nama-lengkap(kebab-case di HTML) menjadidataset.namaLengkap(camelCase di JavaScript).
Mengubah dataset
user.dataset.role = "user";
user.dataset.status = "aktif"; // menambah data-status="aktif"
Menghapus
delete user.dataset.role;
Kapan Menggunakan dataset?
- Menyimpan metadata pada elemen (ID, state, konfigurasi).
- Menghubungkan elemen dengan data di JavaScript.
- Bukan untuk data sensitif — semua
data-*terlihat di HTML.
<button class="beli" data-produk-id="42" data-harga="150000">Beli</button>
document.querySelectorAll(".beli").forEach(btn => {
btn.addEventListener("click", () => {
const produkId = btn.dataset.produkId;
const harga = Number(btn.dataset.harga);
console.log(`Beli produk ${produkId} seharga Rp${harga}`);
});
});
Membuat Elemen Baru
createElement()
const p = document.createElement("p");
p.textContent = "Paragraf baru";
p.className = "teks";
Elemen yang dibuat belum muncul di halaman — harus ditambahkan ke DOM.
createTextNode()
const teks = document.createTextNode("Hello");
p.appendChild(teks);
Biasanya lebih mudah menggunakan textContent.
cloneNode()
const asli = document.querySelector(".kotak");
const salinan = asli.cloneNode(true); // true = deep clone (termasuk anak)
const salinanDangkal = asli.cloneNode(false); // shallow
Menambahkan Elemen ke DOM
appendChild() — Tambah sebagai Anak Terakhir
const ul = document.querySelector(".daftar");
const li = document.createElement("li");
li.textContent = "Item baru";
ul.appendChild(li);
append() — Tambah Beberapa Node/String
ul.append(li, "Teks biasa", document.createElement("hr"));
append() menerima node dan string (string otomatis jadi text node).
prepend() — Tambah di Awal
ul.prepend(li); // li menjadi anak pertama
insertBefore() — Sisipkan Sebelum Elemen Tertentu
const referensi = ul.children[1];
ul.insertBefore(li, referensi); // sisipkan li sebelum referensi
insertAdjacentElement() / insertAdjacentHTML()
Menyisipkan relatif terhadap elemen:
const el = document.querySelector(".kotak");
el.insertAdjacentHTML("beforebegin", "<p>Sebelum</p>");
el.insertAdjacentHTML("afterbegin", "<p>Awal dalam</p>");
el.insertAdjacentHTML("beforeend", "<p>Akhir dalam</p>");
el.insertAdjacentHTML("afterend", "<p>Sesudah</p>");
Posisi:
<!-- beforebegin -->
<div>
<!-- afterbegin -->
...konten...
<!-- beforeend -->
</div>
<!-- afterend -->
⚠️ Peringatan XSS:
insertAdjacentHTML()memproses HTML — jangan gunakan dengan input user tanpa sanitasi.
Perbandingan Method Penambahan
| Method | Menerima | Posisi |
|---|---|---|
appendChild() |
Node | Akhir |
append() |
Node + string | Akhir |
prepend() |
Node + string | Awal |
insertBefore() |
Node | Sebelum referensi |
insertAdjacentElement() |
Element | Relatif |
insertAdjacentHTML() |
String HTML | Relatif |
Menghapus dan Mengganti Elemen
remove() — Hapus Elemen
const el = document.querySelector(".kotak");
el.remove();
removeChild() — Hapus Anak (Cara Lama)
const parent = document.querySelector(".daftar");
const child = parent.firstElementChild;
parent.removeChild(child);
replaceWith() — Ganti Elemen
const lama = document.querySelector(".lama");
const baru = document.createElement("p");
baru.textContent = "Elemen baru";
lama.replaceWith(baru);
replaceChild() — Ganti Anak (Cara Lama)
parent.replaceChild(baru, lama);
Mengosongkan Elemen
// Cara 1: innerHTML
el.innerHTML = "";
// Cara 2: while + removeChild
while (el.firstChild) {
el.removeChild(el.firstChild);
}
// Cara 3: replaceChildren (modern)
el.replaceChildren();
Tips:
replaceChildren()adalah cara paling modern dan efisien untuk mengosongkan atau mengganti semua anak.
Contoh Praktis
1. To-Do List Sederhana
<!DOCTYPE html>
<html>
<body>
<h1>To-Do List</h1>
<input type="text" id="input-todo" placeholder="Tugas baru...">
<button id="btn-tambah">Tambah</button>
<ul id="daftar-todo"></ul>
<script>
const input = document.querySelector("#input-todo");
const btnTambah = document.querySelector("#btn-tambah");
const daftar = document.querySelector("#daftar-todo");
btnTambah.addEventListener("click", () => {
const teks = input.value.trim();
if (teks === "") return;
const li = document.createElement("li");
li.textContent = teks;
// Tombol hapus
const btnHapus = document.createElement("button");
btnHapus.textContent = "Hapus";
btnHapus.className = "hapus";
btnHapus.addEventListener("click", () => li.remove());
li.appendChild(btnHapus);
daftar.appendChild(li);
input.value = "";
input.focus();
});
</script>
</body>
</html>
2. Menampilkan Daftar Produk dari Data
const produk = [
{ id: 1, nama: "Keyboard", harga: 450000 },
{ id: 2, nama: "Mouse", harga: 150000 },
{ id: 3, nama: "Monitor", harga: 1500000 }
];
const container = document.querySelector("#produk-list");
function renderProduk(produkList) {
container.innerHTML = ""; // kosongkan dulu
produkList.forEach(p => {
const card = document.createElement("div");
card.className = "card";
card.dataset.id = p.id;
const judul = document.createElement("h3");
judul.textContent = p.nama;
const harga = document.createElement("p");
harga.textContent = `Rp${p.harga.toLocaleString("id-ID")}`;
card.append(judul, harga);
container.appendChild(card);
});
}
renderProduk(produk);
3. Mengubah Tema (Dark/Light Mode)
const btnTema = document.querySelector("#btn-tema");
const body = document.body;
btnTema.addEventListener("click", () => {
body.classList.toggle("dark-mode");
btnTema.textContent = body.classList.contains("dark-mode")
? "☀️ Light Mode"
: "🌙 Dark Mode";
});
Dengan CSS:
body {
background: white;
color: black;
transition: background 0.3s, color 0.3s;
}
body.dark-mode {
background: #1a1a1a;
color: white;
}
4. Tabel Dinamis dari Array
const users = [
{ id: 1, nama: "Budi", email: "[email protected]" },
{ id: 2, nama: "Siti", email: "[email protected]" }
];
const tbody = document.querySelector("#users tbody");
tbody.innerHTML = users.map(u => `
<tr>
<td>${u.id}</td>
<td>${u.nama}</td>
<td>${u.email}</td>
</tr>
`).join("");
⚠️ Peringatan: Contoh di atas menggunakan
innerHTMLdengan template literal. Aman jika data berasal dari kode Anda sendiri, tetapi berbahaya jika data dari input user. Untuk data user, gunakantextContentdancreateElement.
5. Filter Real-time
<input type="text" id="search" placeholder="Cari produk...">
<ul id="hasil"></ul>
<script>
const produk = ["Keyboard", "Mouse", "Monitor", "Headset", "Webcam"];
const search = document.querySelector("#search");
const hasil = document.querySelector("#hasil");
search.addEventListener("input", () => {
const keyword = search.value.toLowerCase();
const filter = produk.filter(p => p.toLowerCase().includes(keyword));
hasil.replaceChildren(
...filter.map(p => {
const li = document.createElement("li");
li.textContent = p;
return li;
})
);
});
</script>
Tips & Best Practice
-
Utamakan
textContentdaripadainnerHTMLuntuk teks dari user — mencegah XSS. -
Gunakan
classListdaripada memanipulasiclassNamestring. -
Gunakan
datasetuntuk metadata, bukan atribut non-standar. -
Cache seleksi DOM — jangan panggil
querySelectorberulang kali di loop.
// ❌ Buruk
for (let i = 0; i < 100; i++) {
document.querySelector(".kotak").style.width = i + "px";
}
// ✅ Baik
const kotak = document.querySelector(".kotak");
for (let i = 0; i < 100; i++) {
kotak.style.width = i + "px";
}
- Batch update DOM — ubah DOM di luar loop jika memungkinkan, atau gunakan
DocumentFragment.
const fragment = document.createDocumentFragment();
for (let i = 0; i < 100; i++) {
const li = document.createElement("li");
li.textContent = `Item ${i}`;
fragment.appendChild(li);
}
ul.appendChild(fragment); // satu kali update DOM
-
Gunakan
replaceChildren()untuk mengosongkan/mengganti anak — lebih efisien. -
Event handling dibahas di artikel berikutnya — jangan campur inline
onclickdi HTML. -
Aksesibilitas — saat memanipulasi DOM, pertimbangkan
aria-*dan fokus keyboard.
Ringkasan
| Kategori | Method / Properti |
|---|---|
| Seleksi | querySelector, querySelectorAll, getElementById |
| Navigasi | children, parentElement, nextElementSibling |
| Konten | textContent, innerHTML, innerText, outerHTML |
| Atribut | getAttribute, setAttribute, removeAttribute, dataset |
| Style | style, getComputedStyle, classList |
| Membuat | createElement, createTextNode, cloneNode |
| Menambah | appendChild, append, prepend, insertBefore, insertAdjacentHTML |
| Menghapus | remove, removeChild, replaceWith, replaceChildren |
Poin penting:
- Gunakan
querySelector/querySelectorAllsebagai default. textContentaman dari XSS;innerHTMLmemproses HTML (hati-hati!).classListlebih aman dan ekspresif daripadaclassName.datasetmengaksesdata-*(kebab-case → camelCase).- Gunakan
DocumentFragmentuntuk batch update DOM. - Cache seleksi DOM — jangan query berulang di loop.
replaceChildren()cara modern mengosongkan/mengganti anak.
Pada artikel berikutnya, kita akan membahas Event & Event Handling — merespons interaksi user.