JavaScript Collection

Three Categories:

• Indexed Collections → Access by numeric index

• Keyed Collections → Access by key (string, number, or object)

• Weak Collections → Hold weak references (garbage-collectable)

Indexed Collections — These store values in order and are indexed with numbers

Array — Index-based, ordered list of values

• Can contain mixed types.

• Dynamically sized.

const arr = [10, "hi", true];

forEach() method:

arr.forEach((value, index) => {

  console.log(index, value);

});

• Refer section below → Array Methods: forEach, map, filter, reduce

Typed Arrays — Holds binary data of a specific numeric type

• Used for WebGL, audio/video manipulation, raw bytes.

• Types include: Int8Array, Uint8Array, Float32Array, etc.

const bytes = new Uint8Array([255, 128, 0]);

Keyed Collections — These store values by key, not index

Object — Key/value pairs

• Keys are strings or symbols.

• Not ordered (though ES2015+ preserves insertion order for non-numeric keys).

const obj = { name: "Alice", age: 30 };

Map — Key/value collection

• Keys can be any type, including objects, functions...

• Maintains insertion order.

• More predictable and complete than plain object for dynamic keying.

const map = new Map();

map.set("name", "Alice");

map.set({}, 123);

forEach() method:

map.forEach((value, key) => {

  console.log(key, value);

});

Set — Stores unique values (no duplicates)

• Order is preserved.

• Useful for deduplication.

const set = new Set([1, 2, 2, 3]); // → {1, 2, 3}

• Note: In a Set, each value acts as its own key (internally).

Weak Collections — These do not prevent garbage collection of their keys/values (if unreferenced elsewhere)

• Used to avoid memory leaks.

WeakMap — Weakly referenced → keys auto-removed when no longer used

• Keys MUST be objects.

• Values can be anything.

• Not iterable.

const wm = new WeakMap();

let obj = {};

wm.set(obj, "data");

obj = null; // entry is auto-deleted

WeakSet — Stores objects only

• Objects are weakly held.

• Not iterable.

const ws = new WeakSet();

let user = {};

ws.add(user);

user = null; // auto-removed

Iterables

• They can be iterated through the for...of loop, and methods like forEach(), etc.

• Common iterables:

  • Array

  • String

  • Map

  • Set

  • Arguments

  • NodeList

  • TypedArrays

  • Generators

for...of loop

// array

const array = ["Hello", 10, 20];

for (let ele of array) {

         console.log(ele); //1st ele: Hello; 2nd ele: 10; etc.

  }

// map

const map = new Map([

         ["1", "one"],

         ["2", "two"],

         ["3", "three"],

      ]);

for (let ele of map) {

         console.log(ele); //1st ele: 1,one; 2nd ele: 2,two; etc.

  }

Array Methods: forEach, map, filter, reduce

forEach() — Execute a function for each element (side effects)

const nums = [1, 2, 3];

nums.forEach(n => console.log(n * 2)); // 2 4 6

map() — Transform each element of an array into a new array

• Returns: A new array of the same length.

const nums = [1, 2, 3];

const doubled = nums.map(n => n * 2);

console.log(doubled); // [2, 4, 6]

filter() — Select elements from an array that satisfy a condition

• Returns: A new array containing only elements for which the callback returns true.

const nums = [1, 2, 3, 4, 5];

const evens = nums.filter(n => n % 2 === 0);

console.log(evens); // [2, 4]

reduce() — Reduce an array to a single value by applying a function iteratively

• Returns: A single value (any type).

Example: Sum of an array

const nums = [1, 2, 3, 4];

const sum = nums.reduce((acc, n) => acc + n, 0);

console.log(sum); // 10

Example: Flatten an array of arrays

const arr = [[1,2],[3,4],[5]];

const flat = arr.reduce((acc, sub) => acc.concat(sub), []);

console.log(flat); // [1,2,3,4,5]

Chaining

const nums = [1, 2, 3, 4, 5];

const result = nums

  .filter(n => n % 2 === 0)        // [2, 4]

  .map(n => n * 10)                // [20, 40]

  .reduce((acc, n) => acc + n, 0); // 60