Event & Event Handling

Event membuat halaman web interaktif — merespons klik, ketikan, scroll, dan interaksi user lainnya. Artikel ini membahas addEventListener, event object, bubbling/capturing, event delegation, serta event umum seperti click, submit, input, dan keyboard.

Pendahuluan

Event adalah sinyal bahwa sesuatu telah terjadi — user mengklik tombol, mengetik di input, menggulir halaman, atau browser selesai memuat dokumen. Event handling adalah cara JavaScript merespons event tersebut.

Tanpa event, halaman web hanya statis. Dengan event, kita bisa membuat:

  • Tombol yang bereaksi saat diklik.
  • Form yang divalidasi saat di-submit.
  • Pencarian real-time saat user mengetik.
  • Modal yang muncul dan hilang.
  • Dan sebagainya.

Artikel ini membahas cara mendaftarkan event listener, memahami event object, konsep bubbling dan capturing, event delegation, serta event-event yang paling umum digunakan.

Asumsi: Anda sudah memahami DOM manipulation dari artikel sebelumnya.


Dasar Event Handling

addEventListener() — Cara Modern (Rekomendasikan)

const tombol = document.querySelector("#tombol");

tombol.addEventListener("click", () => {
  console.log("Tombol diklik!");
});

Sintaks: element.addEventListener(eventType, listener, options)

  • eventType — nama event (string), misalnya "click", "submit", "input".
  • listener — fungsi yang dipanggil saat event terjadi.
  • options — object opsional (dibahas nanti).

onclick — Cara Lama (Hindari)

// ❌ Menimpa listener sebelumnya
tombol.onclick = () => console.log("Pertama");
tombol.onclick = () => console.log("Kedua"); // "Pertama" hilang!

// ✅ addEventListener — bisa banyak listener
tombol.addEventListener("click", () => console.log("Pertama"));
tombol.addEventListener("click", () => console.log("Kedua"));
// Keduanya jalan!

Rekomendasi: Selalu gunakan addEventListener(). Lebih fleksibel, mendukung banyak listener, dan bisa dihapus dengan removeEventListener().

removeEventListener() — Menghapus Listener

function handleClick() {
  console.log("Diklik!");
}

tombol.addEventListener("click", handleClick);

// Hapus — HARUS merujuk ke fungsi yang sama
tombol.removeEventListener("click", handleClick);

⚠️ Peringatan: removeEventListener() memerlukan referensi fungsi yang sama dengan yang didaftarkan. Arrow function inline tidak bisa dihapus!

// ❌ Tidak bisa dihapus
tombol.addEventListener("click", () => console.log("x"));
tombol.removeEventListener("click", () => console.log("x")); // tidak berhasil

// ✅ Bisa dihapus
const handler = () => console.log("x");
tombol.addEventListener("click", handler);
tombol.removeEventListener("click", handler); // berhasil

Opsi pada addEventListener()

element.addEventListener("click", handler, {
  once: true,      // listener otomatis dihapus setelah dipanggil sekali
  capture: true,   // listener dipanggil di fase capturing
  passive: true    // listener tidak akan memanggil preventDefault()
});
  • once: true — listener dihapus otomatis setelah dipanggil sekali.
  • capture: true — listener dipanggil di fase capturing (dibahas di bagian Bubbling & Capturing).
  • passive: true — menandakan listener tidak akan memanggil preventDefault(). Berguna untuk event scroll/touchmove agar browser tidak menunggu listener selesai sebelum menggulir — meningkatkan performa.
// Contoh: tombol yang hanya bisa diklik sekali
tombol.addEventListener("click", () => {
  console.log("Diklik sekali!");
}, { once: true });

Event Object

Setiap event handler menerima event object sebagai argumen pertama. Object ini berisi informasi tentang event.

tombol.addEventListener("click", (event) => {
  console.log(event.type);      // "click"
  console.log(event.target);    // elemen yang memicu event
  console.log(event.currentTarget); // elemen tempat listener terpasang
  console.log(event.timeStamp); // waktu event terjadi
});

Properti Penting Event Object

Properti Arti
type Jenis event ("click", "keydown", dll.)
target Elemen asal yang memicu event
currentTarget Elemen tempat listener terpasang
timeStamp Waktu event (milidetik)
defaultPrevented Apakah preventDefault() sudah dipanggil
bubbles Apakah event bubbling

Perbedaan target vs currentTarget:

<div id="parent">
  <button id="child">Klik</button>
</div>
const parent = document.querySelector("#parent");

parent.addEventListener("click", (e) => {
  console.log(e.target.id);        // "child" (elemen yang diklik)
  console.log(e.currentTarget.id); // "parent" (tempat listener)
});

preventDefault() — Mencegah Perilaku Default

Banyak elemen memiliki perilaku default:

  • Link <a> → navigasi ke URL.
  • Form <form> → submit dan reload halaman.
  • Checkbox → toggle checked.

preventDefault() mencegah perilaku tersebut.

// Mencegah link navigasi
const link = document.querySelector("a");
link.addEventListener("click", (e) => {
  e.preventDefault();
  console.log("Navigasi dibatalkan");
});

// Mencegah form submit reload
const form = document.querySelector("form");
form.addEventListener("submit", (e) => {
  e.preventDefault();
  console.log("Form di-submit tanpa reload");
  // proses data via fetch...
});

stopPropagation() — Menghentikan Bubbling

Mencegah event “naik” ke parent (dibahas di bagian Bubbling).

child.addEventListener("click", (e) => {
  e.stopPropagation();
  console.log("Hanya child yang handle");
});

stopImmediatePropagation() — Menghentikan Semua Listener Lain

Mencegah listener lain pada elemen yang sama (dan parent) dijalankan.

tombol.addEventListener("click", (e) => {
  e.stopImmediatePropagation();
  console.log("Listener 1");
});

tombol.addEventListener("click", () => {
  console.log("Listener 2"); // TIDAK dijalankan
});

Bubbling dan Capturing

Saat event terjadi pada elemen, event tersebut melewati tiga fase:

  1. Capturing — event turun dari document ke target.
  2. Target — event mencapai elemen target.
  3. Bubbling — event naik dari target ke document.

Secara default, listener dipasang di fase bubbling.

Ilustrasi

<div id="luar">
  <div id="tengah">
    <button id="dalam">Klik</button>
  </div>
</div>
document.querySelector("#luar").addEventListener("click", () => console.log("luar"));
document.querySelector("#tengah").addEventListener("click", () => console.log("tengah"));
document.querySelector("#dalam").addEventListener("click", () => console.log("dalam"));

Saat tombol #dalam diklik, output:

dalam
tengah
luar

Event “naik” dari target ke parent — inilah bubbling.

Capturing

Untuk memasang listener di fase capturing, gunakan capture: true:

document.querySelector("#luar").addEventListener("click", () => console.log("luar (capture)"), true);
document.querySelector("#tengah").addEventListener("click", () => console.log("tengah (capture)"), true);
document.querySelector("#dalam").addEventListener("click", () => console.log("dalam (capture)"), true);

Output saat tombol diklik:

luar (capture)
tengah (capture)
dalam (capture)

Event turun dari luar ke dalam.

Menghentikan Bubbling

document.querySelector("#dalam").addEventListener("click", (e) => {
  e.stopPropagation();
  console.log("dalam — bubbling dihentikan");
});

document.querySelector("#tengah").addEventListener("click", () => {
  console.log("tengah"); // TIDAK dijalankan
});

document.querySelector("#luar").addEventListener("click", () => {
  console.log("luar"); // TIDAK dijalankan
});

Tips: Hindari stopPropagation() kecuali benar-benar perlu. Menghentikan bubbling bisa memutus event delegation dan menyebabkan bug yang sulit dilacak.


Event Delegation

Event delegation adalah teknik memasang satu listener pada parent untuk menangani event dari banyak anak. Ini memanfaatkan bubbling.

Masalah: Listener per Elemen

// ❌ Tidak efisien — listener untuk setiap item
document.querySelectorAll(".item").forEach(item => {
  item.addEventListener("click", () => {
    console.log(`Klik: ${item.textContent}`);
  });
});

Masalah:

  • Banyak listener (boros memori).
  • Item baru yang ditambahkan tidak memiliki listener.

Solusi: Event Delegation

// ✅ Satu listener di parent
const daftar = document.querySelector("#daftar");

daftar.addEventListener("click", (e) => {
  const item = e.target.closest(".item");
  if (!item) return; // klik di luar item

  console.log(`Klik: ${item.textContent}`);
});

Keuntungan:

  • Satu listener untuk banyak elemen — hemat memori.
  • Item baru otomatis “ter-handle” tanpa perlu listener tambahan.
  • Lebih mudah dikelola.

closest() — Mencari Parent Terdekat yang Cocok

daftar.addEventListener("click", (e) => {
  const tombol = e.target.closest(".btn-hapus");
  if (tombol) {
    const item = tombol.closest(".item");
    item.remove();
  }
});

closest() menelusuri dari e.target ke atas hingga menemukan elemen yang cocok dengan selector, atau null.

Contoh: To-Do List dengan Delegation

const daftar = document.querySelector("#daftar-todo");

// Satu listener untuk semua tombol hapus (termasuk yang ditambahkan nanti)
daftar.addEventListener("click", (e) => {
  if (e.target.matches(".btn-hapus")) {
    e.target.closest("li").remove();
  }
});

Tips: Gunakan e.target.matches(selector) untuk cek apakah target cocok dengan selector tertentu.


Event Umum

Mouse Events

Event Kapan Terjadi
click Klik kiri (setelah mousedown + mouseup)
dblclick Double klik
mousedown / mouseup Tombol mouse ditekan/dilepas
mousemove Mouse bergerak
mouseenter / mouseleave Mouse masuk/keluar elemen (tidak bubble)
mouseover / mouseout Mouse masuk/keluar elemen (bubble)
contextmenu Klik kanan

Properti event mouse:

document.addEventListener("click", (e) => {
  console.log(e.clientX, e.clientY); // koordinat relatif viewport
  console.log(e.pageX, e.pageY);     // koordinat relatif dokumen
  console.log(e.button);             // 0 = kiri, 1 = tengah, 2 = kanan
  console.log(e.ctrlKey);            // apakah Ctrl ditekan
  console.log(e.shiftKey);           // apakah Shift ditekan
});

Keyboard Events

Event Kapan Terjadi
keydown Tombol ditekan (berulang jika ditahan)
keyup Tombol dilepas
keypress (Deprecated) — gunakan keydown
document.addEventListener("keydown", (e) => {
  console.log(e.key);      // "a", "Enter", "Escape", "ArrowUp", dll.
  console.log(e.code);     // "KeyA", "Enter", "Escape", "ArrowUp"
  console.log(e.ctrlKey);  // apakah Ctrl ditekan
  console.log(e.altKey);   // apakah Alt ditekan
  console.log(e.shiftKey); // apakah Shift ditekan
  console.log(e.metaKey);  // Cmd (macOS) / Windows key
});

Perbedaan key vs code:

  • key — karakter yang dihasilkan (terpengaruh layout keyboard & Shift).
  • code — kode fisik tombol (tidak terpengaruh layout).
// Tekan "a":
// e.key = "a", e.code = "KeyA"

// Tekan Shift + "a":
// e.key = "A", e.code = "KeyA"

// Tekan "1" di keyboard US:
// e.key = "1", e.code = "Digit1"

Contoh: Shortcut keyboard:

document.addEventListener("keydown", (e) => {
  // Ctrl + S — simpan
  if (e.ctrlKey && e.key === "s") {
    e.preventDefault();
    console.log("Simpan!");
  }

  // Escape — tutup modal
  if (e.key === "Escape") {
    tutupModal();
  }
});

Form Events

Event Kapan Terjadi
submit Form di-submit
reset Form di-reset
input Nilai input berubah (real-time)
change Nilai berubah dan elemen kehilangan fokus
focus / blur Elemen mendapat/kehilangan fokus
focusin / focusout Seperti focus/blur, tetapi bubble
const form = document.querySelector("form");
const input = document.querySelector("#nama");

// Submit — cegah reload
form.addEventListener("submit", (e) => {
  e.preventDefault();
  console.log("Data:", input.value);
});

// Input — real-time saat mengetik
input.addEventListener("input", (e) => {
  console.log("Nilai saat ini:", e.target.value);
});

// Change — setelah kehilangan fokus
input.addEventListener("change", (e) => {
  console.log("Nilai final:", e.target.value);
});

// Focus/blur
input.addEventListener("focus", () => console.log("Fokus"));
input.addEventListener("blur", () => console.log("Blur"));

Perbedaan input vs change:

  • input — dipicu setiap perubahan (setiap ketikan).
  • change — dipicu saat nilai berubah dan elemen kehilangan fokus (atau Enter ditekan).
// Real-time search — gunakan input
searchInput.addEventListener("input", (e) => {
  filterProduk(e.target.value);
});

// Validasi setelah user selesai mengetik — gunakan change
emailInput.addEventListener("change", (e) => {
  validasiEmail(e.target.value);
});

Window Events

Event Kapan Terjadi
load Halaman selesai dimuat (termasuk gambar)
DOMContentLoaded HTML selesai di-parse (sebelum gambar)
resize Window di-resize
scroll Halaman di-scroll
beforeunload Sebelum halaman ditutup (konfirmasi)
// DOMContentLoaded — lebih cepat dari load
document.addEventListener("DOMContentLoaded", () => {
  console.log("DOM siap!");
});

// Resize — dengan debounce (lihat tips)
window.addEventListener("resize", () => {
  console.log(window.innerWidth, window.innerHeight);
});

// Scroll
window.addEventListener("scroll", () => {
  console.log(window.scrollY);
});

Perbedaan DOMContentLoaded vs load:

// DOMContentLoaded — HTML selesai di-parse, gambar mungkin belum
document.addEventListener("DOMContentLoaded", () => {
  // Aman untuk mengakses DOM
});

// load — semua resource (gambar, CSS) selesai dimuat
window.addEventListener("load", () => {
  // Semua siap, termasuk gambar
});

Tips: Untuk manipulasi DOM, gunakan DOMContentLoaded — lebih cepat. Gunakan load hanya jika butuh gambar sudah dimuat (misalnya untuk mengukur dimensi gambar).

Touch Events (Mobile)

Event Kapan Terjadi
touchstart Jari menyentuh layar
touchmove Jari bergerak di layar
touchend Jari diangkat
touchcancel Touch dibatalkan (misalnya telepon masuk)
element.addEventListener("touchstart", (e) => {
  console.log(e.touches.length); // jumlah jari
  console.log(e.touches[0].clientX, e.touches[0].clientY);
});

Catatan: Untuk sebagian besar kasus, click sudah cukup di mobile. Gunakan touch events hanya jika butuh gesture khusus (swipe, pinch).


Contoh Praktis

1. Form Validation Real-time

<form id="form-daftar">
  <input type="text" id="nama" placeholder="Nama">
  <span id="error-nama" class="error"></span>

  <input type="email" id="email" placeholder="Email">
  <span id="error-email" class="error"></span>

  <button type="submit">Daftar</button>
</form>

<script>
  const form = document.querySelector("#form-daftar");
  const nama = document.querySelector("#nama");
  const email = document.querySelector("#email");
  const errorNama = document.querySelector("#error-nama");
  const errorEmail = document.querySelector("#error-email");

  nama.addEventListener("input", () => {
    if (nama.value.trim().length < 3) {
      errorNama.textContent = "Nama minimal 3 karakter";
      nama.classList.add("invalid");
    } else {
      errorNama.textContent = "";
      nama.classList.remove("invalid");
    }
  });

  email.addEventListener("input", () => {
    const valid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email.value);
    if (!valid) {
      errorEmail.textContent = "Email tidak valid";
      email.classList.add("invalid");
    } else {
      errorEmail.textContent = "";
      email.classList.remove("invalid");
    }
  });

  form.addEventListener("submit", (e) => {
    e.preventDefault();

    if (nama.value.trim().length < 3 || !email.value.includes("@")) {
      alert("Perbaiki form terlebih dahulu");
      return;
    }

    console.log("Form valid:", { nama: nama.value, email: email.value });
  });
</script>

2. Modal dengan Escape dan Klik di Luar

<button id="btn-buka">Buka Modal</button>
<div id="modal" class="modal hidden">
  <div class="modal-content">
    <h2>Judul Modal</h2>
    <p>Isi modal...</p>
    <button id="btn-tutup">Tutup</button>
  </div>
</div>

<script>
  const modal = document.querySelector("#modal");
  const btnBuka = document.querySelector("#btn-buka");
  const btnTutup = document.querySelector("#btn-tutup");

  function bukaModal() {
    modal.classList.remove("hidden");
  }

  function tutupModal() {
    modal.classList.add("hidden");
  }

  btnBuka.addEventListener("click", bukaModal);
  btnTutup.addEventListener("click", tutupModal);

  // Klik di luar modal (overlay) menutup
  modal.addEventListener("click", (e) => {
    if (e.target === modal) tutupModal();
  });

  // Escape menutup
  document.addEventListener("keydown", (e) => {
    if (e.key === "Escape" && !modal.classList.contains("hidden")) {
      tutupModal();
    }
  });
</script>

3. Infinite Scroll Sederhana

let halaman = 1;
let loading = false;

window.addEventListener("scroll", async () => {
  if (loading) return;

  const { scrollTop, scrollHeight, clientHeight } = document.documentElement;

  // Jika sudah dekat bawah (100px)
  if (scrollTop + clientHeight >= scrollHeight - 100) {
    loading = true;
    halaman++;

    try {
      const data = await fetch(`/api/produk?page=${halaman}`).then(r => r.json());
      renderProduk(data); // fungsi dari artikel DOM
    } finally {
      loading = false;
    }
  }
});

4. Drag and Drop Sederhana

const item = document.querySelector("#item");
let offsetX, offsetY;

item.addEventListener("mousedown", (e) => {
  offsetX = e.clientX - item.getBoundingClientRect().left;
  offsetY = e.clientY - item.getBoundingClientRect().top;

  function onMouseMove(e) {
    item.style.left = (e.clientX - offsetX) + "px";
    item.style.top = (e.clientY - offsetY) + "px";
  }

  function onMouseUp() {
    document.removeEventListener("mousemove", onMouseMove);
    document.removeEventListener("mouseup", onMouseUp);
  }

  document.addEventListener("mousemove", onMouseMove);
  document.addEventListener("mouseup", onMouseUp);
});

Tips & Best Practice

  1. Gunakan addEventListener(), bukan onclick — mendukung banyak listener dan bisa dihapus.

  2. Gunakan event delegation untuk elemen dinamis — satu listener di parent.

  3. preventDefault() untuk mencegah perilaku default (form submit, link navigasi).

  4. Hindari stopPropagation() kecuali perlu — bisa memutus event delegation.

  5. Gunakan { once: true } untuk listener yang hanya perlu jalan sekali.

  6. Debounce/throttle event yang sering (scroll, resize, input) untuk performa:

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

window.addEventListener("resize", debounce(() => {
  console.log("Resized:", window.innerWidth);
}, 200));
  1. Gunakan passive: true untuk event scroll/touchmove jika tidak memanggil preventDefault() — meningkatkan performa.

  2. Bersihkan listener saat elemen dihapus atau komponen di-unmount (terutama di SPA/framework) — mencegah memory leak.

  3. Gunakan DOMContentLoaded untuk manipulasi DOM — lebih cepat dari load.

  4. Cache elemen — jangan querySelector berulang di dalam handler.


Ringkasan

Konsep Poin Penting
addEventListener() Cara modern, banyak listener, bisa dihapus
removeEventListener() Butuh referensi fungsi yang sama
preventDefault() Mencegah perilaku default
stopPropagation() Menghentikan bubbling
Bubbling Event naik dari target ke parent
Capturing Event turun dari parent ke target (capture: true)
Event delegation Satu listener di parent untuk banyak anak
e.target Elemen asal event
e.currentTarget Elemen tempat listener terpasang

Event umum:

  • Mouse: click, dblclick, mousedown, mouseup, mouseover.
  • Keyboard: keydown, keyup.
  • Form: submit, input, change, focus, blur.
  • Window: DOMContentLoaded, load, resize, scroll.

Poin penting:

  • Gunakan addEventListener() — jangan onclick.
  • Event delegation untuk elemen dinamis — satu listener di parent.
  • e.target vs e.currentTarget — pahami perbedaannya.
  • Gunakan { once: true } untuk listener sekali pakai.
  • Debounce/throttle event yang sering (scroll, resize, input).
  • Gunakan DOMContentLoaded untuk manipulasi DOM.
  • Bersihkan listener saat elemen dihapus untuk mencegah memory leak.

Pada artikel berikutnya, kita akan membahas Web Storage & Cookie — menyimpan data di sisi klien.

Top