Interview answer drill

Use this JavaScript interview question to rehearse a quick answer, common mistake, follow-up, and production pitfall.

Practice interview questions Follow JavaScript mastery study plan Practice more JavaScript interview questions

What are Map and Set in JavaScript, and how does get() work?Frontend interview answer

HighEasyJavascript

By FrontendAtlas Team · Updated Mar 2, 2026

Interview focus

This JavaScript interview question tests whether you can explain JavaScript Map and Set: set(), get(), has(), and Real Use Cases, connect it to production trade-offs, and handle common follow-up questions.

JavaScript Map and Set: set(), get(), has(), and Real Use Cases explanation without falling back to memorized docs wording
Map and Set reasoning, edge cases, and production failure modes
How you would answer the most likely JavaScript interview follow-up

Practice more JavaScript interview questions

Interview quick answer

Map and Set are ES6 collections designed for fast key/value lookups and unique-value membership checks. Learn when to use Map.set/get/has, how Set deduplicates values, and common pitfalls like confusing Map.get(undefined) with missing keys.

Full interview answer

The core idea

Map and Set are modern JavaScript collections:

Map: stores key -> value pairs.

Set: stores unique values only.

If your interview answer is one sentence: use Map for lookup tables and Set for fast membership checks and deduplication.

Collection	Stores	Key operations	Typical use case
`Map`	Key-value pairs	`set`, `get`, `has`, `delete`	Caching, indexing by id, metadata by object key
`Set`	Unique values	`add`, `has`, `delete`	Deduping arrays, visited-node tracking, permission checks

Map answers "what value belongs to this key?" while Set answers "have I seen this value?"

JAVASCRIPT

const userScores = new Map();
userScores.set('u1', 82);
userScores.set('u2', 91);

console.log(userScores.get('u1')); // 82
console.log(userScores.has('u3')); // false

const activeUsers = new Set();
activeUsers.add('u1');
activeUsers.add('u1'); // duplicate ignored
activeUsers.add('u2');

console.log(activeUsers.size); // 2
console.log(activeUsers.has('u2')); // true

Important detail about Map.get()

get() returns undefined for a missing key, but it also returns undefined if the key exists and its value is explicitly undefined.

So in critical code, pair get() with has().

JAVASCRIPT

const settings = new Map();
settings.set('theme', undefined);

console.log(settings.get('theme')); // undefined
console.log(settings.get('language')); // undefined

console.log(settings.has('theme'));    // true
console.log(settings.has('language')); // false

Equality rule used by Map and Set

Map and Set compare keys/values using SameValueZero:

NaN is considered equal to NaN.

0 and -0 are treated as the same.

Object keys are compared by reference identity, not by deep value.

JAVASCRIPT

const m = new Map();
m.set(NaN, 'not-a-number');
console.log(m.get(Number('foo'))); // 'not-a-number'

const a = { id: 1 };
const b = { id: 1 };
m.set(a, 'first');

console.log(m.get(a)); // 'first'
console.log(m.get(b)); // undefined (different object reference)

High-impact real-world patterns

1) Deduplicate incoming IDs with Set before making API calls.
2) Index entities by id in Map for O(1) average lookups.
3) Track visited states in graph/DFS/BFS with Set.

JAVASCRIPT

const ids = ['p1', 'p2', 'p1', 'p3'];
const uniqueIds = [...new Set(ids)];
// ['p1', 'p2', 'p3']

const products = [
  { id: 'p1', name: 'Keyboard' },
  { id: 'p2', name: 'Mouse' }
];
const byId = new Map(products.map((p) => [p.id, p]));

console.log(byId.get('p2')?.name); // 'Mouse'

Common interview pitfalls

Confusing Array.prototype.map() with Map the collection type.

Using objects as Map keys and expecting deep-value matching.

Assuming map.get(key) can distinguish missing key vs undefined value without has().

Using plain objects for heavy insertion/deletion workloads where Map is clearer.

Practical scenario
An autocomplete feature receives repeated product IDs from multiple endpoints. You can dedupe IDs with Set, then create a Map for instant id -> product lookup during rendering.

Common pitfalls

Using array includes repeatedly in hot paths instead of a Set membership check.
Using object property access for dynamic keys that are not strings.
Forgetting insertion-order behavior when rendering deterministic lists.

Trade-off or test tip
Benchmark with realistic payload sizes. Add tests for duplicate values, undefined map values, and object-key identity behavior.

Summary

Use Map when you need key-value lookups with any key type and clean APIs like set/get/has. Use Set when you care about uniqueness and fast membership checks. In production code, combine get() with has() whenever undefined can be a valid stored value.