The event flows from the root to the target element

The event flows from the target element to its ancestors

The event only affects the element that triggered it

The event duplicates itself at each level

Assigning multiple listeners to child elements

Letting a parent handle events from its children

Passing events to external scripts

Preventing event bubbling completely

click on a button

submit on a form

mouseover on a div

keydown on an input

The element that the event is attached to

The root of the DOM

The element where the event originated

The parent element that delegated the event

They are always the same

event.target is where the event started; event.currentTarget is where the handler is attached

event.target refers to parent, event.currentTarget refers to child

event.currentTarget is only available on window

Add a listener to each li manually

Use a loop with setTimeout()

Use event delegation on the ul parent

Wrap the list in a form element

The event flows from the target to the root

The event is canceled before reaching the target

The event flows from the root to the target

The event fires only on form submissions

The event is cloned and canceled

The event continues to bubble but with no default behavior

The event does not bubble and the default action is prevented

The event is detached from the DOM tree

e.preventDefault() is missing

The event listener is on the wrong element

submit events don't bubble

The form is invalid

It won't work if .item elements are added later

forEach doesn't support NodeLists

alert() can't be called from a loop

querySelectorAll attaches listeners globally

this refers to the clicked button

this is the parent div, not the clicked element

e.target should be used instead of this

Both b and c

Listeners are not removed on repeated calls

The element ID is incorrect

Arrow function captures this

Events do not bubble from IDs

preventDefault() must be synchronous to work

e is undefined inside the arrow function

click events can't be delayed

this is incorrect inside the arrow function

handleClick is not defined before usage

onclick does not support functions

The button has a higher z-index

The element with ID btn doesn't exist at the time of assignment

This already uses proper delegation

Move the listener to each .task element

Use e.currentTarget instead of e.target

Stop event propagation before handling

matches doesn't work on event targets

The third argument true enables bubbling

The event listener is in capturing phase

Only anchor tags trigger the click event

Use .onclick instead of addEventListener

Wrap the listener in if (!btn.hasListener)

Remove the previous listener before adding

Declare the handler inline in HTML

The button re-enables itself too quickly

If submitForm throws, button remains disabled

The button disables before the click action finishes

e.preventDefault() should be called

The handler is declared as an arrow function

The element is removed using innerHTML = ''

The listener is bound inside a closure and never removed

The event is passive and doesn’t clean itself up

The event listener is too generic

Scroll events fire on document, not body

Scroll events are not throttled or debounced

this inside the function is undefined

Use e.preventDefault() on both events

Track timestamps and ignore one

Use setTimeout() with cancelation logic in click

Bind click only on single clicks using e.detail === 1

The pointer is released outside the element

The element is display: none

pointerdown cancels the click

Pointer events never trigger clicks

To cancel default behavior more aggressively

To prevent other listeners on the same element from firing

To ensure event delegation fails

To block async event chains

Non-button elements inside <button> may trigger it

tagName can be lowercase on some browsers

Buttons may be shadow DOM elements

Events fired from SVG buttons won’t match

ticking is not declared as const

requestAnimationFrame can run before scroll completes

The scroll handler re-enters before ticking resets

The scroll event listener should be passive

It prevents bubbling needed for delegation

It stops other children from receiving the event

It cancels e.preventDefault()

It disables the capturing phase

The handler is removed after one invocation

The event fires twice, then is ignored

It blocks preventDefault()

The event skips bubbling

Shadow DOM elements do not bubble to the main DOM by default

matches() doesn't work on shadow DOM elements

click events are not allowed in shadow roots

e.currentTarget should be used instead of e.target

a)

document.getElementById("myForm").addEventListener("submit", => {
  e.preventDefault();
});

b)

document.getElementById("myForm").onsubmit = () => true;

c)

document.getElementById("myForm").addEventListener("click", => {
  e.preventDefault();
});

d)

document.getElementById("myForm").submit();

document.querySelectorAll(".btn").forEach(btn => {
  btn.addEventListener("click", () => alert("Clicked"));
});

document.getElementById("container").addEventListener("click", => {
  if(e.target.classList.contains("btn")) alert("Clicked");
});

document.querySelector("button").onclick = () => alert("Clicked");

document.addEventListener("click", () => alert("Clicked"));

a)

document.getElementById("link").addEventListener("click", => {
  setTimeout(() => e.preventDefault(), 100);
});

b)

document.getElementById("link").addEventListener("click", => {
  e.preventDefault();
});

c)

document.getElementById("link").onclick = () => false;

d)

document.getElementById("link").addEventListener("click", () => {
  return false;
});

a)

items.forEach(item => item.addEventListener("click", handler));

b)

document.body.addEventListener("click", => {
  if (e.target.matches(".item")) handler(e);
});

c)

window.addEventListener("click", () => {});

d)

items.forEach(item => item.onclick = handler);

button.addEventListener("click", function() {
  console.log(this.textContent);
});

button.addEventListener("click", () => {
  console.log(event.target.textContent);
});

button.addEventListener("click", => {
  console.log(e.currentTarget.textContent);
});

button.onclick = () => console.log(this.textContent);

btn.removeEventListener("click", handler);
btn.addEventListener("click", handler);

btn.onclick = handler;

btn.addEventListener("click", handler, { once: true });

// No fix needed

window.addEventListener("keydown", => {
  if (e.key === " " || e.code === "Space") e.preventDefault();
});

window.addEventListener("keypress", => {
  if (e.key === "Spacebar") e.preventDefault();
});

window.addEventListener("keyup", => {
  if (e.key === "Space") e.preventDefault();
});

window.addEventListener("keydown", => {
  if (e.code === "KeySpace") e.preventDefault();
});

shadowRoot.addEventListener("click", handler);

document.body.addEventListener("click", handler);

shadowRoot.querySelector("button").addEventListener("click", handler);

document.addEventListener("shadowclick", handler);

button.addEventListener("click", handler);
button.addEventListener("dblclick", handler);

button.addEventListener("click", handler, { once: true });

button.removeEventListener("click", handler);

button.addEventListener("click", () => {
  setTimeout(handler, 200);
});

element.addEventListener("click", => {
  e.stopPropagation();
});

element.addEventListener("click", => {
  e.preventDefault();
});

element.addEventListener("click", => {
  e.stopImmediatePropagation();
});

element.addEventListener("click", => {
  e.stopPropagation();
  e.preventDefault();
});

Promises run synchronously

Microtasks run after the current call stack finishes

console.log inside Promise runs before event handler

Event listeners always run after promises

button.disabled = true;
await doSomething();
button.disabled = false;

doSomething().then(() => console.log("done"));

setTimeout(() => console.log("done"), 0);

button.addEventListener("click", () => console.log("done"));

let timeout;
button.addEventListener("click", () => {
  clearTimeout(timeout);
  timeout = setTimeout(() => doAsyncStuff(), 300);
});

button.addEventListener("click", () => doAsyncStuff());

c)

button.addEventListener("click", () => {
  if (!button.disabled) doAsyncStuff();
});

button.addEventListener("click", async () => {
  await doAsyncStuff();
});

The event object is lost inside the promise

The default action happens before microtasks

Promises block the event loop

preventDefault() must be called synchronously

It stops propagation immediately

It throws an error

It has no effect because propagation already happened

It delays propagation stopping until the callback finishes

sync → promise → timeout

promise → timeout → sync

timeout → promise → sync

sync → timeout → promise

input.addEventListener("input", async => {
  const valid = await validate(e.target.value);
  if (!valid) alert("Invalid");
});

input.addEventListener("input", => {
  validate(e.target.value).then(valid => {
    if (!valid) alert("Invalid");
  });
});

input.addEventListener("input", => {
  while(!validateSync(e.target.value)) {}
});

input.addEventListener("input", => {
  setTimeout(() => validate(e.target.value), 0);
});

Changing value triggers another input event

.toUpperCase() is async

Event listeners can only run once

e.target.value cannot be reassigned

Async listeners pause event propagation

Async listeners delay next event handler until await completes

Async listeners return a promise ignored by the event system

Async listeners block UI rendering until resolved

Promise.all([p1, p2]).then(() => console.log("both done"));

p1.then(() => p2.then(() => console.log("both done")));

setTimeout(() => console.log("both done"), 0);

fetch("/api/one").then(() => fetch("/api/two")).then(() => console.log("both done"));