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, firstChild mengembalikan 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). Gunakan textContent untuk 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 outerHTML diubah, 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. Gunakan getAttribute() 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: cssText menimpa 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 string className.


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) menjadi dataset.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 innerHTML dengan template literal. Aman jika data berasal dari kode Anda sendiri, tetapi berbahaya jika data dari input user. Untuk data user, gunakan textContent dan createElement.

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

  1. Utamakan textContent daripada innerHTML untuk teks dari user — mencegah XSS.

  2. Gunakan classList daripada memanipulasi className string.

  3. Gunakan dataset untuk metadata, bukan atribut non-standar.

  4. Cache seleksi DOM — jangan panggil querySelector berulang 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";
}
  1. 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
  1. Gunakan replaceChildren() untuk mengosongkan/mengganti anak — lebih efisien.

  2. Event handling dibahas di artikel berikutnya — jangan campur inline onclick di HTML.

  3. 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/querySelectorAll sebagai default.
  • textContent aman dari XSS; innerHTML memproses HTML (hati-hati!).
  • classList lebih aman dan ekspresif daripada className.
  • dataset mengakses data-* (kebab-case → camelCase).
  • Gunakan DocumentFragment untuk 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.

Top