Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

A Map in TypeScript is a built-in, generic iterable collection that stores key-value pairs. Unlike standard JavaScript objects, a Map permits keys of any data type—including objects, functions, and primitives—and strictly maintains the insertion order of its elements. TypeScript enhances the native JavaScript Map by enforcing strict type safety through generics (Map<K, V>).

​
Instantiation and Typing

TypeScript utilizes generics to define the types for the keys (K) and values (V). If initialized with values, TypeScript can infer these types, but explicit declaration is standard practice for empty maps. 
// Instantiating an empty Map with explicit types
const nodeCache = new Map<string, object>();

// Instantiating with an iterable of tuples
const statusCodes = new Map<number, string>([
    [200, "OK"],
    [404, "Not Found"]
]);

​
Core API

The Map object provides a standardized set of methods for mutation and retrieval. TypeScript ensures that arguments passed to these methods adhere to the defined <K, V> generics.
  • set(key: K, value: V): this Adds or updates an element with a specified key and value. Returns the Map instance, allowing for method chaining. 
statusCodes.set(500, "Internal Server Error").set(403, "Forbidden");
  • get(key: K): V | undefined Returns the value associated with the key. If the key does not exist, it returns undefined. TypeScript automatically types the return value as a union of the value type and undefined. 
const status = statusCodes.get(200); // Type: string | undefined
  • has(key: K): boolean Returns a boolean asserting whether a value has been associated with the key in the Map. 
const exists = statusCodes.has(404); // true
  • delete(key: K): boolean Removes the specified element from the Map. Returns true if the element existed and was removed, or false if the element did not exist. 
statusCodes.delete(403);
  • clear(): void Removes all key-value pairs from the Map, resetting its size to zero. 
statusCodes.clear();
  • size: number A read-only property that returns the total number of elements currently in the Map. 
const count = statusCodes.size;

​
Iteration Protocols

Map implements the iterable protocol, meaning it can be used directly with for...of loops. It yields key-value pairs as tuples ([K, V]). 
for (const [code, message] of statusCodes) {
    console.log(code, message);
}
Additionally, Map provides methods that return IterableIterator objects for specific parts of the collection:
  • keys(): IterableIterator<K> Returns a new iterator object containing the keys for each element in insertion order.
  • values(): IterableIterator<V> Returns a new iterator object containing the values for each element in insertion order.
  • entries(): IterableIterator<[K, V]> Returns a new iterator object containing an array of [key, value] for each element in insertion order. This is the default iterator behavior of the Map object.

​
Key Equality

Key equality in a Map is evaluated using the SameValueZero algorithm. This means NaN is considered equal to NaN (even though NaN !== NaN in standard JavaScript), and all other values are considered equal according to the semantics of the strict equality (===) operator. When using objects or arrays as keys, equality is determined by memory reference, not structural shape. 
const map = new Map<object, string>();
const objKey = { id: 1 };

map.set(objKey, "Active");

// Successful retrieval: exact same reference
map.get(objKey); // Returns "Active"

// Failed retrieval: structurally identical, but different reference
map.get({ id: 1 }); // Returns undefined
Master TypeScript with Deep Grasping Methodology!Learn More