JavaScript Core Interview Questions

The earlier JavaScript lessons cover how the engine runs your code: the execution context, the call stack, let, const and the temporal dead zone, the scope chain, closures and the event loop. For the browser side of the event loop read Browser, Lesson 8. This lesson does not repeat them. It covers the other half of a JavaScript interview: types, objects, prototypes, classes, this, copying, collections, iterators, modules, errors and the newer built-in methods.

All outputs below were run on Node 22 unless a line says otherwise. Browser-only facts were checked in Chromium.

Words used in this lesson

• A primitive is a simple value that is not an object and cannot be changed: string, number, boolean, null, undefined, bigint and symbol. Everything else is an object, which is a bag of named properties.
• Coercion is the automatic conversion of a value from one type to another, such as "5" - 2 turning the string into a number.
• A prototype is the object that another object falls back to when a property is not found on it. It works like a "see also" note: if I do not have it, ask my prototype.

Types and coercion

The seven primitive types, and typeof

Equality: ==, ===, Object.is

• === (strict equality) compares type and value. No conversion.
• == (loose equality) converts types first, using a long rule list. The rules that matter: null == undefined is true and equals nothing else; if one side is a number and the other a string, the string becomes a number; an object becomes a primitive first.
• Object.is is like ===, with two differences: Object.is(NaN, NaN) is true, and Object.is(0, -0) is false.

NaN === NaN;            // falseObject.is(NaN, NaN);    // true0 === -0;               // trueObject.is(0, -0);       // falsenull == undefined;      // truenull == 0;              // falsenull >= 0;              // true   (>= converts null to 0; == does not)[] == ![];              // true   (![] is false -> 0, [] -> "" -> 0)

Conversion rules worth knowing

"5" - 2        // 3      - minus always means numbers"5" + 2        // "52"   - plus joins if either side is a string+""  +[]  +null   // 0 0 0+undefined  +{}   // NaN NaN[] + {}        // "[object Object]"

There are only eight falsy values: false, 0, -0, 0n, "", null, undefined, NaN. Everything else is truthy, including [], {}, "0" and new Boolean(false).

Numbers, -0, NaN, BigInt

A JavaScript number is a 64-bit floating-point value (IEEE 754). Many decimals cannot be stored exactly.

0.1 + 0.2;                          // 0.30000000000000004Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON;   // true - compare with a toleranceNumber.MAX_SAFE_INTEGER;            // 9007199254740991 (2**53 - 1)2 ** 53 === 2 ** 53 + 1;            // true - integers lose precision above this1.005.toFixed(2);                   // "1.00"  - the stored value is slightly below 1.005

-0 is a real value: 1 / -0 is -Infinity, and Math.round(-0.4) gives -0. Only Object.is and 1/x can see it.

BigInt (ES2020, a bigint primitive) holds integers of any size: 9007199254740993n + 1n is 9007199254740994n. Rules: you cannot mix it with numbers (1n + 1 throws TypeError: Cannot mix BigInt and other types), JSON.stringify throws on it, and Math functions do not accept it. 2n == 2 is true but 2n === 2 is false.

Symbols

A symbol is a primitive that is always unique, used mainly as a property key that cannot clash with another key. Symbol("a") === Symbol("a") is false. Symbol.for("a") reads a shared global registry, so Symbol.for("a") === Symbol.for("a") is true. Symbol keys are skipped by Object.keys, for...in and JSON.stringify, but Reflect.ownKeys lists them. The language uses well-known symbols as hooks: Symbol.iterator, Symbol.asyncIterator, Symbol.toPrimitive, Symbol.toStringTag.

Objects and property descriptors

Every property has a descriptor. A data property has value, writable, enumerable, configurable. An accessor property has get, set, enumerable, configurable.

const o = { a: 1 };Object.defineProperty(o, "hidden", { value: 42 });   // other flags default to falseObject.getOwnPropertyDescriptor(o, "hidden");// { value: 42, writable: false, enumerable: false, configurable: false }Object.keys(o);          // ["a"]   - not enumerable, so hidden from keys and JSONo.hidden = 7;            // silently ignored in sloppy mode                         // TypeError in strict mode: Cannot assign to read only property

• enumerable: shows up in Object.keys, for...in, spread and JSON.stringify.
• writable: the value can be changed.
• configurable: the property can be deleted or its descriptor changed.

Sloppy mode versus strict mode. Sloppy mode is the old, forgiving behaviour that ignores some errors. Strict mode ("use strict") turns them into real errors. ES modules and class bodies are always strict, which is why the same code can fail silently in a script and throw in a module.

Key order. Integer-like keys come first in ascending order, then string keys in the order they were added, then symbols. Object.keys({ b: 1, 2: 1, a: 1, 1: 1 }) gives ["1", "2", "b", "a"].

Prototypes and the prototype chain

Every object has an internal link to its prototype (read it with Object.getPrototypeOf(obj); the old __proto__ accessor does the same). When you read obj.x and x is missing, the engine looks at the prototype, then the prototype's prototype, up to null. This list of links is the prototype chain.

function Animal(n) { this.n = n }Animal.prototype.speak = function () { return this.n + " speaks" };const d = new Animal("Rex");d.speak();                                       // "Rex speaks"Object.getPrototypeOf(d) === Animal.prototype;   // trueObject.hasOwn(d, "speak");                       // false - it lives on the prototypeObject.getPrototypeOf(Animal.prototype) === Object.prototype;  // trueObject.getPrototypeOf(Object.prototype);         // null - end of the chain

Three names are easy to mix up. Difference in one line: obj.__proto__ (or Object.getPrototypeOf(obj)) is the link an object has; Fn.prototype is the object a function gives to the things it creates with new.

• new Fn(args) does four steps: make an empty object whose prototype is Fn.prototype; call Fn with this set to it; if Fn returns an object, use that; otherwise use the new object.
• Object.create(proto) makes an object with a chosen prototype. Object.create(null) makes one with no prototype, a safe dictionary. instanceof walks the left side's chain looking for Right.prototype.
• Writes do not use the chain. Reading finds an inherited value; writing always creates an own property (shadowing). child.count++ reads the parent's 0, then creates child.count = 1; the parent stays 0. But child.list.push(1) changes the shared parent array.
• for...in also walks the chain and lists inherited enumerable keys. Object.keys and Object.entries list own keys only. Use Object.hasOwn(obj, key) (ES2022), not obj.hasOwnProperty(key).

Classes

A class is a cleaner way to write a constructor function plus prototype methods. It is not a new object model. typeof class {} is "function", and methods live on Class.prototype.

Differences from a plain constructor function: a class cannot be called without new (TypeError: Class constructor A cannot be invoked without 'new'), its body is always strict, class declarations are in the temporal dead zone before they run, and methods are not enumerable.

class Account {  #balance = 0;                       // private instance field (ES2022)  static #count = 0;                  // private static field  static ready;  static { Account.ready = true; }    // static block (ES2022)  get balance() { return this.#balance }          // a getter runs a function on read...  set balance(v) { if (v < 0) throw new RangeError("negative"); this.#balance = v }  // ...and a setter  #log() { return "private method" }  static isAccount(o) { return #balance in o }    // brand check (ES2022)}

• A private field #x is visible only inside the class body. It is a real language rule, not a naming habit. Reading obj.#x outside gives a SyntaxError at parse time. It is not an own property: Object.keys and JSON.stringify do not see it, and a Proxy around the object cannot reach it (Cannot read private member #x from an object whose class did not declare it).
• A static block runs once when the class is created. #x in obj is a safe check that an object came from this class.
• A class field with an arrow function (handle = () => {}) creates a new function per instance, but keeps this fixed. A normal method is shared on the prototype.
• extends and super. super(...) in a constructor must run before you touch this; otherwise: ReferenceError: Must call super constructor in derived class before accessing 'this'. super.method() calls the parent's version. static methods are inherited too.
• Field timing. A subclass field is set after super() returns. So if the base constructor calls an overridden method, that method sees the subclass field as undefined.

class Par { constructor() { this.say() } say() { console.log("Par") } }class Chi extends Par { name = "chi"; say() { console.log("Chi says", this.name) } }new Chi();   // "Chi says undefined"

The accessor keyword you may see in tutorials belongs to the decorators proposal (Stage 2.7). It is not part of JavaScript today.

this, call, apply, bind and arrow functions

this is decided by how a function is called, not where it is written. Arrow functions are the exception: they take this from where they are written.

• call runs the function now with a chosen this and separate arguments. apply is the same with an array of arguments (today I would use spread instead). bind does not run it; it returns a new function with this (and optionally the first arguments) fixed.
• Losing this. const f = obj.method; f() is a plain call. (obj.method)() still works (parentheses do not detach), but (0, obj.method)() does not.
• Arrow functions have no own this, arguments or prototype, and cannot be called with new. call, apply and bind cannot change their this. Do not use an arrow as an object method if you need this to be the object.

const obj = {  name: "obj",  regular() { return this.name },  arrow: () => typeof this,  nested() { return [1].map(() => this.name) },       // ["obj"] - arrow keeps this};const f = obj.regular;obj.regular();   // "obj"f();             // undefined in strict mode (a module or class); the global's name in sloppy mode

Copying and immutability

Assignment never copies an object. const b = a copies the reference (the address), so both names point at the same object. JavaScript is always pass-by-value. For objects, the value that is passed is the reference. That is why changing obj.x inside a function is seen outside, but obj = {} inside the function is not.

A shallow copy copies only the top level, so inner objects stay shared. A deep copy copies every level.

structuredClone is a global function that makes a deep copy using the browser's structured clone algorithm. It is not part of the ECMAScript spec; it comes from the HTML standard and Node (Node 17+, Chrome 98, Firefox 94, Safari 15.4). It can also move a buffer: structuredClone(buf, { transfer: [buf] }) leaves the original with byteLength 0.

Immutability means a value is never changed after creation. JavaScript gives three levels:

freeze is shallow: Object.freeze({ n: { b: 2 } }).n.b = 3 works. It also does not protect a Map: Object.freeze(new Map()).set(1, 2) still works, because the data is in internal slots. In sloppy mode, writes to a frozen object are silently ignored; in strict mode they throw. A frozen array rejects push with TypeError: Cannot add property 2, object is not extensible.

const is different: it stops re-assigning the name, not changing the object.

Map, Set, WeakMap, WeakSet, WeakRef

A weak reference is a link that does not keep an object alive. If nothing else points at the object, the garbage collector may free it.

Map versus plain object. Use a Map when keys are not known in advance, are not strings, or the table changes a lot. A plain object has inherited keys ("toString" in {} is true), turns keys into strings, and has no size. Use an object for fixed, known shapes and for JSON.

Typical WeakMap use: attach metadata to an object (such as a DOM element) without leaking it, because the entry disappears with the key.

Set methods (ES2025)

union, intersection, difference, symmetricDifference, isSubsetOf, isSupersetOf, isDisjointFrom:

const A = new Set([1, 2, 3]), B = new Set([3, 4]);A.union(B);          // Set {1, 2, 3, 4}A.intersection(B);   // Set {3}A.difference(B);     // Set {1, 2}

Iterators and generators

An iterable is an object with a [Symbol.iterator]() method that returns an iterator, an object with next() returning { value, done }. for...of, spread, destructuring, Array.from, Map, Set and Promise.all all use this protocol. A plain object is not iterable (for (const x of {a:1}) throws TypeError); use Object.entries(obj).

const range = {  from: 1, to: 3,  [Symbol.iterator]() {    let c = this.from, t = this.to;    return {      next: () => (c <= t ? { value: c++, done: false } : { value: undefined, done: true }),      return() { console.log("closed"); return { done: true } },   // runs on break/throw/destructuring    };  },};[...range];                    // [1, 2, 3]for (const x of range) { if (x === 2) break }   // prints "closed"const [first] = range;         // also prints "closed" - destructuring stops early

A generator function (function*) is a function that can pause with yield and continue later, so it returns an iterator you do not write by hand. yield pauses and gives a value out; the value passed into next(v) becomes the result of the yield. return() ends it early and still runs finally blocks. yield* hands over to another iterable. Because generators are lazy, they can be infinite:

function* naturals() { let i = 0; while (true) yield i++ }naturals().filter(x => x % 2).map(x => x * x).take(4).toArray();   // [1, 9, 25, 49]

The chain above uses iterator helpers (ES2025): map, filter, take, drop, flatMap, reduce, toArray, some, every, find, forEach, plus Iterator.from. They work lazily, one item at a time, unlike array methods that build a full array at each step.

Async iterators use for await...of; async function* is the generator form. Array.fromAsync(asyncIterable) (ES2026) collects one into an array.

Destructuring, defaults, rest, optional chaining, nullish

Destructuring unpacks values from arrays or objects into variables.

const { a = 10, b: { c = 5 } = {}, ...rest } = { a: undefined, x: 1, y: 2 };// a = 10, c = 5, rest = { x: 1, y: 2 }const [x, , y = 3, ...zs] = [1, 2, undefined, 4, 5];   // x=1, y=3, zs=[4,5][p, q] = [q, p];                                        // swap, no temp variable

• A default applies only when the value is undefined, not null or 0. A default is evaluated only when needed.
• const { nope } = null throws TypeError: Cannot destructure property 'nope' of 'null'. Add = {} on the pattern when the value may be missing.
• Rest (...rest) collects the leftover items. In a function it replaces arguments. fn.length counts parameters before the first default or rest.
• Optional chaining ?. (ES2020) stops and gives undefined if the left side is null or undefined: user?.address?.city, fn?.(), arr?.[0]. It short-circuits the whole rest of the chain.
• Nullish coalescing ?? (ES2020) picks the right side only for null/undefined. 0 ?? 5 is 0; 0 || 5 is 5. ??, ??=, ||=, &&= (ES2021) are the assignment forms. You cannot mix ?? with || or && without parentheses (SyntaxError).

Proxy and Reflect

A Proxy is an object that wraps another object and lets you intercept actions on it (reading, writing, in, delete) with functions called traps. Reflect has one function for each default action, so a trap can call the normal behaviour: Reflect.get(target, key, receiver).

const guarded = new Proxy({ a: 1 }, {  set(t, k, v, r) {    if (typeof v !== "number") throw new TypeError("number only");    return Reflect.set(t, k, v, r);  },  has: (t, k) => k.startsWith("a"),});

Real uses: validation, logging, negative array indexes, lazy objects, and the reactivity in frameworks such as Vue 3. Limits: a proxy cannot lie about a frozen target (it throws a TypeError), a proxy around a Map breaks because Map methods need the real object as this (Method Map.prototype.set called on incompatible receiver), private fields are not reachable, and traps add cost to every access. Proxy.revocable returns a proxy you can switch off.

Tagged templates

A tagged template calls a function with the template pieces: tag\a${1}b`. The function gets an array of the literal strings (with a .rawcopy that keeps\n as typed) and then the values. The strings array is frozen and the **same object every time the same code location runs**. Uses: safe HTML escaping, SQL parameters (sql`... ${id}`), CSS-in-JS, String.raw`.

Intl, Date and Temporal

Intl is the built-in internationalisation API (its own standard, ECMA-402). It formats numbers, dates, lists and plurals the way a locale expects, with no library:

new Intl.NumberFormat("en-IN", { style: "currency", currency: "INR" }).format(1234567.891); // "₹12,34,567.89"new Intl.NumberFormat("en", { notation: "compact" }).format(1234567);                        // "1.2M"["ä", "z", "a"].sort(new Intl.Collator("de").compare);                                       // ["a", "ä", "z"]

The Date object is weak. It is mutable (setMonth changes the object); months start at 0; new Date(2024, 0, 31).setMonth(1) overflows into March; a date-only string like "2024-03-10" is read as UTC, but "2024-03-10T00:00:00" is read as local time; it has no time zone support besides "UTC or the user's"; and parsing of non-ISO strings differs between engines.

Temporal is the replacement. It has separate immutable types: Temporal.PlainDate (a calendar date), Temporal.Instant (an exact moment), Temporal.ZonedDateTime (a moment with a time zone), and Temporal.Duration. Status: it reached Stage 4 and is listed for ES2027. It ships in Firefox 139, Chrome 144 and Node 26. Safari has it only in preview. It was not present in Node 22 or Chromium 141 in my tests. In Node 26:

Temporal.PlainDate.from("2024-01-31").add({ months: 1 }).toString();   // "2024-02-29" (clamped)Temporal.Instant.from("2024-03-10T00:00:00Z").toZonedDateTimeISO("Asia/Kolkata").toString();// "2024-03-10T05:30:00+05:30[Asia/Kolkata]"

Today I store dates as UTC ISO strings and use a library or a polyfill.

ES modules versus CommonJS

A module is a file with its own scope that shares values with other files. JavaScript has two systems.

A live binding means the importer sees the exporter's current value. With export let count = 0; export function inc() { count++ }, the importer reads count as 0, calls inc(), then reads 1. The importer cannot assign to it: count = 5 throws TypeError: Assignment to constant variable. In CommonJS, const { count, inc } = require("./cnt") copies the number once, so it stays 0.

Cycles. In CommonJS, a file in a cycle gets the partly filled exports so far. In my test, c2 saw c1.loaded === false. In ESM, bindings exist but may not be initialised: using an export const too early throws ReferenceError: Cannot access 'a' before initialization. Fix cycles by moving shared code to a third file.

Top-level await (ES2022; Chrome 89, Firefox 89, Node 14.8; Safari 15 with a bug that is fixed in 27) lets a module wait for a promise. Modules that import it wait too, so one slow await can delay start-up of everything that depends on it.

Dynamic import() (ES2020) loads a module on demand and returns a promise: const { default: x } = await import("./x.mjs"). It works in both CJS and ESM, and bundlers use it to split code. Import attributes (ES2025) are written import data from "./a.json" with { type: "json" }.

In Node, a file is ESM if it ends in .mjs or the nearest package.json has "type": "module". Since Node 22.12, require() can load an ES module that has no top-level await. For the server side of this, see Full-Stack Q&A, Lesson 6 (Node.js).

Modern methods: edition and support

"Support" below is the first version of Chrome / Firefox / Safari / Node that has it (MDN browser-compat data).

The four "copy" methods return a new array and leave the original alone, unlike sort, reverse, splice and index assignment, which change the array in place:

const arr = [3, 1, 2];arr.toSorted();      // [1, 2, 3]       arr is still [3, 1, 2]arr.with(0, 9);      // [9, 1, 2]       out of range throws RangeErrorarr.toSpliced(1, 1); // [3, 2]arr.at(-1);          // 2arr.findLast(x => x > 1);   // 2Object.groupBy([1, 2, 3, 4, 5], n => (n % 2 ? "odd" : "even"));// { odd: [1, 3, 5], even: [2, 4] }  - an object with no prototypeMap.groupBy([1, 2, 3], n => n > 1);   // Map { false => [1], true => [2, 3] }const { promise, resolve, reject } = Promise.withResolvers();   // resolve it from outside

For features your target browsers lack, check the table against your browserslist, then transpile or polyfill.

Error handling

An Error is an object with name, message and stack. You can throw anything, but always throw an Error so you get a stack.

• cause (ES2022) links the original error when you wrap it: throw new Error("config bad", { cause: err }). Keeps the full story in logs.
• AggregateError has an errors array. Promise.any rejects with it when every promise fails. Promise.allSettled never rejects; it reports {status, value | reason} for each.
• Custom errors extend Error. Set name (use new.target.name) and add useful fields:

class HttpError extends Error {  constructor(status, msg, opts) { super(msg, opts); this.name = new.target.name; this.status = status }}class NotFound extends HttpError { constructor(m) { super(404, m) } }const e = new NotFound("gone");e instanceof HttpError;   // trueJSON.stringify(e);        // {"name":"NotFound","status":404} - message and stack are NOT enumerable

• instanceof fails across realms (an iframe); Error.isError(x) (ES2026) is the cross-realm check.
• try/catch does not catch the rejection of a promise you forgot to await. try { af() } catch {} where af is async does nothing; the rejection becomes an unhandled rejection. In Node 15+, an unhandled rejection ends the process with exit code 1 by default.
• finally runs even after return or throw. A return inside finally overrides the earlier result, which is usually a bug.

Memory and performance basics

• Garbage collection frees memory of objects nothing can reach any more. Reachability decides what is collected. An object lives while a chain of references reaches it from a root (global variables, the current stack, active closures, timers, event listeners).
• Common leaks: a global array or Map that only grows (caches with no limit); a listener or setInterval that was never removed; a closure that holds a large variable; detached DOM nodes still in a variable. Fix: remove listeners (AbortController signal), clear timers, use a WeakMap or a size-limited cache.
• Cheap wins: do not search an array inside a loop (build a Map or Set once); use a lazy iterator instead of building big arrays; and measure with the profiler before tuning.

Interview questions

console.log(0.1 + 0.2 === 0.3, [10, 9, 1].sort(), ["1", "2", "3"].map(parseInt), "b" + "a" + +"a" + "a");

class Par { constructor() { this.say() } say() { console.log("Par") } }class Chi extends Par { name = "chi"; say() { console.log("Chi says", this.name) } }new Chi();

const a = {}, b = { key: "b" }, c = { key: "c" };a[b] = 123;a[c] = 456;console.log(a[b], Object.keys(a));

const { a = 10, b: { c = 5 } = {}, ...rest } = { a: undefined, x: 1, y: 2 };console.log(a, c, rest);console.log(0 ?? "d", "" ?? "d", null ?? "d", 0 || "d");

function myNew(Ctor, ...args) {  const o = Object.create(Ctor.prototype);  const r = Ctor.apply(o, args);  return r !== null && (typeof r === "object" || typeof r === "function") ? r : o;}Function.prototype.myBind = function (ctx, ...pre) {  const fn = this;  function bound(...rest) { return fn.apply(new.target ? this : ctx, [...pre, ...rest]) }  if (fn.prototype) bound.prototype = Object.create(fn.prototype);  return bound;};

function deepClone(v, seen = new WeakMap()) {  if (v === null || typeof v !== "object") return v;  if (seen.has(v)) return seen.get(v);  if (v instanceof Date) return new Date(v);  if (v instanceof Map) {    const m = new Map(); seen.set(v, m);    v.forEach((val, k) => m.set(deepClone(k, seen), deepClone(val, seen)));    return m;  }  const out = Array.isArray(v) ? [] : Object.create(Object.getPrototypeOf(v));  seen.set(v, out);  for (const k of Reflect.ownKeys(v)) out[k] = deepClone(v[k], seen);  return out;}