Debounce delays a function until calls stop for wait ms — every new call resets the timer.

The implementation

function debounce(fn, wait) {
  let timeoutId;                          // closure-held timer id

  return function (...args) {
    clearTimeout(timeoutId);              // cancel any pending call
    timeoutId = setTimeout(() => {
      fn.apply(this, args);               // run later, preserving this + args
    }, wait);
  };
}

How it works:

1. debounce returns a new function that closes over timeoutId.
2. Each call clears the previous pending timeout and schedules a new one.
3. fn only fires when calls stop for wait ms — every call within the window pushes it back.
4. fn.apply(this, args) forwards the call context and arguments correctly.

Usage

const onResize = debounce(() => console.log("resized"), 200);
window.addEventListener("resize", onResize);

const search = debounce((q) => fetchResults(q), 300);
input.addEventListener("input", (e) => search(e.target.value));

Add a cancel method (the senior touch)

Important so you can clean up a pending call (e.g. on React unmount):

function debounce(fn, wait) {
  let timeoutId;
  function debounced(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => fn.apply(this, args), wait);
  }
  debounced.cancel = () => clearTimeout(timeoutId);
  return debounced;
}

Things to get right (and mention)

• this / arguments — use a regular function + apply, not an arrow, so the caller's this is preserved. (...args captures arguments.)
• Closure — timeoutId must persist across calls; it lives in the closure, one per debounced function.
• cancel() — needed for cleanup.
• Optional extensions: a leading option (fire on the first call, then debounce), trailing (the default), or returning the result via a promise.

Debounce vs throttle (clarify if asked)

• Debounce — runs once after calls stop. Search input, autosave, resize-settled.
• Throttle — runs at most once per interval during continuous calls. Scroll, mousemove, drag.

How to answer

"Return a function that closes over a timer id; each call clears the pending timeout and sets a new one, so fn runs only after calls quiet down for wait ms. Use a regular function with apply to preserve this and arguments, and attach a cancel method so a pending call can be cleared on cleanup."