📋 JS Built-ins

Interview reference for the JS standard-library APIs that get reached for constantly — the exact gotchas that cost time mid-interview, not a full language guide.

1 · 🗂️ Map

const m = new Map<string, number>();
m.set('a', 1); m.get('a'); m.has('a'); m.delete('a');
m.size;   // PROPERTY, no ()
for (const [k, v] of m) {}

2 · 🔵 Set

const s = new Set<number>();
s.add(5); s.has(5); s.delete(5);
s.size;   // PROPERTY, no ()
for (const v of s) {}
[...s];   // to array

new Set([1, 2, 3]);   // ✅ needs an ARRAY
new Set(1, 2, 3);      // ❌ TypeError

3 · 🚨 .keys() / .values() / .entries() Give an ITERATOR, Not an Array — on Map, Set AND Array

m.keys().sort((a, b) => a - b);        // ❌ iterator has no .sort()
[...m.keys()].sort((a, b) => a - b);   // ✅ spread first
Array.from(m.values());                // ✅ same idea
Object.entries(obj);                   // ⚠️ plain object: a function, returns a real ARRAY

4 · 🏗️ MinPriorityQueue / MaxPriorityQueue (LeetCode's built-in library)

const pq = new MinPriorityQueue<number>();                    // simple numeric
const pq = new MinPriorityQueue<number[]>(x => x[0]);          // callback extracts comparison key
const pq = new MaxPriorityQueue<number[]>(x => x[0]);           // reverse order, same API

pq.enqueue(item);   // O(log n)
pq.dequeue();        // O(log n), returns the element directly
pq.front();           // O(1) peek
pq.isEmpty();          // O(1)
pq.size();              // METHOD here — needs ()

5 · 🔢 Math.max / Math.min

Math.max(1, 5, 3);        // ✅ individual args → 5
Math.max([1, 5, 3]);       // ❌ NaN
Math.max(...[1, 5, 3]);    // ✅ spread the array
Math.max(...hugeArr);       // ❌ RangeError around 100k+ items (engine-dependent) → use a loop

6 · 🚨 Map Access: .get()/.set() ONLY — Never Bracket Notation

const m = new Map<string, number>();
m.set('a', 1);

m.get('a');    // ✅ 1
m['a'];        // ❌ undefined — does NOT read from the Map's data
m['a'] = 5;    // ❌ sets a regular object PROPERTY named "a", not a Map entry

7 · 🔢 Big Numbers: Number Is Exact Only Up to 15 Digits — Beyond That, BigInt

Number.MAX_SAFE_INTEGER;               // 9007199254740991 = 2^53 − 1 → 16 digits
Number("12345678901234567890");        // ❌ 12345678901234567000 — silently wrong, no error

BigInt("12345678901234567890") + 1n;   // ✅ exact at any length
BigInt(a) + BigInt(b) === BigInt(c);   // ✅ LC 306 Additive Number check

✅ When to reach for BigInt:

• Numbers arrive as strings longer than 15 digits — LC 306 Additive Number, 415 Add Strings, 43 Multiply Strings
• A sum or product can grow past ~9 × 10^15
• Can I use it on LeetCode (e.g. 306)? Yes — LeetCode's JavaScript runs on Node, which supports BigInt.

🛠️ Using it:

const nums = strs.map(s => BigInt(s));           // convert once, up front
arr.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)); // ❌ a - b throws TypeError
new Map<bigint, number>();                        // keys match by value ✅
x.toString();                                     // return huge answers as strings
BigInt.asIntN(64, x);                             // imitate a 64-bit long

"Without BigInt?" → add the two strings digit by digit from the right, carrying 1 (LC 415).

8 · 🚨 new Array(n).fill([]) — Every Row Is the SAME Array

const g = new Array(3).fill([]);
g[0].push(1);                                   // ❌ [[1],[1],[1]] — one array shared by all rows
const g = Array.from({length: 3}, () => []);    // ✅ a fresh array per row

9 · 🚨 Arrays as Set/Map Keys Compare by REFERENCE — Use a String Key

const seen = new Set<number[]>();
seen.add([0, 1]);
seen.has([0, 1]);                 // ❌ false — a different array object

const seen = new Set<string>();
seen.add(`${r},${c}`);
seen.has(`${r},${c}`);            // ✅ true — strings compare by value

10 · 🔤 Strings Are Immutable — s[i] = 'x' Does Nothing

s[0] = 'z';                                  // ❌ silently ignored (TypeError in strict mode)
const a = s.split(''); a[0] = 'z'; a.join('');   // ✅ edit as an array, join back
s.charCodeAt(i) - 97;                        // letter → index ('a' = 0 … 'z' = 25)
String.fromCharCode(97 + k);                 // index → letter

11 · 🔢 Integer Math: % and / With Negatives, and 32-bit Bit Ops

-1 % 5;                  // ❌ -1, not 4 — % keeps the sign of the LEFT side
((x % n) + n) % n;       // ✅ always 0…n-1 (circular index, hashing)
Math.floor(-7 / 2);      // -4 — rounds down
Math.trunc(-7 / 2);      // -3 — cuts the decimal (what Java/C++ `/` does)
1 << 31;                 // -2147483648 — bit ops work on 32-bit signed ints

12 · 🐢 queue.shift() Is Slow on Big Arrays — BFS With a Head Pointer

while (q.length) { const x = q.shift(); }          // ❌ each shift moves every element → O(n)

let head = 0;
while (head < q.length) { const x = q[head++]; }   // ✅ O(1) per pop, push() still works

13 · 🆚 Object vs Map as a Dictionary — Use Map for Counting

const o: any = {}, m = new Map()
o[1] = 'a'; o['1'] = 'b'         // 1 key: both become "1"
m.set(1, 'a'); m.set('1', 'b')   // 2 keys: types kept

count['constructor'] = (count['constructor'] || 0) + 1   // ❌ starts from a function, not 0

📋 Order: a Map is strictly insertion order. An Object puts integer-like keys first, sorted: keys b, a, 2, 1 come out as 1, 2, b, a. (Map access is #6.)

14 · 🔤 Alphanumeric Check — a One-Character Helper (Valid Palindrome)

function isAlphaNumeric(ch: string) {
    const c = ch.toLowerCase();

    return (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9');
}
// shorter: /[a-z0-9]/i.test(ch)