JavaScript interview
questions for freshers

JavaScript is the most-used language among professional developers in Stack Overflow's 2025 survey, alongside HTML and CSS.⁵ Every front-end framework — React, Angular, Vue — and Node.js on the server is JavaScript underneath, so interviewers test the language first. Candidates who know a framework but not closures, this or the event loop rarely pass the first technical round.

The jobs these fundamentals open are plentiful in India: AmbitionBox lists about 68,600 front-end developer salaries alone, with typical pay of ₹6.1–6.7 lakh in October 2026.⁶

JavaScript's rank among most-used languages by professional developers (Stack Overflow, 2025)

#1

Typical front-end developer pay in India (AmbitionBox, Oct 2026)

₹6.1–6.7 lakh

Front-end developer salaries on AmbitionBox

~68,600

Where JavaScript fundamentals are tested

1st round

Table: How JavaScript is tested in interviews (editorial summary)

MDN's JavaScript Guide is the best free reference,¹ and the ECMAScript specification is the final word when behaviour is surprising.⁴

A favourite fresher task: "Write a debounce function."

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

const onSearch = debounce((q) => console.log("search", q), 300);

What to say: the returned function closes over timer, so every call shares it; each call cancels the previous timer, so fn runs only after 300 ms of quiet; apply preserves this and arguments. Then mention edge cases — a leading-edge option, cancelling, and why it's useful for search boxes and resize events.

"What prints: for (var i = 0; i < 3; i++) setTimeout(() => console.log(i));"

3, 3, 3 — var is shared across iterations and the callbacks run after the loop ends. With let, it prints 0, 1, 2 because each iteration gets a new binding.

"Explain hoisting."

Declarations are processed before code runs: var declarations are hoisted and initialised to undefined; function declarations are hoisted fully; let and const are hoisted but not initialised (temporal dead zone).

"What's the output order of a setTimeout(0) and a resolved promise?"

The promise callback first — microtasks run before the next macrotask.

"Difference between map, forEach, filter and reduce?"

map returns a new array of transformed items; forEach just iterates; filter returns items that pass a test; reduce combines items into one value.

"How do you copy an object?"

Spread or Object.assign for shallow copies; structuredClone for deep copies of plain data.

"What is event delegation?"

Attaching one listener to a parent and using event.target to handle events from many children — efficient and works for elements added later.

"Why use async/await over .then()?"

It reads like synchronous code and makes try/catch error handling simpler; underneath it's still promises.

"What is a pure function?"

One that returns the same output for the same input and has no side effects — easier to test and reason about.

Table: How JavaScript interview expectations have changed (editorial summary)

1. Output drills — Fifty output-prediction snippets on scope, this and the event loop; explain each aloud.
2. Utility functions — Write debounce, throttle, deep clone, flatten and a simple promise pool from scratch.
3. A vanilla app — Build a filterable list with fetch, loading and error states, and event delegation — no framework.
4. Async race — Build a search that ignores out-of-order responses using AbortController.
5. Read the spec once — Look up one surprising behaviour in the ECMAScript specification.

Table: JavaScript-based roles and typical pay in India (AmbitionBox, October 2026; indicative)

1. Week 1: Language core — Scope, types, functions, closures, this.
2. Week 2: Data and modules — Arrays, objects, destructuring, spread, ES modules.
3. Week 3: Async and DOM — Promises, async/await, event loop, fetch, events.
4. Week 4: Practice and proof — Output drills and small tasks; take the JavaScript Fundamentals Certification.

Next: the TypeScript test, the HTML and CSS test and React Developer Assessment; our guides on front-end and Node.js jobs show where they lead.

• Debugging async bugs — race conditions between API calls, stale state and unhandled promise rejections.
• Reading framework code — understanding what React, Angular or Vue does with your functions and closures.
• Performance work — avoiding unnecessary work on the main thread and in event handlers.
• Browser APIs — fetch, storage, events and observers used directly or through libraries.
• Code review — catching == comparisons, accidental mutation and this-binding mistakes.
• Utilities — writing small, well-tested helpers instead of pulling in large libraries.

"What is the difference between null and undefined?"

undefined means a variable was declared but not assigned (or a missing property); null is an intentional "no value". typeof null is "object" for historical reasons.

"What does the spread operator do?"

It expands arrays or objects into individual elements or properties — useful for copying, merging and passing arguments. Copies are shallow.

"What is a higher-order function?"

A function that takes or returns another function, such as map, filter or a debounce wrapper.

"How do you handle errors with async/await?"

Wrap awaits in try/catch, handle rejections close to where you can act on them, and use Promise.allSettled when partial failure is acceptable.

"What is the difference between call, apply and bind?"

call and apply invoke a function immediately with a chosen this (apply takes arguments as an array); bind returns a new function with this fixed for later.

• Guessing output instead of reasoning aloud.
• Confusing == and ===.
• Not knowing what this refers to.
• Ignoring promise errors.
• Only knowing a framework.

Technical references are MDN's JavaScript Guide (including closures and promises) and the ECMAScript specification; usage data from Stack Overflow's 2025 survey; pay from AmbitionBox (read October 2026). Test formats and the history table are editorial summaries. Science of Apps publishes the free certification linked here. Last reviewed October 2026.

• Closure — a function that keeps access to variables from where it was created.
• Hoisting — declarations being processed before code runs.
• Event loop — the mechanism that runs queued tasks when the call stack is empty.
• Promise — an object representing a value that will be available later.
• Event delegation — handling events from many children with one parent listener.