How does the JavaScript event loop work?

Start by explaining that JavaScript runs on a single thread for executing code, and the event loop schedules tasks so the thread can handle asynchronous operations. Describe the difference between the call stack, task queue (macrotasks), and microtask queue, and how the event loop picks microtasks before the next macrotask. Give a simple example: a setTimeout callback goes to the macrotask queue, a Promise.then callback goes to the microtask queue, and microtasks run before the next render or macrotask. You can illustrate by walking through code where a Promise resolves inside a setTimeout to show the ordering. Tip: when answering, narrate the order of operations for a short code sample instead of reciting definitions, and avoid claiming behavior that depends on specific engines unless you name them.

javascript interview questions: Explain closures and when to use them

Define a closure as a function that captures variables from its outer lexical scope so those variables persist after the outer function returns. Explain that closures allow you to create private state and to implement factory functions, callbacks, and function-based modules. Show a concise example: a function makeCounter returns an inner function that increments a private count variable captured by closure. Walk through how each returned function call updates that private count without exposing it globally. Advice: mention memory considerations because captured variables stay reachable, and avoid creating unnecessary closures in hot loops to reduce memory pressure.

What is the difference between var, let, and const?

Explain that var is function-scoped and hoisted, while let and const are block-scoped and not usable before their declaration due to the temporal dead zone. Add that const creates a read-only binding for the variable identifier but does not make the referenced object immutable. Give an example showing var hoisting causing an undefined value, and contrast with let causing a ReferenceError if accessed before declaration. For const, show modifying a property on a const object still works, which illustrates the distinction between binding immutability and object immutability. Tip: recommend defaulting to const for values that should not be rebound, use let for variables that change, and avoid var in modern codebases to prevent unexpected scoping bugs.

Can you explain prototypal inheritance and how it differs from classical inheritance?

Describe that JavaScript uses prototype-based inheritance where objects inherit directly from other objects via a prototype chain, rather than classes creating instances that inherit from class definitions. Explain how functions have a prototype property used when creating objects with new, and how Object.create sets an explicit prototype. Provide a short example comparing Object.create to an ES6 class. Show how methods added to a prototype are shared across instances, and how property lookup walks the prototype chain until it finds a value or reaches null. Caution: clarify that ES6 classes are syntactic sugar over prototypes, and avoid implying classes introduce a separate inheritance mechanism.

What are hoisting and the temporal dead zone?

Explain that hoisting means declarations are conceptually moved to the top of their scope, but initialization behaves differently for var versus let and const. Describe the temporal dead zone as the period between entering a scope and the actual declaration where let and const cannot be accessed. Use an example where a var-declared variable logs undefined when referenced before its declaration, while a let-declared variable throws a ReferenceError in the same position. Emphasize practical debugging advice: search for unexpected undefined values and replace var with let or const to reduce subtle bugs. Avoid overgeneralizing engine behavior, and if you mention specifics reference the ECMAScript specification or major engines.

How do promises, async/await, and error handling work in JavaScript?

Describe that a Promise represents a future value and supports then and catch for chaining, while async functions let you write asynchronous code with await that pauses execution until a promise settles. Explain that awaiting a rejected promise throws, so you must use try/catch or attach a catch to the promise chain for proper error handling. Give a code example: an async function that awaits fetch, wraps the call in try/catch, and handles network errors versus JSON parse errors separately. Show how Promise.all rejects fast if any promise rejects, and how Promise.allSettled can be used when you want results for every input regardless of rejection. Tip: mention common pitfalls like forgetting to return a promise chain in then handlers or not handling rejected promises in background tasks.

Explain the difference between == and === in JavaScript

State that === checks for strict equality without coercion, while == performs type conversion before comparison when types differ. Explain that == can yield surprising results due to coercion rules, for example null == undefined is true, but null === undefined is false. Provide examples showing '0' == 0 is true due to coercion, but '0' === 0 is false. Recommend using === for predictable comparisons and only using == when you intentionally want coercion and can justify the exact cases. Tip: when reviewing legacy code, search for == occurrences and confirm whether coercion was intentional.

How does the value of this get determined in JavaScript?

Explain that this is determined by how a function is called: as a method, as a plain function, with call/apply/bind, or when used with new. Clarify that arrow functions do not have their own this, they inherit it lexically from the surrounding scope. Give examples: calling obj.method() sets this to obj, calling func() in strict mode sets this to undefined, and new Func() sets this to the newly created instance. Show how bind creates a new function with a permanently set this, which helps in callbacks where context matters. Advice: when explaining, walk through the call site and show how different invocation patterns change this rather than only listing rules.

When would you use debounce versus throttle?

Define debounce as delaying a function call until a pause in events, and throttle as limiting a function call to at most once per interval. Explain common use cases: debounce for search input to wait until typing stops, throttle for scroll or resize handlers to run periodically. Give a brief implementation sketch: debounce clears and resets a timeout on each event, while throttle tracks the last execution time and skips calls until the wait period elapses. Mention libraries like Lodash for battle-tested implementations when you cannot write and test a custom version. Caution: point out that both can affect perceived responsiveness, so choose parameters based on UX and test on target devices.

How do memory leaks occur in JavaScript and how do you find them?

Explain that memory leaks happen when references to objects persist longer than needed, preventing garbage collection. Common causes include accidental global variables, closures holding large data, forgotten timers or event listeners, and DOM references retained in JavaScript structures. Describe diagnostic steps: reproduce the scenario, use browser DevTools Heap Snapshot or allocation instrumentation to compare snapshots, and look for detached DOM nodes or growing retained object graphs. Provide a fix example like removing event listeners in component cleanup and nulling large references when no longer needed. Tip: add cleanup logic in lifecycle hooks or use disposable patterns to ensure timers and listeners are removed, and profile on devices that match user hardware when possible.

Tell me about a time you fixed a critical production bug under time pressure

Situation: In one role, a release caused intermittent failures in the checkout flow during peak traffic, affecting revenue and customer trust. Task: As the most familiar developer on the feature, you had to identify the root cause and restore the flow quickly while communicating status. Action: You reproduced the failure in a staging environment using sampled logs, traced the problem to a race condition in an async payment handler, and deployed a hotfix that added a safe retry with idempotency checks. You coordinated with QA to run targeted tests and with support to notify affected customers. Result: The hotfix reduced checkout errors to near zero within two hours and prevented revenue loss during the next peak window, and you later wrote a postmortem that led to improved monitoring and a 30% reduction in similar incidents.

Describe a time you had a disagreement with a teammate about a technical approach

Situation: Your team debated whether to refactor a legacy module now or postpone until after the next release to meet a tight deadline. Task: You had to advocate for your position while maintaining team alignment and delivery commitments. Action: You gathered concrete examples of long-term maintenance cost, built a short prototype showing the refactor scope, and proposed a compromise: ship a minimal fix for the release and schedule a focused refactor sprint with clear acceptance criteria. You presented trade-offs, estimated effort, and asked for feedback to align priorities. Result: The team agreed to the compromise, the release shipped on time, and the later refactor reduced bug reports in that module by 45%, validating your approach while keeping team morale intact.

Give an example of mentoring a junior developer and the outcome

Situation: A junior developer struggled with writing testable code and understanding async patterns, which slowed feature delivery. Task: You took responsibility to improve their skills and ramp them to independent delivery. Action: You scheduled weekly pairing sessions to work through real tickets, created small exercises focused on promises and async/await, and reviewed their pull requests with actionable feedback and examples. You set measurable goals like increasing unit test coverage and reducing the time to resolve assigned bugs. Result: Over three months the developer increased their test coverage from 20% to 65% on owned modules, reduced bug reopen rates by half, and began mentoring interns, which showed sustained growth and improved team throughput.

Explain microtasks vs macrotasks with an example

Explain that microtasks, like Promise callbacks and mutation observer callbacks, run after the current task completes but before rendering and before macrotasks. Macrotasks include setTimeout, setInterval, I/O callbacks, and message events, and they run one per event loop turn after microtasks drain. Example: show ordering with code: `setTimeout(() => console.log('macrotask'), 0); Promise.resolve().then(() => console.log('microtask')); console.log('sync');` The output will be: sync, microtask, macrotask, which you can walk through step by step. Pitfalls: be careful when scheduling heavy microtasks because they can starve rendering and macrotasks, and avoid assuming exact ordering across environments without tests.

Write a simple debounce function and explain how it works

Approach: a debounce function returns a wrapper that delays invoking the original function until after a wait period has elapsed since the last call. It works by keeping a timeout id and clearing it each time the returned function runs, then setting a new timeout to call the original after the delay. Example implementation: `function debounce(fn, wait){ let t; return function(...args){ clearTimeout(t); t = setTimeout(() => fn.apply(this, args), wait); }; }` Explain that this preserves context and arguments using apply and rest parameters. Gotchas: mention that immediate invocation variants exist where the function runs on the leading edge, and that including long-running tasks inside debounced functions can affect responsiveness.

Show how to implement a simple promise-based retry with backoff

Approach: create a function that attempts an async operation and retries on failure up to a max number with increasing delay between attempts. Use a loop or recursion to await each attempt and wait using a sleep helper implemented with a promise. Example code: `async function retry(fn, attempts=3, delay=200){ for(let i=0;i setTimeout(r, delay*(i+1))); } } }` Explain that this multiplies delay each retry and rethrows the final error. Pitfalls: avoid blind retries for client errors like 4xx, add jitter to backoff in distributed systems to avoid thundering herd, and limit total retry time to avoid blocking resources.

Explain how to deep clone an object in JavaScript and trade-offs

Approach: list common methods: structuredClone if available, JSON.parse(JSON.stringify(obj)) for simple cases, and manual deep copy using recursion or libraries like lodash's cloneDeep for complex structures. Explain that each method has trade-offs around prototypes, functions, dates, maps, sets, and circular references. Example: show `const copy = JSON.parse(JSON.stringify(obj));` and explain it fails for functions, undefined, NaN, Infinity, and loses prototypes and class instances. Mention `structuredClone(obj)` as a modern alternative that handles many built-in types and circular references when supported. Tip: choose cloning method based on the data shapes you expect, and prefer immutable patterns or controlled data copying over deep cloning when possible to reduce surprises.

How do you optimize JavaScript performance in a large single-page app?

Approach: identify hotspots with profiling, optimize critical rendering paths, and reduce work on the main thread by moving heavy tasks off the UI thread or breaking large tasks into smaller chunks. Also consider code-splitting, lazy loading, and limiting re-renders by using memoization and fine-grained state updates. Practical steps: use browser DevTools to profile scripting and rendering, split bundles via dynamic import to defer noncritical code, and employ requestIdleCallback or Web Workers for background processing. On the UI side, avoid excessive DOM updates and prefer virtualized lists for long item sets. Caveats: always measure before and after changes because optimizations can add complexity, and test on target devices to ensure real-world improvements.

Explain how prototype chain property lookup works with an example

Approach: property access looks on the object itself first, and if not found it follows the object's internal prototype link to the next object, repeating until it finds the property or reaches null. This lookup means shared methods can be placed on prototypes to save memory and allow behavior reuse across instances. Example: `const parent = { greet(){ return 'hi'; } }; const child = Object.create(parent); child.name = 'A'; child.greet()` will find greet on parent via the prototype chain and run it with child as this. Walk through how setting child.greet shadows the prototype method by adding an own property. Pitfalls: modifying prototypes at runtime can create unexpected behavior and slow property access in some engines, so prefer defining prototypes at creation time and avoid prototype mutation in production code.

javascript Interview Questions: Complete Guide

This guide covers common javascript interview questions and shows what to expect in technical and behavioral rounds. Interviews often combine live coding, system design, and behavioral questions, so prepare to explain your thinking and write clear code under time pressure.

Common Interview Questions

Behavioral Questions (STAR Method)

STAR Method: Structure your answers using Situation, Task, Action, and Result to tell compelling stories about your experience.

Technical Questions

Questions to Ask the Interviewer

Show your interest by asking thoughtful questions

•What does success look like in this role after the first 6 months, and what metrics will indicate progress?
•Can you describe the team structure, who I would work with daily, and where this role fits in that structure?
•What are the biggest technical challenges the team is currently facing with the frontend or JavaScript stack?
•How does the team handle on-call, incident response, and postmortems for production issues?
•What opportunities are there for mentoring, owning features end-to-end, and influencing the technical roadmap?

Interview Preparation Tips

Practice explaining your thought process aloud while solving whiteboard or coding problems so interviewers can follow your reasoning.

Write small, focused tests for your functions during take-home tasks and mention your testing strategy during interviews.

In live coding, start with a simple correct solution, then iterate to improve performance or edge cases, narrating each change.

Prepare 2-3 concrete examples of past work that show impact, and keep metrics handy to quantify outcomes.

Overview

This guide prepares you for JavaScript interviews across frontend, backend (Node. js), and full-stack roles.

Expect four common formats: phone screens (10–20 minutes), live coding (30–60 minutes), take-home assignments (2–48 hours), and system-design or architecture rounds (45–90 minutes). For junior roles, 60–75% of questions focus on language fundamentals like scope, closures, and array methods.

For mid-to-senior roles, interviewers add performance, design, and debugging—roughly 40–60% of those rounds examine asynchronous patterns and architecture decisions.

Core topics to master:

•Language basics: hoisting, var/let/const, prototypes, and ES6+ syntax (arrow functions, destructuring).
•Asynchronous JavaScript: callbacks, Promises, async/await, event loop phases, and cancellation patterns.
•DOM & browser APIs: event delegation, reflow vs repaint, and storage (localStorage/IndexedDB).
•Data structures & algorithms: arrays, maps, sets, common sorts; aim to solve medium problems in 20–30 minutes.
•Node.js specifics: streams, buffers, process lifecycle, and cluster/threading choices.

During interviews, show trade-offs. For example, when asked to optimize rendering, quantify: "I reduced repaint area by 60% by batching DOM updates and using requestAnimationFrame.

" Communicate assumptions, write testable code, and run a quick complexity check (time/space). Actionable takeaway: practice 5 timed problems and 3 mock interviews, then iterate on weaknesses with targeted study.

Subtopics and Example Questions

Break your study into focused subtopics, each with sample tasks, difficulty, and timing guidance.

1) JavaScript Fundamentals (15–25 min per topic)

•Key ideas: scope chain, hoisting, prototype vs class, equality (== vs ===).
•Example question: "Explain closures and implement a function that maintains a private counter."
•Example answer snippet: function makeCounter(){ let c=0; return ()=>++c; }

2) Asynchronous Patterns (20–40 min)

•Key ideas: event loop, Promises, async/await, cancellation, race conditions.
•Example task: "Convert callback-based API to return a Promise and add timeout handling (e.g., 2s)."

3) DOM, Events, and Performance (15–30 min)

•Key ideas: event delegation, reflow/repaint, virtual DOM trade-offs.
•Example: implement event delegation to handle clicks for 10,000 list items and measure FPS impact.

4) Data Structures & Algorithms (20–35 min)

•Focus: array transforms, maps/sets, sliding window, two pointers.
•Example: flatten nested arrays to depth N without recursion (use stack).

5) Node.

•Topics: streams, clustering, backpressure, health checks.
•Example: design a streaming CSV parser that handles 1M rows using backpressure.

6) Testing & Debugging (15–30 min)

•Tasks: write unit tests (Jest), reproduce a race condition, and fix memory leaks.

Actionable takeaway: set a weekly plan—cover two subtopics per week, solve 4 related problems, and do one timed mock interview.

Resources and Study Plan

Use a mix of reference docs, hands-on practice, and timed mocks. Aim for a 6–8 week prep if you study 6–10 hours per week.

Authoritative references (read and bookmark)

•MDN Web Docs: language features, browser APIs, and examples.
•ECMAScript proposals/spec: quick lookup for new syntax.
•"You Don't Know JS" (book series): deep dives on closure, scope, and this.

Practice platforms (code problems and mock interviews)

•LeetCode & HackerRank: solve 60–80 medium problems; prioritize array, string, and hash-map categories (30–45 minutes each).
•Frontend Mentor & CodeSandbox: build small UI projects (1–3 days each) to show production-level DOM and state handling.
•Interviewing.io / Pramp: do at least 5 mock interviews with feedback.

Tools and tutorials (hands-on learning)

•Chrome DevTools performance and memory tabs: learn to profile and fix leaks; aim for a 10% reduction in memory usage on a sample app.
•FreeCodeCamp JavaScript algorithms and projects: 200+ exercises for syntax and basics.
•FrontendMasters or Egghead: 1–2-hour courses on advanced JS patterns and Node.js internals.

Project-based practice (concrete builds)

•Build 3 mini-projects: a todo app with offline sync (2–4 days), a real-time chat with WebSocket (3–5 days), and a CSV streaming processor (2–3 days).

Actionable takeaway: follow a 6-week schedule—weeks 1–2 fundamentals, 3–4 algorithms+async, 5 projects+profiling, 6 mock interviews and review.

javascript Interview Questions: Complete Guide

Emily Thompson

Common Interview Questions

Behavioral Questions (STAR Method)

Technical Questions

Questions to Ask the Interviewer

Interview Preparation Tips

Overview

Subtopics and Example Questions

Resources and Study Plan

Common Interview Questions

Build your job search toolkit

javascript Interview Questions: Complete Guide

Emily Thompson

Common Interview Questions

Q1How does the JavaScript event loop work?

Q2javascript interview questions: Explain closures and when to use them

Q3What is the difference between var, let, and const?

Q4Can you explain prototypal inheritance and how it differs from classical inheritance?

Q5What are hoisting and the temporal dead zone?

Q6How do promises, async/await, and error handling work in JavaScript?

Q7Explain the difference between == and === in JavaScript

Q8How does the value of this get determined in JavaScript?

Q9When would you use debounce versus throttle?

Q10How do memory leaks occur in JavaScript and how do you find them?

Behavioral Questions (STAR Method)

B1Tell me about a time you fixed a critical production bug under time pressure

B2Describe a time you had a disagreement with a teammate about a technical approach

B3Give an example of mentoring a junior developer and the outcome

Technical Questions

T1Explain microtasks vs macrotasks with an example

T2Write a simple debounce function and explain how it works

T3Show how to implement a simple promise-based retry with backoff

T4Explain how to deep clone an object in JavaScript and trade-offs

T5How do you optimize JavaScript performance in a large single-page app?

T6Explain how prototype chain property lookup works with an example

Questions to Ask the Interviewer

Interview Preparation Tips

Overview

Subtopics and Example Questions

Resources and Study Plan

Common Interview Questions

Build your job search toolkit