JavaScript Interview Questions

What should you focus on for a JavaScript interview?

Which basics should you check first?

The most asked question compared var, let, and const. It appeared in 20 of 172 interviews. Use it to check more than whether you remember the names:

• Can you compare their scope and reassignment rules?
• Can you separate hoisting from initialization?
• Can you explain the temporal dead zone?

Reviews found answers that did not clearly separate hoisting from initialization: var starts as undefined, while let and const stay inaccessible until initialized. Make that difference clear in your answer.

Also check whether you can explain == versus === and when you would use each. For closures, can you explain how a function keeps access to outer variables?

How clearly can you explain async code?

Async and the event loop was the most common topic in these interviews, appearing in 60 of 172 interviews. Check whether your answer covers both the runtime and the order in which code runs.

Reviews found answers that left out how the browser or runtime handles asynchronous operations and queues callbacks for later execution. Answers about execution order also missed a key sequence: synchronous code finishes first, then the microtask queue drains before the next timer task runs.

Can you use that sequence to explain the order of code with promises, timers, and await continuations? Can you explain what a callback is and when you would use a promise?

What coding tasks can you try?

Coding tasks appeared in 17 of 172 interviews. Try these tasks from the interviews:

• Return the first repeating character in a string.
• Write a function that checks for a palindrome.
• Write a binary search implementation in JavaScript.
• Select objects from an array whose score is greater than 45.

The arrays and coding topic also covers time and space complexity. After writing your code, can you explain how its running time and memory use change as the input grows?

What should you check beyond core JavaScript?

React, Redux, and RxJS appeared in 38 of 172 interviews. Can you explain what Redux is, how components share state, and what hooks do?

Use the other topics to check specific gaps:

• Browser: can you explain how you would change the DOM and handle an event?
• Performance: can you explain debouncing and throttling?
• Testing: can you describe how you would debug a test and check edge cases?

The page also has questions on Node.js, TypeScript, memory leaks, and reusable application design.

Who gets asked JavaScript

The 20 most asked JavaScript questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. How do var, let, and const differ in scope, reassignment, hoisting, and the temporal dead zone?

   Asked in 20 of 172 interviews · last asked Oct 8 · Concept · Junior

   Show answer

   Inside functions, `var` is function-scoped; `let` and `const` are block-scoped. `var` and `let` allow reassignment; `const` does not. All three are hoisted, but only `var` starts as `undefined`. `let` and `const` remain inaccessible in the temporal dead zone until initialization.

   • At the top level, `var` is global in scripts but module-scoped in modules.
   • `const` prevents reassignment, not changes to an object's properties or an array's contents.
   • `var` allows repeated declarations; `let` and `const` cannot be redeclared in the same scope.
   • Prefer `const`; use `let` when reassignment is needed. Avoid `var` in new code.

   JavaScriptCopy

   console.log(a); // undefined
   var a = 1;
   try {
     console.log(b);
   } catch (error) {
     console.log(error.name); // ReferenceError
   }
   let b = 2;
   const item = { value: 1 };
   item.value = 2; // Allowed: item still refers to the same object.

   What the interviewer checks: The interviewer checks whether you understand scope, binding changes, and access before initialization.

   Common mistake (in 4 of 9 reviewed answers): Many answers forget that hoisting is not initialization: `let` and `const` are hoisted but cannot be accessed before initialization.

   Other ways it was asked

   • “What is the difference between var, let, and const in JavaScript?”
   • “What is the difference between var, let, and const?”
   • “In JavaScript, can you differentiate between let, var, and const?”

2. How does the JavaScript event loop work?

   Asked in 16 of 172 interviews · last asked Oct 8 · Concept · Mid-level

   Show answer

   The event loop coordinates when queued JavaScript callbacks run. Synchronous code runs on the call stack, while the browser or Node.js runtime handles asynchronous operations and queues callbacks when ready. Queued callbacks run only when the stack is empty. Promise microtasks run before the next task, such as a timer callback.

   • Long-running synchronous code blocks other callbacks from running.
   • Microtasks include Promise handlers and queueMicrotask callbacks; newly added microtasks also run before the next task.
   • A timer delay is a minimum wait, not a guaranteed execution time.
   • Node.js uses event loop phases for timers and I/O, plus a separate process.nextTick queue.

   JavaScriptCopy

   console.log('start');
   setTimeout(() => console.log('timer'), 0);
   Promise.resolve().then(() => console.log('promise'));
   console.log('end');
   // Output: start, end, promise, timer

   What the interviewer checks: The interviewer checks whether you can explain callback scheduling and predict execution order.

   Common mistake (in 4 of 6 reviewed answers): Many answers forget that the runtime handles asynchronous work and queues callbacks to run after the call stack is empty.

   Other ways it was asked

   • “What is the event loop in JavaScript?”
   • “Can you explain the event loop?”
   • “What does the event loop do in Node.js?”

3. What is the difference between == and === in JavaScript, and when would you use each?

   Asked in 12 of 172 interviews · last asked Sep 29 · Concept · Junior

   Show answer

   === compares values without converting their types. == may convert types before comparing, so values of different types can be equal. Use === by default for predictable comparisons. Use == only when you want its conversion rules, such as value == null to check for null or undefined.

   • === returns false when the operands have different types.
   • == can produce surprising results, such as 0 == false being true.
   • Both operators compare objects by reference, not by their contents.
   • NaN is not equal to itself with either operator.

   JavaScriptCopy

   console.log(5 == "5");         // true
   console.log(5 === "5");        // false
   console.log(null == undefined);  // true
   console.log(null === undefined); // false

   What the interviewer checks: The interviewer is checking whether you understand type conversion and can choose comparisons that avoid unexpected results.

   Other ways it was asked

   • “What is the difference between == and === in JavaScript?”
   • “What is the difference between `==` and `===` in JavaScript?”
   • “When would you use ==, and when would you use ===?”

4. What is a closure in JavaScript, and how does it retain access to outer variables?

   Asked in 12 of 172 interviews · last asked Oct 15 · Concept · Junior

   Show answer

   A closure is a function together with access to variables from its outer scope. JavaScript keeps this access based on where the function was created, even after the outer function finishes. It retains access to the variables, not copies of their values.

   • Closures follow lexical scope: where a function is created determines which outer variables it can access.
   • An inner function can read and update outer variables after the outer function returns.
   • Closures are useful for private state, callbacks, and function factories.

   JavaScriptCopy

   function makeCounter() {
     let count = 0;
     return function () {
       return ++count;
     };
   }
   const counter = makeCounter();
   console.log(counter()); // 1
   console.log(counter()); // 2

   What the interviewer checks: The interviewer checks whether you understand lexical scope and how functions keep access to outer variables.

   Other ways it was asked

   • “What is a closure in JavaScript?”
   • “Why are closures used in JavaScript?”
   • “What is a closure in JavaScript, and how does it work?”

5. What is hoisting in JavaScript, and how does it affect var, let, and const?

   Asked in 10 of 172 interviews · last asked Oct 21 · Concept · Junior

   Show answer

   Hoisting means JavaScript sets up declarations before running code in their scope; it does not move the code. A var variable starts as undefined, so you can read it before its declaration. let and const are also hoisted, but reading them before their declarations run throws a ReferenceError. This waiting period is called the temporal dead zone.

   • var has function, module, or global scope; let and const have block scope.
   • Initializers run where they appear in the code, not during hoisting.
   • const must have an initializer in a normal declaration and cannot be reassigned.

   JavaScriptCopy

   console.log(count); // undefined
   var count = 3;
   
   {
     console.log(total); // ReferenceError: temporal dead zone
     let total = 5;
   }

   What the interviewer checks: The interviewer checks whether you can explain scope, initialization, and access before a declaration.

   Other ways it was asked

   • “What is hoisting in JavaScript?”
   • “What is hoisting?”
   • “Tell me about hoisting in JavaScript.”

6. How do microtasks, timers, and await continuations run relative to synchronous code in the JavaScript event loop?

   Asked in 10 of 172 interviews · last asked Oct 8 · Concept · Senior

   Show answer

   Synchronous code finishes first, then microtasks drain before the next timer callback. Promise handlers run as microtasks when their promises settle. An await pauses its async function, and its continuation runs as a microtask, even for an already fulfilled promise.

   • Microtasks added while draining also run before the next timer; repeated microtasks can delay timers and I/O.
   • A timer delay is a minimum wait, not a guaranteed execution time.
   • Node.js process.nextTick uses a separate queue, usually drained before promise microtasks; ES modules can differ.
   • Node.js setImmediate runs in the check phase; its order against setTimeout depends on context.

   JavaScriptCopy

   console.log('start');
   setTimeout(() => console.log('timer'), 0);
   (async () => {
     await Promise.resolve();
     console.log('await');
   })();
   Promise.resolve().then(() => console.log('then'));
   console.log('end');
   // Output: start, end, await, then, timer

   What the interviewer checks: The interviewer checks whether you can predict execution order and explain how microtasks can delay other work.

   Common mistake (in 3 of 6 reviewed answers): Many answers forget that synchronous code finishes first and queued microtasks drain before the next timer callback.

   Other ways it was asked

   • “In Node.js, what's the practical difference between the event loop's microtask queue (Promises and queueMicrotask) and macrotask queue (setTimeout and setImmediate), and when would you choose one over the other?”
   • “In Node.js, what's the difference between the microtask queue (promises and process.nextTick) and the macrotask queue (setTimeout and setImmediate), and how can this affect production latency?”
   • “In JavaScript's event loop, how do microtasks (promises) and macrotasks (setTimeout) differ in scheduling, and what's the practical impact on execution order?”

7. What is JavaScript?

   Asked in 8 of 172 interviews · last asked Sep 24 · Concept · Junior

   Show answer

   JavaScript is a programming language used to make web pages interactive. It handles user actions, updates page content, and requests data without reloading the page. It also runs outside browsers, such as on servers using Node.js.

   • HTML defines page structure, CSS controls appearance, and JavaScript adds behavior.
   • JavaScript is dynamically typed: values have types, but variables are not fixed to one type.
   • JavaScript and Java are different languages.

   What the interviewer checks: The interviewer is checking whether you understand JavaScript’s role on the web and where else it runs.

   Other ways it was asked

   • “What is JavaScript? Explain it.”
   • “What is JavaScript, and why is it used?”

8. What is a callback function in JavaScript?

   Asked in 7 of 172 interviews · last asked Sep 30 · Concept · Junior

   Show answer

   A callback is a function passed to another function so that it can call it. Callbacks let you provide code to run during an operation or after it finishes. They can run immediately, like callbacks in array methods, or later, like timer callbacks.

   • Pass the function itself, rather than calling it and passing its result.
   • Callbacks can be synchronous or asynchronous.
   • Common uses include array methods, event handlers, and handling results from asynchronous operations.

   JavaScriptCopy

   function greet(name, callback) {
     callback(`Hello, ${name}`);
   }
   
   greet("Sam", (message) => {
     console.log(message); // Hello, Sam
   });

   What the interviewer checks: The interviewer is checking whether you understand passing functions as values and know that callbacks are not always asynchronous.

   Other ways it was asked

   • “Can you explain what a callback function is?”
   • “What is a callback function?”
   • “What is a callback function used for in JavaScript?”

9. What is a JavaScript promise, and when would you use one?

   Asked in 7 of 172 interviews · last asked Oct 5 · Concept · Junior

   Show answer

   A JavaScript Promise is an object that represents the eventual result of an operation, usually asynchronous. It starts pending, then becomes fulfilled with a value or rejected with a reason. I use promises for tasks like network requests, so I can handle results and errors without blocking other code.

   • Once fulfilled or rejected, a promise cannot change its state or result.
   • Use .then() for success, .catch() for errors, and .finally() for cleanup.
   • These methods return new promises, so you can chain operations.
   • Async functions can use await to read promise results and try/catch to handle rejections.

   What the interviewer checks: The interviewer checks whether you understand asynchronous results, promise states, and error handling.

   Other ways it was asked

   • “What is a promise?”
   • “What is a JavaScript Promise, and how does it work?”
   • “What is a JavaScript Promise used for, and when would you use one?”

10. How does the DOM work in JavaScript?

    Asked in 7 of 172 interviews · last asked Sep 7 · Concept · Junior

    Show answer

    The DOM (Document Object Model) is an object tree that represents a web page. JavaScript uses browser APIs to read and change this tree, update styles, and handle events. These changes can update the page without reloading it.

    • Elements and text are nodes in the tree.
    • The document object is the main entry point for accessing the page.
    • JavaScript can find, create, change, and remove nodes.
    • The DOM is a browser API, not part of the JavaScript language itself.

    JavaScriptCopy

    // Run after the page's body exists.
    const message = document.createElement('p');
    message.textContent = 'Hello!';
    document.body.appendChild(message);

    What the interviewer checks: The interviewer checks whether you understand how JavaScript reads and changes a web page through the DOM.

    Other ways it was asked

    • “What is the DOM?”
    • “What is the DOM, and what is it used for in JavaScript?”
    • “What is the DOM used for in JavaScript?”

11. What is Redux?

    Asked in 7 of 172 interviews · last asked Oct 15 · Concept · Junior

    Show answer

    Redux is a JavaScript library for managing shared application state in a central store. You dispatch actions to describe changes, and reducers calculate the next state. With React, React Redux connects components to the store. Redux Toolkit is the recommended way to write Redux logic with less code.

    • Redux works with React, but it can also be used without React.
    • Reducers must be pure and must not mutate existing state.
    • Redux Toolkit uses Immer so you can write updates that look like mutations but produce immutable state.
    • Redux helps with complex shared state; local component state is often enough for simpler needs.

    What the interviewer checks: The interviewer checks whether you understand Redux’s data flow, its role with React, and when it is useful.

    Other ways it was asked

    • “Can you explain what Redux does?”
    • “What is Redux, and how does it help manage application state?”
    • “What is Redux, and how is it used with React?”

12. How do CommonJS require and ES module import differ?

    Asked in 7 of 172 interviews · last asked Oct 19 · Concept · Junior

    Show answer

    `require()` is CommonJS syntax and loads modules synchronously; CommonJS exports use `module.exports`. ES modules use `import` and `export`; static imports are processed before the module runs. You can call `require()` conditionally, but static `import` must be at the top level. Dynamic `import()` works in both systems and returns a promise.

    • In Node.js, `.cjs` means CommonJS, while `.mjs` means ES modules.
    • For `.js` files, the nearest package.json's `type` field can explicitly select the module system.
    • Static imports help build tools analyze dependencies and remove unused code through tree shaking.
    • Recent Node.js versions can require ES modules only if their dependency graph has no top-level `await`.

    What the interviewer checks: The interviewer checks whether you understand module syntax, loading behavior, and Node.js module support.

    Other ways it was asked

    • “What is the difference between require and import in Node.js?”
    • “Could you clarify the syntax differences between require and import, and explain how their loading mechanisms affect module behavior in Node.js?”
    • “What is the difference between `require` and `import` in Next.js?”

13. What is the difference between Java and JavaScript?

    Asked in 6 of 172 interviews · last asked Jul 2 · Concept · Junior

    Show answer

    Java and JavaScript are different programming languages, despite their similar names. Java uses static types and usually runs on the Java Virtual Machine (JVM). JavaScript uses dynamic types and runs in browsers or runtimes like Node.js. I would use Java for many backend or Android projects, and JavaScript for interactive web pages or Node.js backends.

    • Java checks types before execution; JavaScript checks types at runtime.
    • Java uses class-based inheritance; JavaScript uses prototype-based inheritance, even with class syntax.
    • Both can run on servers; JavaScript is the standard language for browser scripting.

    What the interviewer checks: The interviewer is checking whether you can distinguish their type systems, runtimes, and common uses.

    Other ways it was asked

    • “What is the difference between Java and JavaScript, and when would you use each?”
    • “What is the difference between JavaScript and Java?”

14. When would you use Promise.all, Promise.allSettled, or sequential awaits, and how would you handle failures?

    Asked in 6 of 172 interviews · last asked Oct 7 · Concept · Mid-level

    Show answer

    Use `Promise.all` for independent operations when you need every result. Use `Promise.allSettled` when partial success is useful and you need every outcome. Use sequential awaits when operations depend on earlier results or must run one at a time. Catch rejections from `Promise.all` and sequential awaits; with `Promise.allSettled`, inspect each result and handle failures individually.

    • `Promise.all` rejects on the first rejection, but does not cancel other operations.
    • `Promise.allSettled` waits for every operation and returns fulfilled values or rejection reasons.
    • Both return results in input order, not completion order.
    • For sequential execution, start each operation after the previous one finishes; awaiting already-started promises does not serialize them.

    What the interviewer checks: The interviewer checks whether you can choose concurrency based on dependencies and handle partial or complete failure.

    Other ways it was asked

    • “What is the difference between Promise.all and Promise.allSettled?”
    • “When you have multiple independent API calls, how do you decide between Promise.all, Promise.allSettled, and sequential awaits?”
    • “When you write an async function that awaits multiple API calls, how do you decide between running them sequentially versus in parallel with Promise.all? And how do you handle partial failures?”

15. What’s the difference between null and undefined?

    Asked in 5 of 172 interviews · last asked Sep 2 · Concept · Junior

    Show answer

    In JavaScript, `undefined` usually means a variable has no assigned value or a property is missing. `null` is normally set on purpose to mean “no value.” Both are primitive values, but they have different types.

    • You can also explicitly assign `undefined`; it is not only produced automatically.
    • `typeof undefined` returns `"undefined"`; `typeof null` returns `"object"` because of a historical JavaScript bug.
    • `null == undefined` is true, but `null === undefined` is false.

    What the interviewer checks: The interviewer is checking whether you understand missing values, intentional absence, and JavaScript’s type and equality rules.

    Other ways it was asked

    • “What is the difference between null and undefined?”
    • “What is the difference between null and undefined in JavaScript?”
    • “What is the difference between undefined and null?”

16. What does TypeScript add to JavaScript, and what benefits does it provide?

    Asked in 5 of 172 interviews · last asked Aug 25 · Concept · Junior

    Show answer

    TypeScript adds static type checking to JavaScript, with features like type annotations, interfaces, and generics. It catches many type errors before code runs and improves autocomplete, code navigation, and refactoring. TypeScript compiles to JavaScript, so its types do not check data at runtime.

    • Type inference often checks types without explicit annotations.
    • Type definitions make function inputs and outputs clearer.
    • Editor tools use types to suggest code and help rename symbols safely.
    • Static checks do not replace tests or runtime validation of external data.

    What the interviewer checks: The interviewer is checking whether you understand static typing, tooling benefits, and the limits of compile-time checks.

    Other ways it was asked

    • “Why use TypeScript, and what benefits does it offer?”
    • “Can you explain why TypeScript is useful and what tooling it adds?”
    • “What does TypeScript add on top of JavaScript, and what tooling benefits does it provide?”

17. What is the temporal dead zone, and how does it differ from accessing a hoisted var?

    Asked in 4 of 172 interviews · last asked Sep 29 · Concept · Mid-level

    Show answer

    The temporal dead zone is the time from entering a scope until a `let` or `const` binding is initialized. Accessing it during this time throws a `ReferenceError`. A hoisted `var` starts as `undefined`, so reading it before any assignment returns `undefined`.

    • `let` and `const` are hoisted, but remain uninitialized during the temporal dead zone.
    • Even `typeof` throws a `ReferenceError` for a variable in its temporal dead zone.
    • A `let` declaration without an initializer sets the variable to `undefined` when that declaration runs.

    JavaScriptCopy

    console.log(a); // undefined
    var a = 1;
    
    console.log(b); // ReferenceError: b is in its temporal dead zone
    let b = 2;

    What the interviewer checks: The interviewer is checking whether you distinguish hoisting from initialization and know when variable access throws an error.

    Other ways it was asked

    • “How would you explain the practical difference between a hoisted var being initialized to undefined and the temporal dead zone for let and const?”
    • “How does the temporal dead zone affect access to a `let` or `const` variable before its declaration?”
    • “What is the temporal dead zone?”

18. What is the difference between debouncing and throttling?

    Asked in 4 of 172 interviews · last asked Oct 8 · Concept · Junior

    Show answer

    Debouncing groups repeated calls into one, usually after calls stop for a set time. Throttling limits how often a function runs while calls keep coming. Debouncing helps when you want the final input; throttling helps when you need regular updates.

    • A typical debounce resets its timer on every call.
    • Use debounce for search input and throttle for scroll updates.
    • Both can support running at the start or end of a waiting period, depending on the implementation.

    What the interviewer checks: The interviewer wants to know whether you can choose the right way to control frequent events.

    Other ways it was asked

    • “What is the difference between debounce and throttle?”

19. How is this determined in regular functions, method calls, and arrow functions?

    Asked in 3 of 172 interviews · last asked Aug 11 · Concept · Mid-level

    Show answer

    For a regular function, `this` depends on how it is called. A plain call gives `undefined` in strict mode, or `globalThis` in non-strict mode. In `obj.method()`, `this` is `obj`. An arrow function gets `this` from its surrounding scope; calling it as a method does not change it.

    • Calling an extracted method as a plain function loses its original object as `this`.
    • `call`, `apply`, and `bind` can set `this` for regular functions.
    • Arrow functions have no own `this`; `call`, `apply`, and `bind` cannot change it.

    JavaScriptCopy

    "use strict";
    function readThis() { return this; }
    const obj = {
      readThis,
      makeArrow() { return () => this; }
    };
    console.log(readThis()); // undefined
    console.log(obj.readThis() === obj); // true
    const arrow = obj.makeArrow();
    console.log(arrow.call({}) === obj); // true

    What the interviewer checks: The interviewer checks whether you distinguish call-based `this` in regular functions from scope-based `this` in arrow functions.

    Other ways it was asked

    • “What does `this` refer to in JavaScript?”
    • “How is `this` determined in JavaScript for a regular function call, a method call, and an arrow function?”
    • “In strict mode, what does `this` evaluate to inside a regular function call, and how does that differ from an arrow function?”

20. Is JavaScript single-threaded or multithreaded, and how does it handle asynchronous work?

    Asked in 3 of 172 interviews · last asked Aug 25 · Concept · Mid-level

    Show answer

    JavaScript runs one piece of code at a time on each thread. Browsers and Node.js handle asynchronous operations, such as timers and network requests. The event loop lets queued callbacks run when the call stack is empty. Workers allow JavaScript to run on separate threads.

    • Asynchronous work does not mean JavaScript callbacks run in parallel on the same thread.
    • Promise callbacks run as microtasks, before the next task, such as a timer callback.
    • Long synchronous code blocks that thread, delaying queued callbacks.

    What the interviewer checks: The interviewer checks whether you can separate JavaScript execution from runtime-managed asynchronous work and explain the event loop.

    Other ways it was asked

    • “JavaScript is single-threaded, so how does it handle asynchronous tasks?”
    • “Is JavaScript single-threaded or multithreaded?”

Live coding round next? Coding mode in the MeetAssist desktop app solves the problem on your screen, with your phone as the remote.

Related interview questions

• Software Engineer interview questions
• QA Engineer interview questions
• Cybersecurity interview questions
• Python interview questions
• Java interview questions
• TypeScript interview questions
• C# and .NET interview questions
• C++ interview questions
• PHP and Laravel interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every JavaScript interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

172 interviews, 132 candidates, Nov 2025 to Oct 2026. Updated every month with new interviews.