Map in JS

A Map is a data structure that stores key-value pairs, where each key is unique. It is similar to an object but has some advantages:

• Inserts keys in the order they were added.
• Allows keys of any type, not just strings and symbols.
• Provides better performance when dealing with large datasets.

Creating a Map

Map() constructor allows two ways to create a Map in JavaScript.

• Passing an Array to new Map().
• Create a Map and use Map.set().

let myMap = new Map();
let anotherMap = new Map([
    ['name', 'GFG'],
    ['age', 30],
    ['city', 'Noida']
]);
console.log(anotherMap);

Map(3) { 'name' => 'GFG', 'age' => 30, 'city' => 'Noida' }

Properties of JavaScript Map

• set(key, val) : Adds or updates an element with a specified key and value.
• get(key) : Returns the value associated with the specified key.
• has(key) : Returns a boolean indicating whether an element with the specified key exists.
• delete(key) : Removes the element with the specified key.
• clear(): Removes all elements from the Map.
• size: Returns the number of key-value pairs in the Map.

Example demonstrating all the common operations on a Map

// Create a new Map
const myMap = new Map();

// 1. set(key, value)
myMap.set('name', 'GFG');
myMap.set('age', 25);
myMap.set(1, 'One'); 

console.log(myMap);


// 2. get(key)
console.log(myMap.get('name')); 
console.log(myMap.get('age')); 
console.log(myMap.get(1)); 
console.log(myMap.get('invalidKey')); 

// 3. has(key)
console.log(myMap.has('name'));
console.log(myMap.has('address')); 
console.log(myMap.has(1)); 

// 4. delete(key)
myMap.delete('age');
console.log(myMap.has('age')); 
console.log(myMap);

// 5. clear()
myMap.clear();
console.log(myMap); // Output: Map {}

console.log(myMap.size); 

myMap.set('a', 1);
myMap.set('b', 2);
console.log(myMap.size); 
console.log(myMap);

Map(3) { 'name' => 'GFG', 'age' => 25, 1 => 'One' }
GFG
25
One
undefined
true
false
true
false
Map(2) { 'name' => 'GFG', 1 => 'One' }
Map(0) {}
0
2
Map(2) { 'a' => 1, 'b' => 2 }

Advantages of Using Maps:

• Key order: Maps remember the insertion order of the keys.
• Performance: Inserting and retrieving elements from a Map are generally faster than objects, especially when the number of elements is large.
• Any type of key: Unlike objects, Map keys can be of any data type, including functions, objects, and primitive types.

DSA Problems On Map

• Most Frequent Element
• Count distinct elements in every window of size K
• Check if two arrays are equal or not
• 2 Sum – Count Pairs with target sum
• Count all pairs with absolute difference equal to K
• Check If Array Pair Sums Divisible by K
• Max distance between two occurrences in array
• Subarray with Given Sum – Handles Negative Numbers
• Remove minimum elements such that no common elements exist in two arrays
• 3 Sum – Count all triplets with target sum
• Longest Subarray with Sum Divisible by K
• Longest Subarray having Majority Elements Greater than K

Map in JavaScript

Visit Course

Map in JavaScript

Map in JS