JavaScript Coding Interview Questions With Solutions

The JavaScript questions that interviewers ask most often test the language itself, not algorithms: hoisting, this binding, the event loop, closures, and a few array utilities written by hand. The twelve questions below cover that set, grouped by topic, each with a solution short enough to write on a whiteboard. Read the question, write your own answer first, then compare. In an interview the code is the smaller part of the answer, and the explanation of why it works is what is graded.

Language fundamentals

1. What does this print, and why? The question tests hoisting, which is the way JavaScript moves declarations to the top of their scope before running the code.

console.log(a); // undefined, var is hoisted and set to undefined
var a = 1;
console.log(b); // ReferenceError, b exists but cannot be read yet
let b = 2;

A var declaration is hoisted with the value undefined, so the first line prints without error. A let or const declaration is also hoisted, but it cannot be read before its line runs, and that gap is called the temporal dead zone.

2. What is this inside a regular function and inside an arrow function?

const user = {
  name: "Ada",
  regular() { return this.name; },
  arrow: () => this.name,
};
user.regular();              // "Ada"
user.arrow();                // undefined, arrow functions take this from outside
const detached = user.regular;
detached.call(user);         // "Ada", call sets this explicitly

A regular function receives this from how it is called. An arrow function has no this of its own and uses the one from the scope where it was written.

3. Reverse a string without built-in helpers. No split, reverse, or join.

function reverse(str) {
  let out = "";
  for (let i = str.length - 1; i >= 0; i--) out += str[i];
  return out;
}
reverse("abc"); // "cba"

The usual follow-up is about emoji, which occupy two positions and get split by this loop.

Asynchronous JavaScript

4. In what order do these lines print? The question tests the event loop, which is the scheduler that runs callbacks after the current code finishes.

console.log("start");
setTimeout(() => console.log("timeout"), 0);
Promise.resolve().then(() => console.log("promise"));
console.log("end");
// start, end, promise, timeout

Synchronous code runs first. Promise callbacks go in the microtask queue, which is emptied before any timer callback runs, so "promise" prints before "timeout".

5. Write Promise.all by hand. It takes an array of promises and resolves with their results in the same order, or rejects on the first failure.

function promiseAll(promises) {
  return new Promise((resolve, reject) => {
    const results = new Array(promises.length);
    let remaining = promises.length;
    if (remaining === 0) return resolve(results);
    promises.forEach((p, i) => Promise.resolve(p).then((value) => {
      results[i] = value;
      if (--remaining === 0) resolve(results);
    }, reject));
  });
}

Writing to results[i] rather than pushing keeps the order stable, because promises can finish in any sequence.

6. Write a debounce function. Debouncing delays a call until the caller has been quiet for a set time, which is how search boxes avoid one request per keystroke.

function debounce(fn, waitMs) {
  let timer;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), waitMs);
  };
}
const onResize = debounce(() => console.log("resized"), 300);