Question 1

What is the difference between var, let and const?

Accepted Answer

var is function scoped, while let and const are block scoped. A var can be redeclared, let and const cannot be redeclared in the same scope. A const cannot be reassigned, but the contents of an object or array stored in it can still change. Modern code uses const by default and let only when the value changes.

Question 2

What is hoisting in JavaScript?

Accepted Answer

When a scope is created, the engine registers declarations before any code runs. Function declarations are hoisted completely, so you can call them before the line where they are declared. A var is hoisted with the value undefined. let and const are registered too, but until their declaration line they sit in the TDZ, and accessing them throws a ReferenceError.

Question 3

What is the difference between == and ===?

Accepted Answer

=== compares without type coercion: the values must have the same type and be equal. == first coerces the operands to a common type, so 0 == "" and null == undefined are both true. Because the coercion rules are surprising, === is used almost everywhere. One exception sometimes kept on purpose: x == null checks for both null and undefined at once.

Question 4

What is a closure? Give an example of how it is used.

Accepted Answer

A closure is a function together with the lexical environment it was created in. It can access the outer function's variables even after that function has returned. This is how you build private state, for example a counter that returns an increment function. Callbacks, function factories and memoization also rely on closures.

Question 5

How does a shallow copy of an object differ from a deep copy?

Accepted Answer

A shallow copy creates a new top level object, but nested objects remain shared references. You make one with spread { ...obj } or Object.assign. A deep copy recursively copies every level, so changes to nested data do not affect the original. The built in structuredClone does this, while JSON.parse(JSON.stringify(obj)) loses functions, undefined and dates.

Question 6

How does an object differ from an array in JavaScript?

Accepted Answer

An object is a set of named fields, for example user.name. An array is an ordered list where you get an element by its number, and the first one has number zero. On the backend you most often see an array of objects, such as a list of orders. Technically an array is also an object, but with special behavior for indexes and the length property.

Question 7

Given const a = { n: 1 }; const b = a; b.n = 2;, what does console.log(a.n) print and why?

Accepted Answer

It prints 2. The line const b = a does not copy the object, it gives one more reference to the same object. So a change through b is visible through a. Primitives (numbers, strings, booleans) are copied by value, while objects and arrays are passed by reference. To get an independent copy you need spread or structuredClone.

Question 8

What is a callback in simple words? Give an example.

Accepted Answer

A callback is a function I pass to another function so that it calls it itself at the right moment. For example, onClick calls my function on a click, and map calls it for each array element. Asynchronous APIs work the same way: I do not wait for the result, I give a function that will run when it is ready.

Question 9

The code prints A, then schedules setTimeout(() => console.log('B'), 0), then prints C. In what order do the letters appear and why?

Accepted Answer

It prints A, then C, then B. First all the synchronous code of the current call runs. The setTimeout callback goes to a queue and runs only when the stack is empty, even if the delay is zero. So zero in setTimeout means 'as soon as possible after the current code', not 'immediately'.

Question 10

An async function getUser returns the string 'Olya'. What does console.log(getUser()) print in Node.js and how do you get the string itself?

Accepted Answer

It prints Promise { 'Olya' }, because an async function always returns a promise, even if there is a plain return inside. To get the string you write await getUser() inside an async function or use .then. A forgotten await is one of the most common mistakes: the code compiles but then works with a promise instead of data.

Question 11

What do typeof null and typeof NaN return? How do isNaN and Number.isNaN differ, and how do you filter out an invalid number from a query parameter?

Accepted Answer

typeof null gives 'object': it is a historical mistake of the first implementation that cannot be fixed, so an object is checked as value !== null && typeof value === 'object'. typeof NaN gives 'number'. The global isNaN('abc') first converts the argument to a number and returns true, while Number.isNaN does no conversion and is true only for NaN itself. For a query parameter prefer Number.isFinite(Number(x)), remembering that Number('') gives 0 and parseInt('42px') gives 42.

Question 12

How does the event loop work? How do microtasks differ from macrotasks?

Accepted Answer

JavaScript runs code on a single thread through the call stack, while asynchronous callbacks wait in queues. After each macrotask (a script, setTimeout, an event) the event loop drains the whole microtask queue, and only then takes the next macrotask. Microtasks are Promise.then callbacks, await continuations and queueMicrotask. That is why Promise.resolve().then(...) runs before setTimeout(..., 0).

Question 13

What determines the value of this inside a function?

Accepted Answer

In a regular function this depends on how it is called: for obj.method() it is obj, for a plain call it is undefined in strict mode or the global object without it. call, apply and bind set this explicitly, and new binds it to the newly created object. An arrow function has no this of its own and takes it from the enclosing scope. That is why a method passed as a callback often loses its context.

Question 14

How do promises relate to async/await? How do you handle errors and parallel requests?

Accepted Answer

async/await is syntax on top of promises: an async function always returns a promise, and await waits for a result without nested then calls. Errors are caught with try/catch around await or with .catch in a chain. Consecutive await calls run one after another, so independent requests are started together with Promise.all. If you need the results even when some fail, use Promise.allSettled.

Question 15

A function has console.log(x) and below it let x = 'inner', while the outer x equals 'outer'. What does the call print and why is the outer value not used?

Accepted Answer

You get ReferenceError: Cannot access 'x' before initialization. The inner let x is registered in the creation phase of the function context and shadows the outer x for the whole block, not only after its line. From the start of the block to the initialization line the variable is in the temporal dead zone, and any access throws. That is why typeof of an undeclared variable is safe, while typeof of a variable in the TDZ also throws.

Question 16

A for (var i = 0; i < 3; i++) loop schedules a setTimeout that prints i. What does it print, and what does a similar loop with let in the header print? Why does a let declared outside the loop behave like var?

Accepted Answer

With var you get 3, 3, 3, because there is one variable for the whole function and the callbacks fire after the loop has finished. With let in the header you get 0, 1, 2: the specification creates a new binding for each iteration. If let k is declared outside for, there is one binding again and the result is like var. A closure captures the variable, not its value at the moment of creation.

Question 17

Two arrow functions are created in one function: one returns x, then x = 2, the other also returns x. What does each return? And where is a name looked up: where the function is written or where it is called?

Accepted Answer

Both return 2, because they close over the same variable x, not its value at creation time. A closure holds a reference to the lexical environment, not a snapshot of values. Names are resolved lexically: the environment where the function was created is stored in an internal slot, and calling it from elsewhere does not change that. So a variable of the calling function is not visible to the inner function, because JavaScript has no dynamic scope.

Question 18

A class has a method key(id) that reads this.prefix. Why does ids.map(service.key) fail with a TypeError, while ids.map((id) => service.key(id)) works?

Accepted Answer

this is determined by how a function is called, not where it is declared. The expression service.key(id) is a call through an object, so this equals service. But service.key without parentheses just reads a function that remembers nothing about service, and map calls it as a plain function. A class body is always strict, so this there is undefined, and reading prefix throws a TypeError. Fixes: bind, an arrow wrapper, or the second thisArg argument of map.

Question 19

How does an arrow function differ from a regular one with respect to this? What happens to this in a regular function inside setTimeout in Node.js, and in a method destructured from an object?

Accepted Answer

An arrow function has no this of its own, it takes it from the surrounding scope where it is written. In CommonJS at the top level that is module.exports, in ESM it is undefined. A method pulled out by destructuring is called without an object: in sloppy mode this is globalThis, in strict mode undefined. Node calls a setTimeout callback with this equal to the Timeout object, in a browser it would be window. An arrow inside a method takes the this of that method.

Question 20

A prototype holds an array tags and a number count. One descendant does tags.push('x') and count++. What will another descendant see, and why do the array and the number behave differently?

Accepted Answer

Reading a property walks the prototype chain, while assignment always creates or changes an own property of the object. a.tags.push('x') only reads the array from the prototype and mutates it, so that array is shared and the other descendant will see 'x'. a.count++ expands to a.count = a.count + 1: it reads 0 from the prototype and writes its own count = 1, so the other descendant still has 0. Mutable state must not be placed on a prototype.

Question 21

How does prototype differ from __proto__? Which two prototype chains does class Dog extends Animal build?

Accepted Answer

Every object has an internal slot [[Prototype]]. __proto__ is a deprecated accessor on Object.prototype that reads it, the modern way is Object.getPrototypeOf. prototype is a regular property of a constructor function: the object that new will put into [[Prototype]] of a new instance. extends builds two chains: the instance chain (d, Dog.prototype, Animal.prototype, Object.prototype) and the constructor chain (Dog, Animal), so that static methods work. Class methods are not own properties of the instance: in sees them, Object.hasOwn does not.

Question 22

They say class is syntactic sugar over constructor functions. What differences between them still exist?

Accepted Answer

The mechanics are similar: both a class and a function have a prototype where methods go. But class methods are non-enumerable, while Fn.prototype.m = ... creates an enumerable property, so for...in over an old-style instance also lists inherited methods. A function can be called without new, and this becomes globalThis in sloppy mode, while a class without new throws a TypeError. A class body is always strict, and a class is not hoisted like a function declaration (it sits in the TDZ).

Question 23

An async function prints a1, does await null, prints a2. Right after calling it there is Promise.resolve().then(p1).then(p2) and a synchronous console.log('sync'). In what order does everything print, and how many microtask steps does await cost?

Accepted Answer

Order: a1, sync, a2, p1, p2 (the continuation of the async function is queued before p1). The code of an async function up to the first await runs synchronously, so a1 is first. Each await of a plain value puts the continuation into the microtask queue and costs one step. The following then handlers are registered only after the previous ones run, so the async continuation and the then chain interleave.

Question 24

In Node.js there are two setTimeout calls with zero delay. The first schedules Promise.then and queueMicrotask, the second Promise.then and process.nextTick. Do the microtasks of the first timer run before the second timer? What goes first: nextTick or a promise?

Accepted Answer

Yes, the microtasks of the first timer run before the second timer. Since Node 11, after each individual timer callback Node drains the process.nextTick queue first, then the microtask queue, like a browser after each task. queueMicrotask and Promise.then share one FIFO queue. The nextTick queue is separate and is processed before promise microtasks, so in the second timer nextTick runs before then, even though the promise was created first.

Question 25

A chain: a then without return, then a then that throws, then another then, then a catch that returns 42, then a then and a finally. What happens at each step?

Accepted Answer

Every then returns a new promise, and its state is set by the callback. Without return the next step gets undefined: this is the most common mistake in chains. A throw in a callback makes the next promise rejected, and a then without onRejected passes it on, so the intermediate then does not run. A catch that returns a value restores the chain to fulfilled, and the next then gets 42. finally receives no value and does not change it unless it throws itself.

Question 26

How do Promise.all, allSettled, race and any differ? What backend tasks do you use each for, and what happens to the remaining operations after all rejects?

Accepted Answer

all rejects on the first error, race on the first settlement of any kind, any waits for the first success (if all fail, it rejects with AggregateError), and allSettled waits for all and never rejects. Typical use: all for dependent requests, allSettled when partial results are needed, any for mirrors, race for timeouts. Importantly, after rejection the remaining operations are not cancelled: requests and SQL continue and hold connections. Cancellation is done separately through AbortController.

Question 27

An endpoint enriches 2000 orders with data from an external service. The version with await in a for loop takes 40 seconds, the version with Promise.all gets 429 and a DB pool timeout. What is wrong with both, and how do you do it right?

Accepted Answer

The sequential version waits for each step: 2000 times 20 ms is 40 seconds. Promise.all starts all 2000 operations at once: the service rate limits requests, and a pool of 10 connections is clogged by a queue. You need bounded concurrency: a worker pool, p-limit or batches of 10-20. Also reduce the number of calls: unique ids, a batch endpoint, one INSERT per batch. Partial errors are collected with allSettled instead of failing the whole request.

Question 28

When does the body of a generator start running? What happens if a for...of loop over a generator is interrupted with break?

Accepted Answer

Calling a generator function does not run the body, it starts on the first next(). After that the generator runs only up to the next yield, so the computation is lazy and alternates with the consumer. break in for...of calls the iterator's return(): the generator is closed and yields nothing more, and code after the current yield does not run. Only finally blocks run, so cleanup of resources in a generator is written there.

Question 29

How does an iterable differ from an iterator? Why can your own range collection be spread twice while a generator can be used only once?

Accepted Answer

An iterable has a Symbol.iterator method that returns an iterator. An iterator has a next() method that returns { value, done }. A range collection creates a new iterator on every call of Symbol.iterator, so it can be traversed many times. A generator returns itself from Symbol.iterator, so it is single use. Consequence: into a function that may walk the data twice you pass an iterable (or an array), not an already created generator.

Question 30

Why is 0.1 + 0.2 not equal to 0.3, and why does 1.005 round to 1? How would you handle money in a payment service?

Accepted Answer

Numbers in JavaScript are IEEE 754 doubles, and 0.1 has no exact binary representation, so the sum gives 0.30000000000000004. Fractions are compared through a difference with a tolerance, and Number.EPSILON only suits values near one. 1.005 * 100 gives 100.49999999999999, so Math.round gives 1 and toFixed does not help. Money is kept in whole minor units (cents), in BigInt or in a decimal library, and in Postgres you use numeric.

JavaScript interview questions and answers

Junior questions

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

2. What is hoisting in JavaScript?

3. What is the difference between == and ===?

4. What is a closure? Give an example of how it is used.

5. How does a shallow copy of an object differ from a deep copy?

6. How does an object differ from an array in JavaScript?

7. Given const a = { n: 1 }; const b = a; b.n = 2;, what does console.log(a.n) print and why?

8. What is a callback in simple words? Give an example.

9. The code prints A, then schedules setTimeout(() => console.log('B'), 0), then prints C. In what order do the letters appear and why?

10. An async function getUser returns the string 'Olya'. What does console.log(getUser()) print in Node.js and how do you get the string itself?

11. What do typeof null and typeof NaN return? How do isNaN and Number.isNaN differ, and how do you filter out an invalid number from a query parameter?

Middle questions

1. How does the event loop work? How do microtasks differ from macrotasks?

2. What determines the value of this inside a function?

3. How do promises relate to async/await? How do you handle errors and parallel requests?

4. A function has console.log(x) and below it let x = 'inner', while the outer x equals 'outer'. What does the call print and why is the outer value not used?

5. A for (var i = 0; i < 3; i++) loop schedules a setTimeout that prints i. What does it print, and what does a similar loop with let in the header print? Why does a let declared outside the loop behave like var?

6. Two arrow functions are created in one function: one returns x, then x = 2, the other also returns x. What does each return? And where is a name looked up: where the function is written or where it is called?

7. A class has a method key(id) that reads this.prefix. Why does ids.map(service.key) fail with a TypeError, while ids.map((id) => service.key(id)) works?

8. How does an arrow function differ from a regular one with respect to this? What happens to this in a regular function inside setTimeout in Node.js, and in a method destructured from an object?

9. A prototype holds an array tags and a number count. One descendant does tags.push('x') and count++. What will another descendant see, and why do the array and the number behave differently?

10. How does prototype differ from __proto__? Which two prototype chains does class Dog extends Animal build?

11. They say class is syntactic sugar over constructor functions. What differences between them still exist?

12. An async function prints a1, does await null, prints a2. Right after calling it there is Promise.resolve().then(p1).then(p2) and a synchronous console.log('sync'). In what order does everything print, and how many microtask steps does await cost?

13. In Node.js there are two setTimeout calls with zero delay. The first schedules Promise.then and queueMicrotask, the second Promise.then and process.nextTick. Do the microtasks of the first timer run before the second timer? What goes first: nextTick or a promise?

14. A chain: a then without return, then a then that throws, then another then, then a catch that returns 42, then a then and a finally. What happens at each step?

15. How do Promise.all, allSettled, race and any differ? What backend tasks do you use each for, and what happens to the remaining operations after all rejects?

16. An endpoint enriches 2000 orders with data from an external service. The version with await in a for loop takes 40 seconds, the version with Promise.all gets 429 and a DB pool timeout. What is wrong with both, and how do you do it right?

17. When does the body of a generator start running? What happens if a for...of loop over a generator is interrupted with break?

18. How does an iterable differ from an iterator? Why can your own range collection be spread twice while a generator can be used only once?

19. Why is 0.1 + 0.2 not equal to 0.3, and why does 1.005 round to 1? How would you handle money in a payment service?

20. A frontend receives ids from a Postgres bigint in JSON. What bugs can this cause and how do you avoid them?

21. Why does [] == false give true and null == 0 give false, although null >= 0 gives true? How does the == algorithm work?

22. What does a copy via JSON.parse(JSON.stringify(x)) lose, what can structuredClone not do, and what would you use to copy a DTO before mutation?

23. A default config is frozen with Object.freeze, a service makes a copy with spread and changes the nested timeout. Why did another service suddenly get a changed timeout?

24. A client complains that in a JSON response the key '2026' comes before 'total', although the server order was different. In what order does JavaScript enumerate object keys?

25. How does debounce work, and why does an implementation that does not keep the timer in a closure fail? How does debounce differ from throttle?

26. In a config retries: 0 means 'do not retry', but the service makes 3 attempts. How does ?? differ from ||, and where does ?. help and where does it hide an error?

27. A client sends { offset: null, sort: '' }, and the destructuring has default values. Why did the defaults not apply and the database query fail?

28. How do you correctly wrap errors without losing the root cause? Why does a custom error class show name equal to Error, and what will a log show after JSON.stringify(error)?

29. A reducer returns a new object via spread, but changes 'leak' into the old state. Where does the mutation usually hide?

Senior questions

1. What happens in the engine when a function is called? What is in an execution context, how does the creation phase differ from the execution phase, and how is this related to the call stack?

2. The code holds only one theThing, but heapUsed grows to hundreds of megabytes, although the helper function unused is never called. Why does this happen with closures, and how do you find it in a heap snapshot?

3. Rank the this binding rules by priority. What happens with new on a bound function and with repeated bind or call? How does this change in strict mode?

4. An endpoint merges the request body into a settings object with a recursive function, and after one request all users got admin rights. How does prototype pollution work and how do you close it?

5. An async function does return Promise.resolve('r'), while other then chains run alongside. Why is r printed later than expected, although the promise is already fulfilled?

6. A colleague says an import loop does not block the server because it has await. But during the import the health check times out. Why, and how do you fix it?

7. How does the browser event loop differ from the Node.js event loop? What does the language define and what does the environment define?

8. Two async functions both have try/catch, one does return fail(), the other return await fail(). Why does only the second catch the error, and when is return await mandatory?

9. Why use a WeakMap in a metadata cache instead of a Map? Why can a string not be a key, and when are WeakRef and FinalizationRegistry appropriate?

10. An index by id from 20,000 rows is built with rows.reduce((acc, r) => ({ ...acc, [r.id]: r }), {}) and takes hundreds of milliseconds, while a simple loop is almost instant. Why, and how do you fix it without giving up purity?

11. A memoize built on Map does not hit for identical object arguments and returns a stale value after the object is mutated. How do you make memoize for object arguments correctly?

12. An async generator takes a connection from the pool and yields cursor rows, and under load the pool is exhausted. Where does the connection leak and how do you fix it?

Train these questions

Answer out loud and get graded

In the knowledge base

Other topics

Explore the platform

1. What is the difference between `var`, `let` and `const`?

3. What is the difference between `==` and `===`?

7. Given `const a = { n: 1 }; const b = a; b.n = 2;`, what does `console.log(a.n)` print and why?

9. The code prints `A`, then schedules `setTimeout(() => console.log('B'), 0)`, then prints `C`. In what order do the letters appear and why?

10. An async function `getUser` returns the string `'Olya'`. What does `console.log(getUser())` print in Node.js and how do you get the string itself?

11. What do `typeof null` and `typeof NaN` return? How do `isNaN` and `Number.isNaN` differ, and how do you filter out an invalid number from a query parameter?

2. What determines the value of `this` inside a function?

3. How do promises relate to `async/await`? How do you handle errors and parallel requests?

4. A function has `console.log(x)` and below it `let x = 'inner'`, while the outer `x` equals `'outer'`. What does the call print and why is the outer value not used?

5. A `for (var i = 0; i < 3; i++)` loop schedules a `setTimeout` that prints `i`. What does it print, and what does a similar loop with `let` in the header print? Why does a `let` declared outside the loop behave like `var`?

6. Two arrow functions are created in one function: one returns `x`, then `x = 2`, the other also returns `x`. What does each return? And where is a name looked up: where the function is written or where it is called?

7. A class has a method `key(id)` that reads `this.prefix`. Why does `ids.map(service.key)` fail with a TypeError, while `ids.map((id) => service.key(id))` works?

8. How does an arrow function differ from a regular one with respect to `this`? What happens to `this` in a regular function inside `setTimeout` in Node.js, and in a method destructured from an object?

9. A prototype holds an array `tags` and a number `count`. One descendant does `tags.push('x')` and `count++`. What will another descendant see, and why do the array and the number behave differently?

10. How does `prototype` differ from `proto`? Which two prototype chains does `class Dog extends Animal` build?

11. They say `class` is syntactic sugar over constructor functions. What differences between them still exist?

12. An async function prints `a1`, does `await null`, prints `a2`. Right after calling it there is `Promise.resolve().then(p1).then(p2)` and a synchronous `console.log('sync')`. In what order does everything print, and how many microtask steps does `await` cost?

13. In Node.js there are two `setTimeout` calls with zero delay. The first schedules `Promise.then` and `queueMicrotask`, the second `Promise.then` and `process.nextTick`. Do the microtasks of the first timer run before the second timer? What goes first: `nextTick` or a promise?

14. A chain: a `then` without `return`, then a `then` that throws, then another `then`, then a `catch` that returns 42, then a `then` and a `finally`. What happens at each step?

15. How do `Promise.all`, `allSettled`, `race` and `any` differ? What backend tasks do you use each for, and what happens to the remaining operations after `all` rejects?

16. An endpoint enriches 2000 orders with data from an external service. The version with `await` in a `for` loop takes 40 seconds, the version with `Promise.all` gets 429 and a DB pool timeout. What is wrong with both, and how do you do it right?

17. When does the body of a generator start running? What happens if a `for...of` loop over a generator is interrupted with `break`?

18. How does an iterable differ from an iterator? Why can your own `range` collection be spread twice while a generator can be used only once?

19. Why is `0.1 + 0.2` not equal to `0.3`, and why does `1.005` round to 1? How would you handle money in a payment service?

20. A frontend receives ids from a Postgres `bigint` in JSON. What bugs can this cause and how do you avoid them?

21. Why does `[] == false` give `true` and `null == 0` give `false`, although `null >= 0` gives `true`? How does the `==` algorithm work?

22. What does a copy via `JSON.parse(JSON.stringify(x))` lose, what can `structuredClone` not do, and what would you use to copy a DTO before mutation?

23. A default config is frozen with `Object.freeze`, a service makes a copy with spread and changes the nested `timeout`. Why did another service suddenly get a changed timeout?

24. A client complains that in a JSON response the key `'2026'` comes before `'total'`, although the server order was different. In what order does JavaScript enumerate object keys?

25. How does `debounce` work, and why does an implementation that does not keep the timer in a closure fail? How does debounce differ from throttle?

26. In a config `retries: 0` means 'do not retry', but the service makes 3 attempts. How does `??` differ from `||`, and where does `?.` help and where does it hide an error?

27. A client sends `{ offset: null, sort: '' }`, and the destructuring has default values. Why did the defaults not apply and the database query fail?

28. How do you correctly wrap errors without losing the root cause? Why does a custom error class show `name` equal to `Error`, and what will a log show after `JSON.stringify(error)`?

2. The code holds only one `theThing`, but `heapUsed` grows to hundreds of megabytes, although the helper function `unused` is never called. Why does this happen with closures, and how do you find it in a heap snapshot?

3. Rank the `this` binding rules by priority. What happens with `new` on a bound function and with repeated `bind` or `call`? How does this change in strict mode?

5. An async function does `return Promise.resolve('r')`, while other `then` chains run alongside. Why is `r` printed later than expected, although the promise is already fulfilled?

6. A colleague says an import loop does not block the server because it has `await`. But during the import the health check times out. Why, and how do you fix it?

8. Two async functions both have `try/catch`, one does `return fail()`, the other `return await fail()`. Why does only the second catch the error, and when is `return await` mandatory?

9. Why use a `WeakMap` in a metadata cache instead of a `Map`? Why can a string not be a key, and when are `WeakRef` and `FinalizationRegistry` appropriate?

10. An index by id from 20,000 rows is built with `rows.reduce((acc, r) => ({ ...acc, [r.id]: r }), {})` and takes hundreds of milliseconds, while a simple loop is almost instant. Why, and how do you fix it without giving up purity?

11. A memoize built on `Map` does not hit for identical object arguments and returns a stale value after the object is mutated. How do you make memoize for object arguments correctly?