JavaScript and Node Core

This file is the language-and-runtime half of your refresher: what JavaScript values actually are, how scope and this resolve, how the prototype chain and class sugar relate, how iterators and generators work, and then the two topics senior interviews spend the most time on — the event loop (with Node’s libuv phases, real “predict the output” puzzles, and a spec-faithful Promise built from scratch) and the V8 execution model (tiers, hidden classes, inline caches, elements kinds, GC). Everything here was executed on Node 22.22.2 / V8 12.4 and the pasted output is real. Where a feature is specified in ES2025/ES2026 but not yet in Node 22’s V8, it is labelled; see Feature availability at the end.

Table of contents

• 1. Values, types and coercion
• 2. Scope, hoisting, closures and this
• 3. Objects and prototypes
• 4. Functions
• 5. Iterators and generators
• 6. Asynchrony and the event loop
• 7. Memory and garbage collection
• 8. The V8 performance model
• 9. Modules
• 10. Node specifics
• 11. Modern syntax you should be fluent in
• 12. Interview questions
• 13. Feature availability on Node 22

Cross-language note. Python made the opposite choice on loop-variable scoping, and its nonlocal/closure rules are the natural counterpart to this chapter’s material. See 20 §5.4 and 20 §6.3.

1. Values, types and coercion

1.1 Primitives vs objects

Intuition. JavaScript has exactly seven primitive types and one non-primitive type. Primitives are immutable values compared by value; objects are references compared by identity. Every “method call on a primitive” is a temporary boxing operation that is thrown away immediately.

const s = 'abc';
s.toUpperCase();          // boxes to a temporary String object, calls, discards the box
s.custom = 1;             // silently dropped in sloppy mode, TypeError in strict mode
console.log(s.custom);    // undefined

typeof null;              // 'object'   <- the famous bug
typeof function () {};    // 'function' <- the only non-'object' object
typeof document?.all;     // 'undefined' in browsers: [[IsHTMLDDA]], the one falsy object

Because typeof null === 'object', the reliable null check is x === null, and the reliable “is it a plain object” check is:

const isPlainObject = (v) =>
  typeof v === 'object' && v !== null && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);

For general tagging, Object.prototype.toString.call(v) still beats typeof:

const tag = (v) => Object.prototype.toString.call(v).slice(8, -1);
// tag([]) === 'Array', tag(null) === 'Null', tag(new Date()) === 'Date', tag(/x/) === 'RegExp'

1.2 Numbers are IEEE-754 doubles

Intuition. Every number is a 64-bit float: 1 sign bit, 11 exponent bits, 52 stored mantissa bits (53 effective, because of the implicit leading 1). Decimal fractions like 0.1 have no exact binary representation, exactly the way 1/3 has no exact decimal representation. Integers are exact only up to 2^53.

 63    62 ......... 52 51 ................................................ 0
 ┌───┬──────────────────┬──────────────────────────────────────────────────┐
 │ s │  exponent (11)   │              mantissa / fraction (52)            │
 └───┴──────────────────┴──────────────────────────────────────────────────┘
 value = (-1)^s x 1.fraction x 2^(exponent - 1023)

// 01-numbers.js
console.log('0.1 + 0.2                 =', 0.1 + 0.2);
console.log('(0.1+0.2).toFixed(20)     =', (0.1 + 0.2).toFixed(20));
console.log('Number.EPSILON            =', Number.EPSILON);
console.log('nearlyEqual(0.1+0.2, 0.3) =', Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON);
console.log('MAX_SAFE_INTEGER          =', Number.MAX_SAFE_INTEGER);
console.log('2**53                     =', 2 ** 53);
console.log('2**53 + 1                 =', 2 ** 53 + 1);
console.log('2**53 === 2**53 + 1       =', 2 ** 53 === 2 ** 53 + 1);
console.log('isSafeInteger(2**53)      =', Number.isSafeInteger(2 ** 53));
console.log('MAX_VALUE * 2             =', Number.MAX_VALUE * 2);
console.log('(0.1+0.7)*10              =', (0.1 + 0.7) * 10);
console.log('Math.floor((0.1+0.7)*10)  =', Math.floor((0.1 + 0.7) * 10));

0.1 + 0.2                 = 0.30000000000000004
(0.1+0.2).toFixed(20)     = 0.30000000000000004441
Number.EPSILON            = 2.220446049250313e-16
nearlyEqual(0.1+0.2, 0.3) = true
MAX_SAFE_INTEGER          = 9007199254740991
2**53                     = 9007199254740992
2**53 + 1                 = 9007199254740992
2**53 === 2**53 + 1       = true
isSafeInteger(2**53)      = false
MAX_VALUE * 2             = Infinity
(0.1+0.7)*10              = 7.999999999999999
Math.floor((0.1+0.7)*10)  = 7

Why 2**53 + 1 fails. At magnitude 2^53 the gap between consecutive representable doubles (the ULP) is exactly 1.0. At 2^53 + 1 the gap becomes 2.0, so 2^53 + 1 is not representable at all — it rounds to nearest-even, which is 2^53. Number.MAX_SAFE_INTEGER is 2^53 − 1 precisely because that is the last integer n for which n and n + 1 are both representable.

Number.EPSILON (2^-52) is the ULP at 1.0, so Math.abs(a - b) < Number.EPSILON is only a valid “nearly equal” test for values near 1. The general form scales it:

const nearlyEqual = (a, b, eps = Number.EPSILON) =>
  Math.abs(a - b) <= eps * Math.max(1, Math.abs(a), Math.abs(b));

For money, do not use doubles at all: use integer minor units (cents as a number while under 2^53, or BigInt), or a decimal library. Math.sumPrecise (ES2026) gives an exactly-rounded sum of an iterable of doubles but is not in Node 22.

1.3 BigInt

const big = 2n ** 53n;
console.log(big + 1n);                        // 9007199254740993n  <- exact
console.log(typeof 1n);                       // 'bigint'
console.log(1n == 1, 1n === 1);               // true false
console.log(BigInt(Number.MAX_SAFE_INTEGER) * 2n);  // 18014398509481982n
1n + 1;                                       // TypeError: Cannot mix BigInt and other types

9007199254740993n
bigint
true false
18014398509481982n
1n + 1 throws              = TypeError: Cannot mix BigInt and other types, use explicit conversions

BigInt is arbitrary precision but has no fractional part, cannot be mixed with number in arithmetic (deliberately: implicit conversion would silently lose precision), is not accepted by Math.*, and is not serialisable by JSON.stringify without a toJSON/replacer. Relational comparison (<, >, ==) does work across the two types because it cannot lose precision.

1.4 -0 and NaN

IEEE-754 has two zeros and a quiet NaN with no identity.

console.log(-0 === 0);               // true      <- === cannot see the sign
console.log(Object.is(-0, 0));       // false     <- Object.is can
console.log(1 / -0);                 // -Infinity <- the usual way to detect it before Object.is
console.log(String(-0));             // '0'       <- ToString normalises
console.log(JSON.stringify(-0));     // '0'
console.log([-0].includes(0));       // true      <- SameValueZero
console.log([-0].indexOf(0));        // 0         <- strict equality
console.log(Math.round(-0.4));       // -0        <- an easy way to produce one accidentally
console.log(Math.sign(-0));          // -0

console.log(NaN === NaN);            // false
console.log(Object.is(NaN, NaN));    // true
console.log([NaN].includes(NaN));    // true      <- SameValueZero
console.log([NaN].indexOf(NaN));     // -1        <- strict equality
console.log(new Set([NaN, NaN]).size); // 1       <- SameValueZero
console.log(isNaN('foo'), Number.isNaN('foo'));  // true false
console.log(Math.max(), Math.min());             // -Infinity Infinity

isNaN coerces its argument first (isNaN('foo') is isNaN(NaN)), which is almost never what you want. Number.isNaN does not coerce. Same story for parseInt/parseFloat vs Number.

1.5 The three (four) equality algorithms

a, b              | ==    | ===   | Object.is
------------------+-------+-------+----------
0, -0             | true  | true  | false
NaN, NaN          | false | false | true
1, "1"            | true  | false | false
null, undefined   | true  | false | false

Note that Map and Set use SameValueZero, and they normalise -0 to +0 on insert:

const m = new Map();
m.set(NaN, 'nan').set(-0, 'minus zero');
m.get(NaN);                                 // 'nan'
m.get(0);                                   // 'minus zero'
Object.is([...m.keys()][1], 0);             // true — stored as +0

1.6 The abstract equality algorithm, in full

x == y (ECMAScript IsLooselyEqual) runs top to bottom; the first matching rule wins:

1. If Type(x) is Type(y), return x === y.
2. null == undefined and undefined == null → true.
3. Number == String → x == ToNumber(y).
4. String == Number → ToNumber(x) == y.
5. BigInt == String → StringToBigInt(y); if it fails, false.
6. Boolean on either side → ToNumber(boolean) == other (so true → 1, false → 0).
7. Number|BigInt|String|Symbol == Object → x == ToPrimitive(y).
8. Object == Number|BigInt|String|Symbol → ToPrimitive(x) == y.
9. BigInt vs Number → mathematically equal (no precision loss), false for NaN/±Infinity.
10. Otherwise false.

Two consequences worth memorising: null/undefined are loosely equal only to each other and to nothing else (null == 0 is false — rule 2 fires before any numeric coercion), and an object is never loosely equal to a boolean without going through ToPrimitive then ToNumber.

Measured surprises (02-equality.js):

expression                | result
--------------------------+--------
[] == ![]                 | true
[] == false               | true
[] == ""                  | true
[] == 0                   | true
[[]] == 0                 | true
[0] == false              | true
[1] == true               | true
[2] == true               | false
null == undefined         | true
null === undefined        | false
null == 0                 | false
null >= 0                 | true
null > 0                  | false
undefined == 0            | false
NaN == NaN                | false
"" == 0                   | true
"0" == 0                  | true
"" == "0"                 | false
" \t\n" == 0              | true
false == "false"          | false
false == "0"              | true
true == "1"               | true
null == false             | false
undefined == false        | false
{} == "[object Object]"   | true
new String("a") == "a"    | true
new String("a") === "a"   | false
Symbol() == Symbol()      | false
1n == 1                   | true

Walk through [] == ![] out loud in an interview:

1. ![] — every object is truthy, so this is false.
2. [] == false — rule 6: the boolean becomes 0, giving [] == 0.
3. Rule 8: ToPrimitive([]) with default hint → valueOf returns the array itself (not primitive) → toString → [].join(',') → "".
4. "" == 0 — rule 4: ToNumber("") is 0.
5. 0 == 0 → true.

And null >= 0 === true while null > 0 === false and null == 0 === false: relational operators use ToNumber (null → 0, so 0 >= 0), but == has that special-cased rule 2 that short-circuits before any numeric coercion. This also means == is not transitive:

"" == 0        -> true
0 == "0"       -> true
"" == "0"      -> false

1.7 ToPrimitive and Symbol.toPrimitive

Intuition. Whenever an object must become a primitive, the engine calls ToPrimitive(obj, hint) where hint is "number", "string" or "default". If obj[Symbol.toPrimitive] exists it is used; otherwise the engine tries valueOf then toString for the number/default hints, and toString then valueOf for the string hint. Date is the one built-in that treats "default" as "string".

const traced = {
  [Symbol.toPrimitive](hint) {
    console.log('  hint:', hint);
    return hint === 'number' ? 42 : 'forty-two';
  },
};
+traced;          // hint: number  -> 42
`${traced}`;      // hint: string  -> 'forty-two'
traced + '';      // hint: default -> 'forty-two'
traced * 2;       // hint: number  -> 84
String(traced);   // hint: string
traced == 42;     // hint: default -> 'forty-two' == 42 -> false

  Symbol.toPrimitive called with hint: number
  +traced      -> 42
  Symbol.toPrimitive called with hint: string
  `${traced}`  -> forty-two
  Symbol.toPrimitive called with hint: default
  traced + ""  -> forty-two
  Symbol.toPrimitive called with hint: number
  traced * 2   -> 84
  Symbol.toPrimitive called with hint: string
  String(traced)-> forty-two
  Symbol.toPrimitive called with hint: default
  traced == 42 -> false

Without Symbol.toPrimitive:

Without Symbol.toPrimitive, valueOf then toString (default/number hint):
  valueOf
  vt + 1   -> 8
  toString
  `${vt}`  -> seven
  valueOf
  vt * 2   -> 14
  toString
  [vt] + ""-> seven

Which operators use which hint:

Template literal coercion always uses the string hint and calls ToString, not String() on symbols — `${Symbol()}` throws a TypeError while String(Symbol()) works. Arrays stringify by join(','), and null/undefined inside an array join to the empty string:

[].toString()                 -> ""
[1,2].toString()              -> "1,2"
[null, undefined].toString()  -> ","
[[1,[2]],3].toString()        -> "1,2,3"

Pitfalls

• parseInt without a radix used to be octal-sensitive; modern engines default to 10 except for a 0x prefix, but ['1','7','11'].map(parseInt) is still [1, NaN, 3] because map passes the index as the second argument (the radix).
• x == null is the one loose comparison worth using deliberately: it means “null or undefined” and nothing else. Most style guides allow it explicitly.
• +new Date() and new Date() - 0 are numbers; new Date() + 0 is a string. That is the default hint special case.
• JSON.stringify drops undefined, functions and symbols in objects, and turns them into null inside arrays. It also turns NaN/Infinity into null.
• Sorting numbers without a comparator sorts them as strings: [10, 9, 1].sort() is [1, 10, 9].

Interview follow-ups

Q: Why is typeof null === 'object'?

A: In the original implementation values were tagged in the low bits of a machine word; the object tag was 000 and the null pointer was all-zero bits, so it read as an object. Fixing it was proposed and rejected as web-breaking.

Q: How do you check “is this an integer” safely?

A: Number.isInteger(x) for representability, Number.isSafeInteger(x) if you also need x ± 1 to be distinguishable. x % 1 === 0 also accepts Infinity-adjacent nonsense and coerces strings.

Q: Why does 0.1 + 0.2 !== 0.3 but 0.5 + 0.25 === 0.75?

A: 0.5 and 0.25 are negative powers of two, so they are exact in binary; 0.1 and 0.2 are repeating binary fractions and get rounded to the nearest double, and the rounding errors do not cancel.

Q: When is == acceptable?

A: x == null. Everywhere else use === — the coercion table is not something a reviewer should have to hold in their head.

Q: What is the difference between Object.is and ===?

A: Only two cases: Object.is(NaN, NaN) is true where === is false, and Object.is(0, -0) is false where === is true. Everything else is identical.

Q: Why does new String('a') == 'a' but !== 'a'?

A: == applies ToPrimitive to the wrapper object (rule 8) producing the primitive 'a'; === compares types first and an object is never strictly equal to a string.

2. Scope, hoisting, closures and this

2.1 var, let, const and the temporal dead zone

Intuition. All declarations are hoisted — the binding is created when the scope is entered. The difference is initialisation. var bindings are initialised to undefined immediately; let/const bindings stay in the temporal dead zone until control flow reaches the declaration. The TDZ is a runtime state, not a syntactic region: a function defined before the let but called after it works fine.

// 03-scope.js
console.log('typeof hoistedFn :', typeof hoistedFn);   // function — full declaration hoisting
console.log('varX before decl :', typeof varX, varX);  // undefined undefined
try { letY; } catch (e) { console.log(e.constructor.name + ': ' + e.message); }
function hoistedFn() {}
var varX = 1;
let letY = 2;

console.log('typeof neverDeclared :', typeof neverDeclared);  // 'undefined' — safe
try { typeof tdzVar; } catch (e) { console.log('typeof tdzVar :', e.constructor.name); }
let tdzVar = 1;

typeof hoistedFn : function
varX before decl : undefined undefined
letY before decl : ReferenceError: Cannot access 'letY' before initialization
typeof neverDeclared : undefined
typeof tdzVar        : ReferenceError

That last pair is the point people miss: typeof is not a safe probe for a TDZ binding, only for a completely undeclared identifier.

const freezes the binding, not the value:

const object mutated : { a: 2 }
reassign const       : TypeError
frozen               : true
write to frozen      : TypeError (strict); silent no-op in sloppy
after frozen write   : { a: 2 }

2.2 Function scope vs block scope, and function declarations in blocks

blockFn in block    : block
blockFn after block : undefined

In a strict-mode script/module a function declaration inside a block is block-scoped. In sloppy mode, Annex B web-compat semantics hoist a var-like binding to the enclosing function scope and assign it when the declaration is evaluated — which is why the name exists but is undefined after the block in some configurations and defined in others. Never rely on it; use const fn = () => {} inside blocks.

2.3 Closures

Intuition. A closure is a function together with the environment record it captured. V8 allocates a Context object on the heap for exactly the variables an inner function references (it does escape analysis at parse time via the pre-parser), and every closure created in the same scope shares that one context. Two calls to the enclosing function create two contexts.

scope chain at call time

  [ inner function ]
        │ [[Environment]]
        ▼
  [ Context: { count: 2 } ]  ← shared by every closure from the same call
        │ outer
        ▼
  [ module/script scope ]
        │ outer
        ▼
  [ global scope ] → null

function counter() {
  let count = 0;
  return { inc: () => ++count, get: () => count };
}
const c1 = counter(), c2 = counter();
c1.inc(); c1.inc(); c2.inc();
console.log(c1.get(), c2.get());     // 2 1 — independent contexts

2.4 The classic for (var i) bug and three fixes

const varFns = [];
for (var i = 0; i < 3; i++) varFns.push(() => i);
varFns.map((f) => f());              // [3, 3, 3]

// fix 1: let — the spec creates a NEW binding per iteration and copies the value forward
const letFns = [];
for (let j = 0; j < 3; j++) letFns.push(() => j);
letFns.map((f) => f());              // [0, 1, 2]

// fix 2: IIFE — an explicit new scope per iteration
const iifeFns = [];
for (var k = 0; k < 3; k++) iifeFns.push(((captured) => () => captured)(k));
iifeFns.map((f) => f());             // [0, 1, 2]

// fix 3: bind — freeze the value as a bound argument
const bindFns = [];
for (var m = 0; m < 3; m++) bindFns.push(((x) => x).bind(null, m));
bindFns.map((f) => f());             // [0, 1, 2]

var loop (bug):
   [ 3, 3, 3 ]
let loop (fix 1 - per-iteration binding):
   [ 0, 1, 2 ]
IIFE (fix 2):
   [ 0, 1, 2 ]
bind (fix 3):
   [ 0, 1, 2 ]

The mechanism behind fix 1 is worth knowing precisely: for a let head, the spec runs CreatePerIterationEnvironment before each iteration, which creates a fresh binding and copies the previous iteration’s value into it. That is why the increment j++ still works across iterations even though each closure sees a different binding. const in a for(;;) head is a SyntaxError for exactly this reason (you cannot increment it); for (const x of xs) is fine because there is no increment.

2.5 IIFE and module scope

Before modules, the IIFE was the only way to get a private scope:

var MyLib = (function () {
  var privateState = 0;
  return { bump: function () { return ++privateState; } };
})();

ESM made this obsolete: every module has its own scope, var at module top level does not touch globalThis, and modules are always strict. In CommonJS the module body is wrapped by Node in a function with (exports, require, module, __filename, __dirname), so module scope is function scope — which is why this at CJS top level is module.exports (an object) while in ESM it is undefined.

arrow as method       : module.exports = {}     // CJS
module-scope this     : undefined               // ESM

2.6 this: the five binding rules

Resolve them in this priority order at the call site:

1. new binding — new Fn() creates a fresh object whose prototype is Fn.prototype and binds this to it.
2. Explicit binding — fn.call(o), fn.apply(o), fn.bind(o). A bound function’s this cannot be re-bound later.
3. Implicit binding — o.fn(); this is o. Only the last property access matters.
4. Default binding — a bare fn(). undefined in strict mode/modules, globalThis in sloppy.
5. Arrow functions — no own this at all; they close over the this of the enclosing lexical scope, and this beats every rule above (you cannot call/bind an arrow’s this).

// 04-this.js
const obj = { name: 'obj', who() { return this?.name; } };
obj.who();                     // 'obj'
const detached = obj.who;
detached();                    // undefined (strict)
(0, obj.who)();                // undefined — the comma operator discards the Reference
obj.who.call({ name: 'call' });// 'call'

const hard = obj.who.bind({ name: 'first' });
hard.call({ name: 'second' }); // 'first' — hard binding wins

function Person(name) { this.name = name; }
const BoundPerson = Person.bind({ name: 'ignored' });
new BoundPerson('still-works').name;   // 'still-works' — new beats bind

strict default this   : undefined
sloppy default this   : globalThis
obj.who()             : obj
detached()            : undefined
wrapper.inner.who()   : obj
(0, obj.who)()        : undefined
call/apply/bind       : call apply bind
rebind a bound fn     : first
new binding           : newed
new on bound ctor     : still-works
arrow in method       : lex
new Arrow             : TypeError
detached method       : undefined
detached field arrow  : widget
static block ran      : true | static field: Widget
static this === class : true

The key insight for this questions: this is determined by how a function is called, not where it is defined — except for arrows, which are the exact opposite.

2.7 Losing this, and the four fixes

class Timer {
  ticks = 0;
  incBroken() { this.ticks++; }       // prototype method — needs a receiver
  incArrow = () => { this.ticks++; }; // instance field — captures `this` at construction
}
const t = new Timer();
[1].forEach(t.incBroken);             // TypeError: this is undefined
[1].forEach(t.incBroken.bind(t));     // fix 1: bind
[1].forEach(() => t.incBroken());     // fix 2: arrow wrapper
[1].forEach(t.incArrow);              // fix 3: class field arrow
[1].forEach(t.incBroken, t);          // fix 4: the thisArg parameter many array methods take

forEach(t.incBroken) -> TypeError
bind        -> ticks=1
arrow wrap  -> ticks=2
field arrow -> ticks=3
thisArg     -> ticks=4

bind vs class-field arrow. A prototype method exists once per class and lives on Class.prototype, so it is shared, patchable, spy-able in tests, and visible to super. A class-field arrow is created per instance during construction: N instances means N closures and N property slots, it is not on the prototype (so super.method() and subclass overrides do not see it), and it cannot be stubbed via the prototype. Prefer prototype methods plus bind in the constructor when you need a stable identity, or bind at the call site. Use field arrows when the ergonomics of React-style handlers matter more than the memory.

2.8 new.target

new.target is undefined in a normal call and the constructor function in a new call. Inside a derived constructor after super(), it is the most-derived constructor.

function Guard() {
  if (new.target === undefined) return 'called without new';
  return 'constructed as ' + new.target.name;
}
class Base { constructor() { this.builtBy = new.target.name; } }
class Derived extends Base {}
new Derived().builtBy;      // 'Derived'

Guard()               : called without new
new.target in super   : Derived

This is how you write an abstract class (if (new.target === Abstract) throw ...) and how Babel’s class downlevelling implements the “class constructor cannot be invoked without new” check.

Pitfalls

• A let inside a loop body (not the head) is a fresh binding per iteration too; a let in the head of a while loop is not — while has no per-iteration environment.
• this inside a plain callback passed to setTimeout is Timeout in Node and window in browsers, not your object.
• Class fields are initialised in order, after super(), so a field cannot reference a field declared below it, and a base-class constructor cannot see a derived class’s fields (they do not exist yet). This is a real source of undefined in TypeScript classes with strictPropertyInitialization.
• Closures over loop variables inside setTimeout still surprise people in code review; if you see var in a loop with any async callback, it is a bug or about to be one.
• Arrow functions have no arguments, no prototype, cannot be newed, and cannot be generators.

Interview follow-ups

Q: Is the TDZ a compile-time or runtime concept?

A: Runtime. The binding exists from scope entry but is marked uninitialised; any read before the declaration executes throws ReferenceError. That is why a function that closes over a let can be defined earlier as long as it is called later.

Q: What does let cost compared to var?

A: Effectively nothing in modern V8 for straight-line code. In loops, the per-iteration environment can mean an extra context allocation per iteration if something captures the binding; if nothing captures it, V8 optimises the copy away.

Q: How do you make truly private state?

A: #private fields (hard-private, enforced by the engine, brand-checked), a closure, or a WeakMap keyed by the instance. _underscore is a convention, not privacy.

Q: Why does (0, obj.method)() lose this?

A: obj.method evaluates to a Reference with a base of obj. The comma operator calls GetValue on it, producing the bare function value and discarding the base, so the call uses default binding.

Q: What is the difference between fn.call(null) in strict and sloppy mode?

A: Sloppy mode applies ToObject to the thisArg and substitutes globalThis for null/undefined; strict mode passes the value through untouched.

Q: Can you bind an arrow function?

A: You can call .bind() on it — it returns a new function — but the this argument is ignored, because an arrow has no this binding to set. Bound arguments still work.

3. Objects and prototypes

3.1 Property descriptors

Every own property is a descriptor, one of two shapes:

Literal syntax creates writable: true, enumerable: true, configurable: true. Object.defineProperty defaults every omitted flag to false.

const o = {};
o.a = 1;                                  // all true
Object.defineProperty(o, 'b', { value: 2 }); // all false

console.log(Object.getOwnPropertyDescriptor(o, 'a'));
console.log(Object.getOwnPropertyDescriptor(o, 'b'));
console.log(Object.keys(o));   // 'b' is non-enumerable
o.b = 99;                      // silently ignored in sloppy mode, TypeError in strict
console.log(o.b);

{ value: 1, writable: true, enumerable: true, configurable: true }
{ value: 2, writable: false, enumerable: false, configurable: false }
[ 'a' ]
2

configurable: false is the only irreversible flag: you cannot make a property configurable again, and you cannot delete it or change it from data to accessor. The one legal mutation is writable: true -> false.

Freezing levels, weakest to strongest:

All three are shallow. A deep freeze is a recursive walk (watch for cycles).

3.2 The prototype chain

[[Prototype]] is an internal slot. Three different things share the word “prototype”:

Lookup walks the chain on read, but assignment does not: obj.x = 1 creates an own property on obj even if x exists up the chain — unless the inherited property is a setter or a non-writable data property.

const d = new Dog('Rex')

  d ──[[Proto]]──> Dog.prototype ──[[Proto]]──> Animal.prototype ──[[Proto]]──> Object.prototype ──> null
  own: name              own: bark                   own: speak                     own: toString, hasOwnProperty, ...

function Animal(name) { this.name = name; }
Animal.prototype.speak = function () { return `${this.name} makes a noise`; };
function Dog(name) { Animal.call(this, name); }
Dog.prototype = Object.create(Animal.prototype);   // link
Dog.prototype.constructor = Dog;                   // repair
Dog.prototype.bark = function () { return `${this.name}: woof`; };

const d = new Dog('Rex');
console.log(d.bark(), '|', d.speak());
console.log(Object.getPrototypeOf(d) === Dog.prototype);
console.log(d instanceof Animal, Object.prototype.hasOwnProperty.call(d, 'speak'));

Rex: woof | Rex makes a noise
true
true false

Dog.prototype = Animal.prototype (a common mistake) would make Dog.prototype.bark also visible on every Animal, because there is only one object.

3.3 instanceof and Symbol.hasInstance

a instanceof B asks: is B.prototype anywhere in a’s prototype chain? It is therefore a question about objects, not constructors, and it breaks across realms (an array from an iframe or a Node vm context is not instanceof Array in your realm — use Array.isArray).

class Even { static [Symbol.hasInstance](x) { return typeof x === 'number' && x % 2 === 0; } }
console.log(4 instanceof Even, 5 instanceof Even);   // true false

3.4 class is sugar — but not only sugar

What class gives you beyond the ES5 pattern:

• The body is always strict mode.
• Methods are non-enumerable (Object.keys(Dog.prototype) is empty for a class).
• The constructor cannot be called without new (TypeError).
• Class declarations are hoisted but in the TDZ, so no use-before-declaration.
• extends also links the constructors (Object.getPrototypeOf(Dog) === Animal), which is how static members are inherited. The ES5 pattern needs an explicit second link.
• Derived constructors have no this until super() returns; the base constructor is what actually allocates the object, which is why extends Array works and the ES5 trick does not.
• #private fields are enforced by the engine, not by convention, and are not visible to Object.keys, JSON.stringify, Proxy traps, or the debugger’s normal property view.

class Counter {
  #n = 0;                                   // private instance field
  static #instances = 0;                    // private static
  static { Counter.registry = new Set(); }  // static initialization block
  id = ++Counter.#instances;                // public field, runs per-instance before ctor body
  constructor() { Counter.registry.add(this); }
  inc() { return ++this.#n; }
  get value() { return this.#n; }
  static has(o) { return #n in o; }         // ergonomic brand check
}
const c = new Counter();
c.inc(); c.inc();
console.log(c.value, c.id, Counter.has(c), Counter.has({}));
console.log(Object.keys(c));                // fields are enumerable; methods are not

2 1 true false
[ 'id' ]

Field-vs-method ordering trap. Public/private fields are installed in order, before the constructor body, and each initializer sees this. A field initialized with an arrow function is a per-instance property (bound this, costs memory per instance); a method is one shared function on the prototype (unbound this, cheap). That is the real trade-off behind onClick = () => {} in class components.

3.5 super needs a home object

super is not dynamic. It resolves through the method’s [[HomeObject]], set when the method is defined with shorthand syntax. Assign a function to a property instead and super is a SyntaxError.

const base = { greet() { return 'base'; } };
const good = { __proto__: base, greet() { return super.greet() + '+good'; } };
console.log(good.greet());          // base+good
// const bad = { __proto__: base, greet: function () { return super.greet(); } }; // SyntaxError

3.6 Mixins

There is no multiple inheritance, so the idiom is a function from class to class:

type Ctor<T = {}> = new (...args: any[]) => T;

const Serializable = <T extends Ctor>(Base: T) =>
  class extends Base { toJSON() { return { ...this }; } };

const Timestamped = <T extends Ctor>(Base: T) =>
  class extends Base { createdAt = new Date(0); };

class Model {}
class User extends Serializable(Timestamped(Model)) {
  constructor(public name: string) { super(); }
}
console.log(JSON.stringify(new User('ana')));

{"createdAt":"1970-01-01T00:00:00.000Z","name":"ana"}

Each mixin adds a real link in the prototype chain, so instanceof on the mixin is not available (that is what Symbol.hasInstance is for).

Pitfalls

• for...in walks enumerable inherited properties. Use Object.keys/entries, or Object.hasOwn(obj, k) (ES2022) as the guard. Never obj.hasOwnProperty(k) on untrusted objects.
• Mutating Object.prototype (or Array.prototype) breaks every for...in on the page and deoptimizes property access globally.
• Object.assign copies values, invoking getters and losing descriptors. Object.defineProperties(target, Object.getOwnPropertyDescriptors(src)) is the faithful copy.
• Spread and Object.assign only copy own enumerable string and symbol keys — not the prototype.
• JSON.stringify drops undefined, functions, and symbols; turns Date into a string; throws on cycles and on BigInt; and calls toJSON if present.
• delete obj.k is fine on plain objects but on arrays it creates a hole (see elements kinds).

Interview follow-ups

Q: What is the difference between Object.create(null) and {}?

A: The former has no prototype: no toString, no __proto__ accessor, no hasOwnProperty. That makes it the correct choice for a string-keyed dictionary because a key named __proto__ or constructor cannot collide with anything or trigger prototype pollution.

Q: How do you implement new yourself?

A: function myNew(Ctor, ...args) { const obj = Object.create(Ctor.prototype); const r = Ctor.apply(obj, args); return (typeof r === 'object' && r !== null) || typeof r === 'function' ? r : obj; } — the return-value rule is the part people forget.

Q: Why is Object.freeze not enough for immutability?

A: It is shallow, it does not stop mutation of objects reachable through frozen properties, and it does not prevent Map/Set contents from changing. Use a recursive freeze or a persistent-data-structure library.

Q: What does class A extends null do?

A: It is legal syntax but nearly unusable: you cannot call super(), so the only way to construct an instance is to return an object explicitly from the constructor.

Q: How would you check whether an object has a private field without throwing?

A: The #field in obj brand check (ES2022), typically wrapped in a static method as shown above.

Q: Prototype vs class inheritance — is there a performance difference?

A: No meaningful one; class compiles to the same shapes. The real performance lever is keeping object shapes consistent so inline caches stay monomorphic.

4. Functions

4.1 Parameters, arity, and arguments

function f(a, b = 2, ...rest) {}
console.log(f.length);   // 1 — stops at the first default or rest param

arguments is array-like, not an array; it is absent in arrow functions and in any function with default/rest/destructured parameters it is unmapped (no live link to the named parameters). Use rest parameters instead — they are a real array and do not force V8 to materialize an arguments object.

4.2 Currying and partial application

type AnyFn = (...args: any[]) => any;

function curry<F extends AnyFn>(fn: F) {
  const arity = fn.length;
  return function curried(...args: any[]): any {
    return args.length >= arity ? fn(...args) : (...more: any[]) => curried(...args, ...more);
  };
}

const volume = (l: number, w: number, h: number) => l * w * h;
const cv = curry(volume);
console.log(cv(2)(3)(4), cv(2, 3)(4), cv(2)(3, 4), cv(2, 3, 4));   // 24 24 24 24

Partial application is the weaker, cheaper cousin: fn.bind(null, 2, 3).

4.3 Composition

const pipe = <T>(...fns: Array<(x: T) => T>) => (x: T) => fns.reduce((v, f) => f(v), x);
const compose = <T>(...fns: Array<(x: T) => T>) => (x: T) => fns.reduceRight((v, f) => f(v), x);

const inc = (n: number) => n + 1, dbl = (n: number) => n * 2;
console.log(pipe(inc, dbl)(5), compose(inc, dbl)(5));   // 12 11

Properly variadic typed pipe needs variadic tuple types — see TypeScript: tuples and variadic types.

4.4 Memoization

function memoize<A, R>(fn: (a: A) => R, keyFn: (a: A) => unknown = (a) => a) {
  const cache = new Map<unknown, R>();
  return (a: A): R => {
    const k = keyFn(a);
    if (cache.has(k)) return cache.get(k)!;
    const v = fn(a);
    cache.set(k, v);
    return v;
  };
}

// Object keys without leaking: WeakMap lets the key be collected.
function memoizeObject<T extends object, R>(fn: (t: T) => R) {
  const cache = new WeakMap<T, R>();
  return (t: T): R => {
    let v = cache.get(t);
    if (v === undefined && !cache.has(t)) { v = fn(t); cache.set(t, v); }
    return v as R;
  };
}

The three real-world questions an interviewer will push on: what is the cache key for multiple arguments (JSON.stringify is correct-ish and slow; a nested Map trie is correct and fast), how do you bound the cache (LRU — see Data structures), and how do you avoid leaking (WeakMap for object keys, TTL/size caps otherwise).

4.5 Debounce and throttle

function debounce<F extends (...a: any[]) => void>(fn: F, ms: number, immediate = false) {
  let t: ReturnType<typeof setTimeout> | null = null;
  return function (this: unknown, ...args: Parameters<F>) {
    const callNow = immediate && t === null;
    if (t) clearTimeout(t);
    t = setTimeout(() => { t = null; if (!immediate) fn.apply(this, args); }, ms);
    if (callNow) fn.apply(this, args);
  };
}

function throttle<F extends (...a: any[]) => void>(fn: F, ms: number) {
  let last = 0, pending: Parameters<F> | null = null, timer: any = null;
  return function (this: unknown, ...args: Parameters<F>) {
    const now = Date.now();
    if (now - last >= ms) { last = now; fn.apply(this, args); }
    else {                                       // trailing edge
      pending = args;
      timer ??= setTimeout(() => {
        last = Date.now(); timer = null;
        if (pending) { fn.apply(this, pending); pending = null; }
      }, ms - (now - last));
    }
  };
}

4.6 Interview follow-ups

Q: Implement Function.prototype.bind.

A:

Function.prototype.myBind = function (thisArg, ...bound) {
  const target = this;
  if (typeof target !== 'function') throw new TypeError('not callable');
  function Bound(...args) {
    // called with `new`: ignore thisArg, keep the prototype chain
    return target.apply(this instanceof Bound ? this : thisArg, [...bound, ...args]);
  }
  Bound.prototype = Object.create(target.prototype || null);
  return Bound;
};

Q: Why can’t you tail-call-optimize in Node?

A: ES2015 specifies proper tail calls, but only JavaScriptCore ever shipped them. V8 removed its implementation (stack-trace and debugging costs, plus a syntactic-vs-implicit design argument), so deep recursion in Node overflows around 11k frames. Convert to an explicit loop or an explicit stack.

Q: What is a pure function and why does it matter here?

A: Same inputs -> same output, no observable side effects. It is the precondition for memoization, for safe parallelism, and for the referential-transparency arguments you will use when justifying a refactor.

Q: fn.call vs fn.apply vs fn.bind?

A: call invokes now with spread arguments, apply invokes now with an array, bind invokes later and returns a new function with this and leading arguments fixed. bind is the only one that survives being passed around.

5. Iterators and generators

5.1 The protocol

An object is iterable if it has a [Symbol.iterator]() method returning an iterator: an object with next() returning { value, done }. for...of, spread, destructuring, Array.from, Promise.all, new Map(...) and yield* all consume it.

class Range implements Iterable<number> {
  constructor(private lo: number, private hi: number, private step = 1) {}
  [Symbol.iterator](): Iterator<number> {
    let i = this.lo;
    const { hi, step } = this;
    return {
      next: () => (i < hi ? { value: (i += step) - step, done: false } : { value: undefined, done: true }),
      return: () => { i = hi; return { value: undefined, done: true }; },   // called on break
    };
  }
}
console.log([...new Range(0, 10, 3)]);   // [ 0, 3, 6, 9 ]

The return() method is the cleanup hook: break, throw, and early return inside for...of all call it. That is how using-style resource release works for iterators.

5.2 Generators

A generator function returns an object that is both an iterator and an iterable, and whose execution suspends at each yield.

function* fib() { let [a, b] = [0, 1]; for (;;) { yield a; [a, b] = [b, a + b]; } }
function* take(it, n) { let i = 0; for (const v of it) { if (i++ >= n) return; yield v; } }
console.log([...take(fib(), 10)]);   // [0,1,1,2,3,5,8,13,21,34]

Two-way communication makes generators coroutines, not just lazy lists:

function* accumulator() {
  let total = 0;
  while (true) {
    const x = yield total;          // the value passed to next() lands here
    if (x === undefined) continue;
    total += x;
  }
}
const acc = accumulator();
acc.next();                          // prime: run to the first yield
console.log(acc.next(5).value, acc.next(10).value, acc.next(1).value);   // 5 15 16

• gen.next(v) — resume, yield evaluates to v.
• gen.throw(e) — resume by raising e at the suspended yield (catchable inside).
• gen.return(v) — resume as if a return v executed there; finally blocks still run.
• yield* delegates to another iterable and evaluates to its return value.

function* inner() { yield 1; yield 2; return 'inner done'; }
function* outer() { const r = yield* inner(); yield r; }
console.log([...outer()]);   // [ 1, 2, 'inner done' ]

5.3 Async iteration

Symbol.asyncIterator + for await...of. Each next() returns a promise.

async function* pages(total) {
  for (let p = 1; p <= total; p++) {
    await new Promise(r => setTimeout(r, 10));       // pretend fetch
    yield { page: p, items: [p * 10, p * 10 + 1] };
  }
}
(async () => {
  for await (const { page, items } of pages(3)) console.log(page, items);
})();

1 [ 10, 11 ]
2 [ 20, 21 ]
3 [ 30, 31 ]

for await also accepts a sync iterable of promises, awaiting each in turn — which is a common source of accidental serialization. If you want concurrency, collect promises and Promise.all them.

5.4 Iterator helpers (ES2026, shipped in Node 22)

Iterator helpers put lazy map/filter/take/drop/flatMap/reduce/toArray/some/every/find on Iterator.prototype, so they work on generators, Map.keys(), NodeList iterators — anything.

function* naturals() { let n = 1; while (true) yield n++; }
let evaluated = 0;
const out = naturals()
  .map(n => { evaluated++; return n * n; })
  .filter(n => n % 2 === 1)
  .take(4)
  .toArray();
console.log(out, 'source values pulled:', evaluated);

[ 1, 9, 25, 49 ] source values pulled: 7

Seven pulls, not infinity — the pipeline is demand-driven, and no intermediate array is ever built. Compare with array.map().filter().slice(), which allocates two full intermediates. Iterator.from(x) wraps a bare iterator so the helpers are available.

Pitfalls

• Generators are single-pass. const g = gen(); [...g]; [...g] gives you the values then []. Return a fresh generator from [Symbol.iterator]() if you need repeat iteration.
• yield inside a non-generator callback (arr.forEach(x => yield x)) is a SyntaxError; use a for...of loop.
• return inside a try with a finally that also returns: the finally wins, silently.
• Spreading an infinite iterator hangs the process. take first.
• for await over an array of promises awaits sequentially. Promise.all is what you usually want.

Interview follow-ups

Q: Difference between an iterable and an iterator?

A: An iterable has [Symbol.iterator](); an iterator has next(). Generators are both, which is why for...of over a generator works and why you can only do it once.

Q: How do you make an object work with spread and for...of?

A: Give it [Symbol.iterator]. Object spread ({...o}) is different — it copies own enumerable keys and needs no protocol.

Q: Where would you actually use a generator in production?

A: Paginated API traversal, streaming parsers, ID generators, tree/graph traversal you want to consume lazily, backtracking search where you want the first N solutions, and test-data builders. Redux-saga made the coroutine use case famous.

Q: What is the memory advantage?

A: O(1) instead of O(n): you never materialize the sequence. Combined with iterator helpers you get a full lazy pipeline. See the Python equivalent in Python core.

6. Asynchrony and the event loop

6.1 The model

graph TD
    A["Synchronous script"] --> B["process.nextTick queue"]
    B --> C["Microtask queue"]
    C --> D["timers<br/>(setTimeout/setInterval)"]
    D -->|drain nextTick + microtasks| E["pending callbacks"]
    E -->|drain nextTick + microtasks| F["poll<br/>(I/O)"]
    F -->|drain nextTick + microtasks| G["check<br/>(setImmediate)"]
    G -->|drain nextTick + microtasks| H["close callbacks"]
    H -->|drain nextTick + microtasks| B

JavaScript has one call stack. Anything asynchronous is a job enqueued for later. There are two queue tiers, and the rule that explains almost every puzzle is:

After every macrotask, and after the synchronous script finishes, the engine drains the entire microtask queue — including microtasks enqueued by microtasks — before taking the next macrotask.

Node adds one queue above microtasks: process.nextTick. Priority is nextTick queue -> microtask queue -> next libuv phase.

6.2 Node’s libuv phases

   ┌───────────────────────────┐
┌─>│           timers          │  setTimeout / setInterval callbacks whose time has come
│  └────────────┬──────────────┘
│  ┌────────────┴──────────────┐
│  │     pending callbacks     │  deferred I/O callbacks (e.g. some TCP errors)
│  └────────────┬──────────────┘
│  ┌────────────┴──────────────┐
│  │       idle, prepare       │  internal
│  └────────────┬──────────────┘      ┌───────────────┐
│  ┌────────────┴──────────────┐      │   incoming:   │
│  │           poll            │<─────┤  connections, │  waits for I/O; this is where the
│  └────────────┬──────────────┘      │   data, ...   │  process actually blocks
│  ┌────────────┴──────────────┐      └───────────────┘
│  │           check           │  setImmediate callbacks
│  └────────────┬──────────────┘
│  ┌────────────┴──────────────┐
└──┤       close callbacks     │  socket.on('close'), etc.
   └───────────────────────────┘

   Between EVERY phase transition: drain nextTick queue, then drain microtask queue.

Practical consequences:

• setTimeout(fn, 0) is really “at least 1 ms” and runs in the timers phase — a full loop turn away.
• setImmediate(fn) runs in the check phase, i.e. after the current poll phase, which for I/O callbacks means sooner than setTimeout(fn, 0). From the main module the ordering of setTimeout(0) vs setImmediate is famously nondeterministic (it depends on how long process startup took relative to the 1 ms timer threshold).
• process.nextTick runs before any promise callback and can starve the loop if it recurses.

6.3 Predict-the-output puzzles

Puzzle 1 — every queue at once.

console.log('1 sync');
setTimeout(() => console.log('2 setTimeout 0'), 0);
setImmediate(() => console.log('3 setImmediate'));
process.nextTick(() => console.log('4 nextTick'));
Promise.resolve().then(() => console.log('5 microtask'));
queueMicrotask(() => console.log('6 queueMicrotask'));
(async () => { console.log('7 async body sync'); await null; console.log('8 after await'); })();
console.log('9 sync end');

1 sync
7 async body sync
9 sync end
4 nextTick
5 microtask
6 queueMicrotask
8 after await
2 setTimeout 0
3 setImmediate

Read it as three groups: everything synchronous (1, 7, 9 — note the async function body runs synchronously up to its first await), then nextTick, then microtasks in FIFO order (5, 6, 8 — the await null resumption is just another microtask, queued third), then macrotasks.

Puzzle 2 — await costs one tick, not two.

async function a() { console.log('a1'); await b(); console.log('a2'); }
async function b() { console.log('b1'); }
console.log('start');
a();
new Promise(r => { console.log('p exec'); r(); }).then(() => console.log('p then'));
console.log('end');

start
a1
b1
p exec
end
a2
p then

a2 beats p then. Since the ES2019 “await optimization”, awaiting a native promise costs one microtask tick, not three — so a’s continuation is queued before the .then registered afterwards. Interviewers who learned this pre-2019 sometimes expect the opposite; if the awaited value is a thenable (not a native promise) you pay the extra ticks and the order flips.

Puzzle 3 — interleaving nextTick and microtasks.

setTimeout(() => console.log('timeout'), 0);
Promise.resolve().then(() => { console.log('mt1'); process.nextTick(() => console.log('tick in mt')); });
process.nextTick(() => { console.log('tick1'); Promise.resolve().then(() => console.log('mt in tick')); });

tick1
mt1
mt in tick
tick in mt
timeout

The nextTick queue is drained first (tick1), then microtasks (mt1, then mt in tick which was just enqueued), and only when both are empty does Node re-check nextTick (tick in mt) and finally move to the timers phase.

6.4 Promise combinators

Two things to say out loud in an interview: Promise.all does not cancel the other operations on rejection (there is no cancellation in the promise model — that is what AbortController is for), and race with an already-settled promise in the list resolves in one tick regardless of timers.

6.5 A spec-faithful Promise from scratch

This passes the test suite below, including thenable adoption, the chaining-cycle check, and single-settlement.

const PENDING = 'pending', FULFILLED = 'fulfilled', REJECTED = 'rejected';

class MyPromise {
  #state = PENDING; #value; #cbs = [];

  constructor(executor) {
    const resolve = v => this.#settle(FULFILLED, v);
    const reject  = r => this.#settle(REJECTED, r);
    try { executor(v => this.#resolveWith(v, resolve, reject), reject); }
    catch (e) { reject(e); }
  }

  // 2.3 of the Promises/A+ spec: the Promise Resolution Procedure
  #resolveWith(v, resolve, reject) {
    if (v === this) return reject(new TypeError('Chaining cycle detected'));
    if (v && (typeof v === 'object' || typeof v === 'function')) {
      let then;
      try { then = v.then; } catch (e) { return reject(e); }
      if (typeof then === 'function') {
        let called = false;
        try {
          return then.call(v,
            y => { if (called) return; called = true; this.#resolveWith(y, resolve, reject); },
            r => { if (called) return; called = true; reject(r); });
        } catch (e) { if (!called) reject(e); return; }
      }
    }
    resolve(v);
  }

  #settle(state, value) {
    if (this.#state !== PENDING) return;          // settle exactly once
    this.#state = state; this.#value = value;
    for (const cb of this.#cbs) queueMicrotask(cb);
    this.#cbs = [];
  }

  then(onFul, onRej) {
    return new MyPromise((resolve, reject) => {
      const run = () => queueMicrotask(() => {
        const handler = this.#state === FULFILLED ? onFul : onRej;
        if (typeof handler !== 'function') {        // pass-through
          this.#state === FULFILLED ? resolve(this.#value) : reject(this.#value);
          return;
        }
        try { resolve(handler(this.#value)); } catch (e) { reject(e); }
      });
      this.#state === PENDING ? this.#cbs.push(run) : run();
    });
  }

  catch(onRej)  { return this.then(undefined, onRej); }
  finally(fn)   { return this.then(v => { fn(); return v; }, r => { fn(); throw r; }); }

  static resolve(v) { return v instanceof MyPromise ? v : new MyPromise(res => res(v)); }
  static reject(r)  { return new MyPromise((_, rej) => rej(r)); }

  static all(iter) {
    return new MyPromise((resolve, reject) => {
      const items = [...iter]; const out = new Array(items.length); let left = items.length;
      if (!left) return resolve([]);
      items.forEach((p, i) =>
        MyPromise.resolve(p).then(v => { out[i] = v; if (--left === 0) resolve(out); }, reject));
    });
  }
  static race(iter) {
    return new MyPromise((res, rej) => { for (const p of iter) MyPromise.resolve(p).then(res, rej); });
  }
  static allSettled(iter) {
    return MyPromise.all([...iter].map(p => MyPromise.resolve(p).then(
      value => ({ status: 'fulfilled', value }), reason => ({ status: 'rejected', reason }))));
  }
}

PASS resolve/then
PASS reject/catch
PASS thenable adoption
PASS nested promise
PASS all
PASS race
PASS allSettled
PASS throw in handler propagates
PASS settle once
PASS finally passthrough
PASS async ordering

The three details interviewers look for: then always returns a new promise (that is what makes chaining work), handlers always run in a microtask even if the promise is already settled (so ordering is deterministic), and resolving with a thenable adopts its state recursively.

6.6 async/await is generators plus a driver

async function desugars to a generator whose yields are awaits, driven by a trampoline:

function toAsync(genFn) {
  return function (...args) {
    const it = genFn.apply(this, args);
    return new Promise((resolve, reject) => {
      const step = (method, arg) => {
        let r;
        try { r = it[method](arg); } catch (e) { return reject(e); }
        if (r.done) return resolve(r.value);
        Promise.resolve(r.value).then(v => step('next', v), e => step('throw', e));
      };
      step('next');
    });
  };
}
const load = toAsync(function* () {
  const a = yield Promise.resolve(1);
  const b = yield Promise.resolve(a + 1);
  return a + b;
});
load().then(console.log);   // 3

That is exactly what Babel’s regenerator emitted, and it is the answer to “how does await work under the hood”.

6.7 The error-handling traps

// 1. await inside forEach does nothing — forEach ignores the returned promise
[1, 2, 3].forEach(async n => { await sleep(10); console.log(n); });   // returns immediately
for (const n of [1, 2, 3]) { await sleep(10); console.log(n); }        // actually sequential

// 2. sequential vs parallel
const a = await fetchA(); const b = await fetchB();          // 2 round trips, serialized
const [a2, b2] = await Promise.all([fetchA(), fetchB()]);     // 1 round trip of latency

// 3. unhandled rejection from a promise created but awaited later
const p = risky();                 // rejects at t=0
await sleep(1000);                 // by now Node may have reported an unhandled rejection
try { await p; } catch {}          // too late in some Node versions
// fix: attach the handler immediately, or create the promise where you await it

// 4. throwing inside a non-awaited async function is invisible
async function bg() { throw new Error('lost'); }
bg();                              // unhandledRejection
bg().catch(reportError);           // correct

// 5. try/finally around await, and the return-in-finally trap
async function f() { try { return 'a'; } finally { return 'b'; } }   // resolves 'b'

Node 22 default for an unhandled rejection is --unhandled-rejections=throw, i.e. the process crashes. That is deliberate — a swallowed rejection is a silent data-corruption bug.

6.8 Cancellation and concurrency control

// AbortController is the standard cancellation channel; fetch, streams and timers honour it.
async function fetchWithTimeout(url, ms = 100) {
  const ac = new AbortController();
  const timer = setTimeout(() => ac.abort(new Error('timeout')), ms);
  try {
    const res = await fetch(url, { signal: ac.signal });
    return await res.json();
  } finally { clearTimeout(timer); }
}

// AbortSignal.timeout(ms) is the one-liner; AbortSignal.any([...]) combines signals.

A bounded-concurrency map, which is the “rate limit N parallel requests” question:

async function pMap(items, mapper, concurrency = 4) {
  const out = new Array(items.length);
  let i = 0, active = 0;
  await new Promise((resolve, reject) => {
    const next = () => {
      if (i >= items.length && active === 0) return resolve();
      while (active < concurrency && i < items.length) {
        const idx = i++; active++;
        Promise.resolve(mapper(items[idx], idx))
          .then(v => { out[idx] = v; active--; next(); }, reject);
      }
    };
    next();
  });
  return out;
}

results 0,1,4,9,16,25,36,49,64,81
peak concurrency 3 | elapsed ~ 200 ms (serial would be 500)

Follow-ups to be ready for: make it fail-soft (collect errors instead of rejecting), add retries with exponential backoff and jitter, preserve order (this does — it writes by index), and make it a stream so memory stays O(concurrency) instead of O(n).

AsyncLocalStorage (from node:async_hooks) is the Node answer to thread-local storage: it propagates a context object across await boundaries, which is how request-scoped tracing and logging work without threading a ctx parameter through every function.

Interview follow-ups

Q: Is JavaScript single-threaded?

A: The JavaScript execution is single-threaded per realm, but the runtime is not: libuv keeps a threadpool (default 4, UV_THREADPOOL_SIZE) for filesystem, DNS and crypto work, and you can add real threads with worker_threads. Network I/O uses the OS event notification mechanism, not the pool.

Q: Why is setTimeout(fn, 0) not zero?

A: HTML clamps nested timers to 4 ms after 5 levels; Node’s timer resolution means the minimum is 1 ms; and the callback still has to wait for the current synchronous execution plus the microtask drain plus the loop to reach the timers phase.

Q: What is the difference between process.nextTick and setImmediate?

A: Despite the names, nextTick fires before the loop continues (higher priority than promises) and setImmediate fires in the next loop turn’s check phase. Prefer setImmediate for “yield to the loop”; reserve nextTick for internal invariants because it can starve I/O.

Q: How do you make a blocking CPU task not freeze the server?

A: Move it off the loop: worker_threads for CPU-bound JS, a native addon or child process for heavy work, or chunk it and await new Promise(r => setImmediate(r)) between chunks to let I/O breathe.

Q: Can a microtask starve the event loop?

A: Yes. A microtask that enqueues another microtask unconditionally never lets the loop advance — no timers, no I/O. The same is true of recursive process.nextTick.

Q: What does await do to a non-promise?

A: It wraps it via Promise.resolve and still yields — so await 1 costs one microtask tick. That is why “8 after await” appears in the microtask group in Puzzle 1.

7. Memory and garbage collection

7.1 V8’s generational collector

Two spaces, two very different collectors — the generational hypothesis is that most objects die young.

Modern V8 (“Orinoco”) makes the major GC mostly non-blocking: incremental marking interleaved with JS, concurrent marking and sweeping on helper threads, parallel scavenging, and lazy sweeping. What remains stop-the-world is short. Node flags worth knowing: --max-old-space-size=N (MB), --expose-gc (then global.gc()), --trace-gc.

Roots are the stack, the global object, and handles held by native code. Reachability, not reference counting, decides liveness — which is why cycles are collected in JS but need a cycle detector in CPython (see Python core).

7.2 Weak references

WeakMap is not enumerable by design — being able to list the keys would expose GC timing.

7.3 The four leak archetypes

1. Accidental globals / module-level accumulation. const cache = new Map() at module scope that never evicts is the single most common Node leak.
2. Closures capturing more than they need. A closure keeps its whole scope alive; one long-lived callback can pin a large object graph. Extract just the field you need before closing over it.
3. Timers and listeners never removed. setInterval keeps its closure alive forever; emitter.on without off grows the listener array (Node warns at 11 listeners).
4. Detached views/nodes still referenced. In the browser, removing a DOM node while JS still holds a reference keeps the whole subtree alive.

Finding one:

node --expose-gc app.js          # exposes global.gc() so you can force a collection

// coarse: watch the trend, forcing GC between samples so you see retention, not garbage
setInterval(() => {
  global.gc();
  const { heapUsed, external, arrayBuffers } = process.memoryUsage();
  console.log((heapUsed / 1e6).toFixed(1), 'MB heap |', (external / 1e6).toFixed(1), 'MB external');
}, 5000);

Then take two heap snapshots (node --inspect, Chrome DevTools Memory tab, or require('v8').writeHeapSnapshot()) at points where memory should be equal, and use the Comparison view: the retaining path of the top delta tells you which closure or map is holding on. heapUsed growing while rss is flat means fragmentation, not a leak.

Interview follow-ups

Q: What exactly makes an object eligible for collection?

A: Unreachability from any root. Setting a variable to null only helps if it was the last strong reference.

Q: Does delete obj.prop free memory?

A: It removes the reference (so the value may become collectable) but it also transitions the object into dictionary mode, which is slower forever. Prefer obj.prop = undefined in hot objects.

Q: What is external memory in process.memoryUsage()?

A: C++ objects bound to JS objects — Buffers, ArrayBuffer backing stores, native addon memory. It is not part of the V8 heap limit, so a buffer leak shows up here, not in heapUsed.

Q: Why can FinalizationRegistry not be used for resource cleanup?

A: Callbacks are best-effort: they may never run (process exit, engine choice), may run late, and must not resurrect the object. Use try/finally, Symbol.dispose/using, or explicit close().

8. The V8 performance model

8.1 The compilation pipeline

source ──> scanner/parser ──> AST ──> Ignition (bytecode interpreter)
                                          │  hot?
                                          ├──> Sparkplug   (baseline, non-optimizing, near-instant compile)
                                          ├──> Maglev      (mid-tier optimizing, since V8 11.x)
                                          └──> TurboFan    (top-tier optimizing, speculative)
                                                   │
                                              deoptimize ──> back to Ignition when a speculation fails

Key ideas to be able to state:

• Lazy parsing. Function bodies are pre-parsed only, and fully parsed on first call. Wrapping a function in parentheses ((function(){})) is the old “eager parse” hint; the modern equivalent is not worrying about it.
• Speculative optimization. TurboFan compiles code specialised on the types it has observed. If a function that always saw integers suddenly gets a string, the optimized code is thrown away (deoptimization) and the function re-warms. A single polymorphic call site can cost you the whole optimization.
• Optimization is per-function and feedback-driven; that is why microbenchmarks need warm-up runs and why the first measurement in a loop is worthless.

8.2 Hidden classes and inline caches

Every object has a hidden class (V8 calls it a Map) describing its shape: which properties exist, in what order, at what offset. Adding a property creates a transition to a new hidden class. Objects built the same way share a hidden class, and a property access site caches “if the shape is M, the value is at offset 3” — an inline cache.

Measured on this container (Node 22.22.2), same read loop compiled at four separate call sites, 20,000 objects, 2,000 iterations:

monomorphic (1 shape)           77.6 ms
polymorphic (2 shapes)         116.0 ms
polymorphic (4 shapes)         116.1 ms
megamorphic (8 shapes)         332.5 ms

Monomorphic to megamorphic is a 4.3x slowdown on pure property reads (a repeat run gave 4.6x). The practical rules:

• Initialize every field in the constructor, in the same order, even to null.
• Do not add or delete properties after construction.
• {x, y} and {y, x} are different hidden classes. Object literal key order matters.
• Prefer a Map when keys are genuinely dynamic — a plain object used as a dictionary goes into dictionary (slow, hash-backed) mode anyway, and Map is designed for it.

A warning about measuring this. My first attempt at this benchmark showed no difference, because a shared counter++ in the loop body dominated the cost and the two cases shared one call site. Isolate the call sites (a fresh function per case), keep the loop body trivial, warm up, and sanity-check that the numbers move when you make the effect bigger. A benchmark that shows no difference is more often a broken benchmark than a disproved theory.

8.3 Elements kinds: packed vs holey

Arrays have their own lattice of representations, and transitions are one-way (you can never go back to a more specific kind):

PACKED_SMI  ──>  PACKED_DOUBLE  ──>  PACKED_ELEMENTS
     │                 │                    │
     v                 v                    v
HOLEY_SMI   ──>  HOLEY_DOUBLE   ──>  HOLEY_ELEMENTS  ──> DICTIONARY_ELEMENTS

SMI = small integer (31-bit tagged, no boxing). DOUBLE = unboxed floats. ELEMENTS = arbitrary tagged values. Holey means the array has gaps, so every read must also consult the prototype chain to be spec-correct — which is why it is slower.

PACKED_SMI                      35.4 ms
HOLEY_SMI (one delete)          49.7 ms
HOLEY_SMI (50% holes)           68.8 ms

One delete arr[10] on a 20,000-element array made the sum loop measurably slower — 15% to 40% depending on the run — and permanently, because the transition is one-way. (This is the noisiest measurement in this guide; the direction is completely consistent, the magnitude is not.) Things that create holes: new Array(n) without filling, delete, assigning past the end (a[a.length+1]=x), and arr.length = biggerNumber.

const good = new Array(n).fill(0);                 // PACKED_SMI
const alsoGood = Array.from({ length: n }, () => 0);
const bad = new Array(n);                          // HOLEY_SMI from birth

DICTIONARY_ELEMENTS happens when an array becomes very sparse (a = []; a[100000] = 1); it is a hash map wearing an array costume, and iteration collapses.

8.4 Strings

V8 has several string representations and concatenation does not copy:

A ConsString is flattened lazily when something needs the characters contiguously (a regex, a char access, passing to C++). So:

+= in loop                   37.1 ms len=400000
array push + join            34.8 ms len=400000

s += x in a loop is fine in V8 (it builds a rope), essentially tying push/join. This is the opposite of Python, where += on str is quadratic unless CPython’s in-place optimization applies — so the “always use join” advice is Python advice, not universal advice. What is expensive in JS is forcing flattening repeatedly, and str.split('').reverse().join('') which allocates an array of one-character strings (and is also wrong for non-BMP characters — use [...str]).

8.5 A checklist for hot JavaScript

• Keep object shapes stable and call sites monomorphic.
• Keep arrays packed and single-typed; preallocate with fill.
• Avoid arguments, with, eval, and delete in hot paths.
• Do not mix types in a numeric array ([1, 2, 'x'] collapses to PACKED_ELEMENTS).
• Prefer for / for...of over forEach in the hottest loops (callback allocation and megamorphic dispatch), but measure — usually it does not matter.
• Map/Set for dynamic keys, plain objects for fixed shapes.
• Typed arrays (Float64Array, Int32Array) when you have numeric bulk data — no boxing, cache-friendly.
• Measure with --prof + node --prof-process, --cpu-prof, or perf; read %OptimizeFunctionOnNextCall-style diagnostics only with --allow-natives-syntax.
• node --trace-deopt and --trace-opt-verbose tell you which functions keep getting thrown away.

Interview follow-ups

Q: What is a hidden class transition and why should I care?

A: Adding a property moves the object to a new shape. Two “identical” objects built in different orders have different shapes, which turns a monomorphic call site polymorphic and costs you the optimized code path.

Q: Why is arr.includes(x) slower than set.has(x)?

A: O(n) linear scan versus O(1) average hash lookup. The crossover is small — usually a few dozen elements — so for tiny arrays the linear scan wins on cache locality.

Q: What is deoptimization and what triggers it?

A: Discarding TurboFan code and resuming in the interpreter, triggered when a speculation fails: an unexpected type, a hole in an array assumed packed, an object shape change, or arguments escaping.

Q: Is for...of slower than a for loop?

A: It allocates an iterator and a result object per step in principle; V8 escape-analyses most of that away for arrays. Treat them as equal until a profile says otherwise.

Q: How do you make numeric code fast in JS?

A: Typed arrays, avoid NaN/undefined sentinels in the data, keep arrays packed-double, use Math.fround if you want float32 semantics, and consider WebAssembly for genuinely heavy kernels.

9. Modules

9.1 CJS vs ESM

9.2 Live bindings, demonstrated

// counter.mjs
export let count = 0;
export const inc = () => ++count;
// main.mjs
import { count, inc } from './counter.mjs';
inc(); inc();
console.log(count);      // 2  — the imported name tracks the exporter's variable
// count = 5;            // TypeError: Assignment to constant variable (imports are read-only)

The CJS equivalent (const { count } = require('./counter')) would print 0, because destructuring copied the number.

9.3 Circular imports

The behaviour differs, and it is a favourite question. Same two-module cycle, both systems:

[cjs] a: start
[cjs] b: start
[cjs] b: saw a.aVal = A-initial (partial export!)      <- b got a HALF-BUILT module object
[cjs] a: saw b.bVal = B-final

CJS returns the partially-populated module.exports to break the cycle. Code that reads a value at require time gets whatever existed at that moment — a real source of undefined is not a function.

[esm] b: start                                          <- depth-first: b is evaluated before a
[esm] b: reading aVal threw ReferenceError - TDZ via live binding
[esm] a: start
[esm] a: saw bVal = B-final

ESM hoists the bindings but leaves them in the temporal dead zone, so a premature read throws a loud ReferenceError instead of silently yielding undefined. Function declarations are hoisted and initialized, which is why cycles between modules that only call each other’s functions work fine in both systems.

9.4 Other module facts worth knowing

• "type": "module" in package.json makes .js files ESM; .cjs/.mjs always win over it.
• The exports field is the modern entry map and it blocks deep imports not listed in it.
• The dual package hazard: shipping both CJS and ESM builds can load two copies of your module, each with its own module-level state (two Symbol registries, two singletons, instanceof failures).
• import() returns a promise for the namespace object and works in both systems; it is how you do lazy loading and how CJS reaches ESM.
• import.meta.url replaces __filename; import.meta.dirname/filename exist in Node 20.11+; import.meta.resolve() resolves specifiers.
• Import attributes: import cfg from './c.json' with { type: 'json' }.

10. Node specifics

10.1 Streams and backpressure

Streams exist so you can process data larger than memory, and backpressure is the mechanism that stops a fast producer from overwhelming a slow consumer. write() returning false means “the internal buffer is above highWaterMark, wait for 'drain'”. pipe/pipeline handle this for you.

import { pipeline } from 'node:stream/promises';
import { createReadStream, createWriteStream } from 'node:fs';
import { createGzip } from 'node:zlib';
import { Transform } from 'node:stream';

const upper = new Transform({
  transform(chunk, _enc, cb) { cb(null, chunk.toString().toUpperCase()); },
});

await pipeline(createReadStream('in.txt'), upper, createGzip(), createWriteStream('out.gz'));

Use pipeline (not .pipe()) because it propagates errors and destroys every stream in the chain; a bare .pipe() leaks file descriptors on error. Async iteration works too: for await (const chunk of readable).

10.2 Parallelism options

Network I/O does not use the threadpool; it uses epoll/kqueue/IOCP. That is why thousands of idle sockets cost almost nothing but four concurrent fs.readFiles can queue.

10.3 Buffers and binary

Buffer is a Uint8Array subclass with encoding helpers. Buffer.allocUnsafe(n) skips zero-filling (faster, may expose old memory — always overwrite it fully). buf.subarray() shares memory; Buffer.from(buf) copies. For structured binary, DataView gives you explicit endianness.

11. Modern syntax you should be fluent in

// Optional chaining and nullish coalescing
const city = user?.address?.city ?? 'unknown';
const first = list?.[0];
const out = fn?.(arg);                 // only calls if fn is not null/undefined
opts.retries ??= 3;                    // logical assignment: ??=, ||=, &&=

// Destructuring: rename, default, nested, rest, in parameters
const { a: alpha = 1, b: { c } = {}, ...rest } = obj;
const [x, , z = 0, ...tail] = arr;
function f({ id, tags = [] } = {}) {}

// Array methods that do NOT mutate (ES2023) — great for state updates
arr.toSorted((a, b) => a - b);  arr.toReversed();  arr.with(2, 'new');  arr.toSpliced(1, 2);
arr.at(-1);                     // last element
arr.findLast(p);  arr.findLastIndex(p);
arr.flat(Infinity);  arr.flatMap(f);

// Grouping (ES2024)
Object.groupBy([1, 2, 3, 4, 5], n => (n % 2 ? 'odd' : 'even'));
// -> {"odd":[1,3,5],"even":[2,4]}
Map.groupBy(users, u => u.teamId);      // Map keyed by anything

// Set algebra (ES2025) — verified on Node 22
const a = new Set([1, 2, 3]), b = new Set([3, 4]);
[...a.union(b)];                 // [1,2,3,4]
[...a.intersection(b)];          // [3]
[...a.difference(b)];            // [1,2]
[...a.symmetricDifference(b)];   // [1,2,4]
a.isSubsetOf(b); a.isSupersetOf(b); a.isDisjointFrom(new Set([9]));   // false false true

// Explicit resource management (ES2026)
class Conn { [Symbol.dispose]() { console.log('closed'); } }
{ using c = new Conn(); /* ... */ }     // disposed at end of block, even on throw
// await using for [Symbol.asyncDispose]

// Structured deep clone, handles cycles, Map/Set/Date/RegExp/ArrayBuffer
const copy = structuredClone(graph);    // NOT functions, DOM nodes, or prototypes

// Misc
Object.hasOwn(obj, 'k');                // replaces hasOwnProperty.call
String.prototype.replaceAll;
Array.fromAsync(asyncIterable);
AbortSignal.timeout(1000); AbortSignal.any([s1, s2]);
label: for (const i of xs) { for (const j of ys) if (bad) continue label; }

12. Interview questions

12.1 Implement these cold

Implement map, filter, reduce.

Array.prototype.myMap = function (cb, thisArg) {
  const out = new Array(this.length);
  for (let i = 0; i < this.length; i++) if (i in this) out[i] = cb.call(thisArg, this[i], i, this);
  return out;
};
Array.prototype.myFilter = function (cb, thisArg) {
  const out = [];
  for (let i = 0; i < this.length; i++) if (i in this && cb.call(thisArg, this[i], i, this)) out.push(this[i]);
  return out;
};
Array.prototype.myReduce = function (cb, ...init) {
  let i = 0, acc;
  if (init.length) acc = init[0];
  else { while (i < this.length && !(i in this)) i++;
         if (i >= this.length) throw new TypeError('Reduce of empty array with no initial value');
         acc = this[i++]; }
  for (; i < this.length; i++) if (i in this) acc = cb(acc, this[i], i, this);
  return acc;
};

The i in this check (skipping holes) and the empty-array-without-initial-value TypeError are the details that distinguish a real answer from a sketch.

Deep clone with cycles.

function deepClone(value, seen = new Map()) {
  if (value === null || typeof value !== 'object') return value;
  if (seen.has(value)) return seen.get(value);              // handles cycles AND shared refs
  if (value instanceof Date) return new Date(value);
  if (value instanceof RegExp) return new RegExp(value.source, value.flags);
  if (value instanceof Map) {
    const m = new Map(); seen.set(value, m);
    for (const [k, v] of value) m.set(deepClone(k, seen), deepClone(v, seen));
    return m;
  }
  if (value instanceof Set) {
    const s = new Set(); seen.set(value, s);
    for (const v of value) s.add(deepClone(v, seen));
    return s;
  }
  if (ArrayBuffer.isView(value)) return new value.constructor(value);
  const out = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
  seen.set(value, out);
  for (const k of Reflect.ownKeys(value)) {
    const d = Object.getOwnPropertyDescriptor(value, k);
    if ('value' in d) d.value = deepClone(d.value, seen);
    Object.defineProperty(out, k, d);
  }
  return out;
}

Say out loud: structuredClone does most of this natively now; hand-roll it only when you need to handle functions, prototypes, or custom classes.

Deep equal.

function deepEqual(a, b, seen = new Set()) {
  if (Object.is(a, b)) return true;
  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;
  if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
  const pair = a; if (seen.has(pair)) return true; seen.add(pair);
  if (a instanceof Date) return a.getTime() === b.getTime();
  if (a instanceof RegExp) return a.source === b.source && a.flags === b.flags;
  if (a instanceof Map) return a.size === b.size && [...a].every(([k, v]) => b.has(k) && deepEqual(v, b.get(k), seen));
  if (a instanceof Set) return a.size === b.size && [...a].every(v => b.has(v));
  const ka = Reflect.ownKeys(a), kb = Reflect.ownKeys(b);
  return ka.length === kb.length && ka.every(k => Reflect.has(b, k) && deepEqual(a[k], b[k], seen));
}

Flatten with depth, iteratively.

function flatten(arr, depth = 1) {
  const out = [], stack = arr.map(v => [v, depth]);
  while (stack.length) {
    const [v, d] = stack.shift();
    if (Array.isArray(v) && d > 0) stack.unshift(...v.map(x => [x, d - 1]));
    else out.push(v);
  }
  return out;
}
// Note: shift/unshift make this O(n^2); the O(n) version pushes and reverses, or recurses.

Event emitter.

class Emitter {
  #m = new Map();
  on(ev, fn) { (this.#m.get(ev) ?? this.#m.set(ev, new Set()).get(ev)).add(fn); return () => this.off(ev, fn); }
  once(ev, fn) { const w = (...a) => { this.off(ev, w); fn(...a); }; return this.on(ev, w); }
  off(ev, fn) { this.#m.get(ev)?.delete(fn); }
  emit(ev, ...args) {
    // copy first: a handler may add/remove handlers during emit
    for (const fn of [...(this.#m.get(ev) ?? [])]) { try { fn(...args); } catch (e) { queueMicrotask(() => { throw e; }); } }
    return (this.#m.get(ev)?.size ?? 0) > 0;
  }
}

Retry with exponential backoff and jitter.

async function retry(fn, { attempts = 5, base = 100, cap = 5000, signal } = {}) {
  let lastErr;
  for (let i = 0; i < attempts; i++) {
    try { return await fn(i); } catch (e) {
      lastErr = e;
      if (signal?.aborted || i === attempts - 1) break;
      const exp = Math.min(cap, base * 2 ** i);
      const wait = Math.random() * exp;                  // full jitter
      await new Promise(r => setTimeout(r, wait));
    }
  }
  throw lastErr;
}

Promisify a callback API.

const promisify = fn => (...args) =>
  new Promise((res, rej) => fn(...args, (err, ...vals) => err ? rej(err) : res(vals.length > 1 ? vals : vals[0])));

once, chunk, groupBy, range.

const once = fn => { let done = false, val; return (...a) => (done ? val : (done = true, val = fn(...a))); };
const chunk = (a, n) => Array.from({ length: Math.ceil(a.length / n) }, (_, i) => a.slice(i * n, i * n + n));
const groupBy = (a, f) => a.reduce((m, v) => ((m[f(v)] ??= []).push(v), m), {});
const range = (n, start = 0, step = 1) => Array.from({ length: n }, (_, i) => start + i * step);