What Is Dev

Implement hash table, array

How array works under the hood

Reference data types

Change slug and title

*exhaustive check?

Map - data structure, which holds key-value pairs (Dictionary, hash-table).

Keys can be objects, functions or primitives (Keys not converted to the string as in object, if you use a number in object, it gets converted to a string)
Maintains primary (insertion) order
Better performance for frequent additions/ deletions, iterations
Has size property
No prototype interference (Does NOT inherit from Object.prototype)
Keeps strong references (prevents garbage collection)

Test on 1000000 operations with complex-random keys and values.

const iterations = 1_000_000;
const keys = Array.from({ length: iterations }, (_, i) => `key_${i}_${Math.random().toString(36).substr(2, 9)}`);
const values = Array.from({ length: iterations }, (_, i) => ({ id: i, data: Math.random() }));

const obj = {};
const map = new Map();

// ===== INSERTION =====
console.log('📝 INSERTION (1M operations):\n');

console.time('  Object insert');
for (let i = 0; i < iterations; i++) {
  obj[keys[i]] = values[i];
}
console.timeEnd('  Object insert');
// ~180ms

console.time('  Map insert');
for (let i = 0; i < iterations; i++) {
  map.set(keys[i], values[i]);
}
console.timeEnd('  Map insert');
// ~95ms

console.log('  ⭐ Map wins: ~47% faster\n');

// ===== LOOKUP/GET =====
console.log('🔍 LOOKUP/GET (1M operations):\n');

console.time('  Object get');
for (let i = 0; i < iterations; i++) {
  const v = obj[keys[i]];
}
console.timeEnd('  Object get');
// ~28ms

console.time('  Map get');
for (let i = 0; i < iterations; i++) {
  const v = map.get(keys[i]);
}
console.timeEnd('  Map get');
// ~41ms

console.log('  ⭐ Object wins: ~32% faster\n');

// ===== ITERATION =====
console.log('🔁 ITERATION (1M entries):\n');

let objSum = 0;
console.time('  Object iteration');
for (const key in obj) {
  objSum += obj[key].id;
}
console.timeEnd('  Object iteration');
// ~52ms

let mapSum = 0;
console.time('  Map iteration');
for (const [key, value] of map) {
  mapSum += value.id;
}
console.timeEnd('  Map iteration');
// ~45ms

console.log('  ⭐ Map wins: ~13% faster\n');

// ===== DELETION =====
console.log('🗑️  DELETION (1M operations):\n');

console.time('  Object delete');
for (let i = 0; i < iterations; i++) {
  delete obj[keys[i]];
}
console.timeEnd('  Object delete');
// ~420ms

console.time('  Map delete');
for (let i = 0; i < iterations; i++) {
  map.delete(keys[i]);
}
console.timeEnd('  Map delete');
// ~105ms

console.log('  ⭐ Map wins: ~75% faster\n');

Notes:
Mostly reads, rare writes? Use Object
Read-Heavy Workloads? Use Object
Need JSON serialization (converting a JavaScript object (or value) into a JSON-formatted string)? Use Object (Map doesn't serialize)
Mixed read/write, dynamic keys? Use Map (better overall performance)
Frequent additions AND deletions? Use Map (75% faster deletion)
Need Guaranteed Iteration Order? Use Map
Need Frequent Size Checks? Use Map

Weak Map - similar to Map, but keys are weakly referenced. Keeps weak references (allows garbage collection). Keys MUST be objects (no primitives). Use for: Private data, caching, DOM node metadata. NOT iterable, no .size, no .clear(), no iteration methods.

https://stackoverflow.com/questions/29413222/what-are-the-actual-uses-of-es6-weakmap

https://www.reddit.com/r/javascript/comments/1cb2vtv/askjs_why_use_weakmap_what_are_its_advantages/

Set - data structure, which stores unique values. Fast membership checking. Use for: Removing duplicates, membership tests, unique lists. Keeps strong references (prevents garbage collection)

Iterable, has .size, .clear(), .forEach()

Use for: Unique collections, deduplication, membership testing

Set Stores Any Type

const set = new Set();

set.add(1);
set.add(2);
set.add(3);
set.add(2);  // Duplicate - ignored
set.add(1);  // Duplicate - ignored

console.log(set);  // Set { 1, 2, 3 }
console.log(set.size);  // 3 (not 5!)

// Array vs Set
const array = [1, 2, 3, 2, 1];
console.log(array.length);  // 5 (duplicates kept)

const setFromArray = new Set(array);
console.log(setFromArray);  // Set { 1, 2, 3 }
console.log(setFromArray.size);  // 3 (duplicates removed)

Weak Set - similar to Set, but values are weakly referenced. Use for: Tracking object membership without preventing garbage collection. Stores ONLY objects. Keeps weak references (allows garbage collection). Not iterable, no .size, no .clear(), no .forEach(). Use for: Tracking objects, tagging, memory-sensitive scenarios

Typed Arrays

// 8-bit integers (0-255)
const uint8 = new Uint8Array([1, 2, 3]);

// 32-bit integers
const int32 = new Int32Array(10); // 10 elements

// 64-bit floats
const float64 = new Float64Array([1.5, 2.7]);

// Shared between arrays (same buffer)
const buffer = new ArrayBuffer(16); // 16 bytes
const view1 = new Int32Array(buffer); // 4 elements (4 bytes each)
const view2 = new Uint8Array(buffer); // 16 elements (1 byte each)

// Use cases
// - Canvas/WebGL pixel data
// - Audio processing
// - File handling
// - WebAssembly interaction

JavaScript Data Structures