Introduction to Map

A Map is a powerful JavaScript data structure that stores key-value pairs, similar to objects but with several crucial advantages. Think of it as a sophisticated dictionary where you can use any data type as keys - not just strings like in regular objects.

Key Features of Map:

• Any Key Type: You can use objects, functions, numbers, strings, or even other Maps as keys
• Preserved Order: Maps maintain the insertion order of elements, unlike regular objects
• Size Property: Easy access to the number of key-value pairs via the .size property
• Better Performance: Optimized for frequent additions and deletions
• No Prototype Pollution: Maps don't inherit properties from Object.prototype

When to Use Map:

• When you need complex keys (objects, functions)
• When insertion order matters
• When you frequently add/remove key-value pairs
• When you need to track the exact size of your collection
• When you want to avoid prototype pollution issues

// User session tracking
const sessionTracker = new Map();

const userSession = { userId: 'u1234', loggedIn: new Date() };
const permissions = ['read', 'write'];

// Using objects as keys
sessionTracker.set(userSession, permissions);

// Function as key
const authCheck = () => true;
sessionTracker.set(authCheck, 'admin-access');

console.log(sessionTracker.get(userSession)); // ['read', 'write']

Map Methods Overview

Before diving into detailed examples, let's first understand all the methods available in the Map object. This overview will help you grasp the complete API before we explore each method in detail.

Core Map Methods:

• set(key, value) - Adds or updates a key-value pair in the Map
• get(key) - Retrieves the value associated with a specific key
• has(key) - Checks if a key exists in the Map (returns boolean)
• delete(key) - Removes a specific key-value pair from the Map
• clear() - Removes all key-value pairs from the Map
• size - Property that returns the number of key-value pairs

Iteration Methods:

• keys() - Returns an iterator of all keys in the Map
• values() - Returns an iterator of all values in the Map
• entries() - Returns an iterator of all [key, value] pairs
• forEach(callback) - Executes a function for each key-value pair

Constructor and Static Methods:

• new Map() - Creates a new Map object
• new Map(iterable) - Creates a Map from an array of [key, value] pairs

Detailed Map Methods

Now let's explore each Map method in detail with comprehensive examples and explanations:

// Creating a Map for an e-commerce inventory system
const productInventory = new Map();

// 1. set(key, value) - Adding and Updating Key-Value Pairs
// Description: The set() method adds a new key-value pair or updates an existing one.
// It returns the Map object, allowing for method chaining.
productInventory.set('laptop', 25);
productInventory.set('phone', 50);
productInventory.set('tablet', 30);

// Updating an existing key (laptop quantity changes)
productInventory.set('laptop', 30); // Updates existing key

// 2. get(key) - Retrieving Values
// Description: The get() method returns the value associated with the specified key.
// If the key doesn't exist, it returns undefined.
console.log(productInventory.get('phone')); // 50
console.log(productInventory.get('mouse')); // undefined

// 3. has(key) - Checking Key Existence
// Description: The has() method returns a boolean indicating whether an element
// with the specified key exists in the Map or not.
console.log(productInventory.has('mouse')); // false
console.log(productInventory.has('laptop')); // true

// 4. delete(key) - Removing Key-Value Pairs
// Description: The delete() method removes the specified key-value pair from the Map.
// It returns true if the element was successfully removed, false otherwise.
const wasDeleted = productInventory.delete('tablet');
console.log(wasDeleted); // true
console.log(productInventory.has('tablet')); // false

// 5. clear() - Removing All Elements
// Description: The clear() method removes all key-value pairs from the Map.
// This is useful when you want to reset the entire Map.
// productInventory.clear(); // Uncomment to clear all items

// 6. size - Getting the Number of Key-Value Pairs
// Description: The size property returns the number of key-value pairs in the Map.
// This is a read-only property that automatically updates as elements are added/removed.
console.log(productInventory.size); // 2 (after deleting tablet)

// Method Chaining Example
// Description: Since set() returns the Map object, you can chain multiple set() calls
// for more concise code when initializing a Map.
const userPreferences = new Map()
    .set('theme', 'dark')
    .set('fontSize', 14)
    .set('notifications', true)
    .set('language', 'en');

Key Insights from the Above Example:

• set() Method: This is the primary method for adding data to a Map. It's versatile because it can both add new entries and update existing ones. The method returns the Map object itself, enabling method chaining for cleaner code.
• get() Method: Provides safe access to values. Unlike object property access, get() returns undefined for non-existent keys instead of throwing an error, making it safer for dynamic key access.
• has() Method: Essential for defensive programming. Always check if a key exists before attempting to access its value, especially when dealing with user input or external data.
• delete() Method: Returns a boolean indicating success, which is useful for error handling and confirming that the operation completed as expected.
• size Property: Unlike objects where you need to manually track the number of properties, Map automatically maintains an accurate count of its elements.

Real-World Application: This inventory system example demonstrates how Maps can be used in e-commerce applications to track product quantities, manage user preferences, and handle dynamic data updates efficiently.

Map Iteration Methods

Maps provide powerful iteration capabilities that make data processing efficient and intuitive:

Powerful iteration and transformation techniques:

// Creating a Map with global language data
const languageSpeakers = new Map([
    ['English', 1.5],
    ['Mandarin', 1.1],
    ['Hindi', 0.6],
    ['Spanish', 0.5]
]);

// 1. keys() - Iterating Over Keys Only
// Description: The keys() method returns an iterator of all keys in the Map.
// This is useful when you only need to process the keys without their values.
console.log("Languages available:");
for (const language of languageSpeakers.keys()) {
    console.log(language);
}
// Output: English, Mandarin, Hindi, Spanish

// 2. values() - Iterating Over Values Only
// Description: The values() method returns an iterator of all values in the Map.
// Use this when you only need to process the values, such as for calculations.
console.log("Speaker counts:");
for (const speakers of languageSpeakers.values()) {
    console.log(speakers + ' billion speakers');
}
// Output: 1.5 billion, 1.1 billion, 0.6 billion, 0.5 billion

// 3. entries() - Default Iteration (Key-Value Pairs)
// Description: The entries() method returns an iterator of [key, value] pairs.
// This is the default iteration behavior when you iterate directly over a Map.
console.log("Language statistics:");
for (const [lang, speakers] of languageSpeakers) {
    console.log(`${lang}: ${speakers} billion speakers`);
}
// Output: English: 1.5 billion, Mandarin: 1.1 billion, etc.

// 4. forEach() - Callback-Based Iteration
// Description: The forEach() method executes a provided function once for each key-value pair.
// This provides a functional programming approach to iteration.
languageSpeakers.forEach((value, key) => {
    console.log(key + ' -> ' + value + ' billion');
});

// 5. Creating Map from Array Data
// Description: You can create a Map directly from an array of [key, value] pairs.
// This is very useful when converting data from external sources.
const populationData = [
    ['Tokyo', 37.4],
    ['Delhi', 31.4],
    ['Shanghai', 27.1]
];
const cityPopulations = new Map(populationData);

// 6. Converting Map Back to Array
// Description: You can convert a Map back to an array using the spread operator.
const cityArray = [...cityPopulations];
console.log(cityArray); // [['Tokyo', 37.4], ['Delhi', 31.4], ['Shanghai', 27.1]]

Introduction to Set

A Set is a collection of unique values where each value can only occur once. Think of it as a mathematical set - like a bag where you can only put one of each item, no matter how many times you try to add the same thing.

Key Features of Set:

• Unique Values: Each value in a Set is unique - duplicates are automatically ignored
• Any Value Type: You can store primitives (strings, numbers, booleans) and objects
• Fast Lookups: Checking if a value exists is extremely fast (O(1) time complexity)
• Preserved Order: Sets maintain the insertion order of elements
• Size Property: Easy access to the number of unique elements via .size
• No Keys: Unlike Maps, Sets only store values, not key-value pairs

When to Use Set:

• When you need to ensure uniqueness in a collection
• When you frequently check if a value exists (membership testing)
• When you want to remove duplicates from arrays
• When you need to perform mathematical set operations (union, intersection, difference)
• When you want to track unique events, users, or items

// User tagging system
const uniqueTags = new Set();

// Adding tags
uniqueTags.add('javascript');
uniqueTags.add('react');
uniqueTags.add('webdev');
uniqueTags.add('javascript'); // Duplicate ignored

// Checking tags
console.log(uniqueTags.has('react')); // true
console.log(uniqueTags.size); // 3

Set Methods Overview

Let's first understand all the methods available in the Set object before diving into detailed examples. This overview will help you grasp the complete Set API.

Core Set Methods:

• add(value) - Adds a value to the Set (ignores duplicates)
• has(value) - Checks if a value exists in the Set (returns boolean)
• delete(value) - Removes a specific value from the Set
• clear() - Removes all values from the Set
• size - Property that returns the number of unique values

Iteration Methods:

• values() - Returns an iterator of all values in the Set
• keys() - Same as values() (for consistency with Map)
• entries() - Returns an iterator of [value, value] pairs
• forEach(callback) - Executes a function for each value

Constructor and Static Methods:

• new Set() - Creates a new Set object
• new Set(iterable) - Creates a Set from an array or other iterable

Detailed Set Methods

Now let's explore each Set method in detail with comprehensive examples and explanations:

// Creating a Set for tracking unique research participants
const researchParticipants = new Set();

// 1. add(value) - Adding Values to the Set
// Description: The add() method adds a value to the Set. If the value already exists,
// it's ignored (no error is thrown). The method returns the Set object for chaining.
researchParticipants.add('P101');
researchParticipants.add('P102');
researchParticipants.add('P103');

// Adding a duplicate value (will be ignored)
researchParticipants.add('P101'); // This won't add anything new
console.log(researchParticipants.size); // Still 3

// 2. has(value) - Checking Value Existence
// Description: The has() method returns a boolean indicating whether an element
// exists in the Set. This is one of the fastest operations in Set.
console.log(researchParticipants.has('P102')); // true
console.log(researchParticipants.has('P999')); // false

// 3. delete(value) - Removing Values
// Description: The delete() method removes the specified value from the Set.
// It returns true if the value was successfully removed, false otherwise.
const wasRemoved = researchParticipants.delete('P101');
console.log(wasRemoved); // true
console.log(researchParticipants.has('P101')); // false

// 4. clear() - Removing All Values
// Description: The clear() method removes all values from the Set.
// This is useful when you want to reset the entire Set.
// researchParticipants.clear(); // Uncomment to clear all participants

// 5. size - Getting the Number of Unique Values
// Description: The size property returns the number of unique values in the Set.
// This is a read-only property that automatically updates as elements are added/removed.
console.log(researchParticipants.size); // 2 (after deleting P101)

// 6. Creating Set from Array (Deduplication)
// Description: One of the most powerful features of Set is automatic deduplication
// when created from an array or other iterable.
const surveyResponses = [45, 42, 45, 47, 42, 45, 48];
const uniqueResponses = new Set(surveyResponses);
console.log([...uniqueResponses]); // [45, 42, 47, 48] - duplicates removed!

// 7. Method Chaining Example
// Description: Since add() returns the Set object, you can chain multiple add() calls
// for more concise code when initializing a Set.
const programmingLanguages = new Set()
    .add('JavaScript')
    .add('Python')
    .add('Java')
    .add('C++')
    .add('JavaScript'); // This duplicate will be ignored

Set Iteration Methods

Sets provide efficient iteration capabilities similar to Maps, but focused on values:

// Creating a Set with unique user IDs
const activeUsers = new Set(['user1', 'user2', 'user3', 'user4']);

// 1. values() - Iterating Over Values
// Description: The values() method returns an iterator of all values in the Set.
// This is the most common way to iterate over a Set.
console.log("Active users:");
for (const user of activeUsers.values()) {
    console.log(user);
}

// 2. keys() - Same as values() (for consistency)
// Description: The keys() method returns the same iterator as values().
// This is provided for consistency with Map interface.
for (const user of activeUsers.keys()) {
    console.log(user); // Same as values()
}

// 3. entries() - Key-Value Pairs (where key = value)
// Description: The entries() method returns an iterator of [value, value] pairs.
// This is provided for consistency with Map interface.
for (const [key, value] of activeUsers.entries()) {
    console.log(`Key: ${key}, Value: ${value}`); // Key and value are the same
}

// 4. forEach() - Callback-Based Iteration
// Description: The forEach() method executes a provided function once for each value.
// This provides a functional programming approach to iteration.
activeUsers.forEach((value, key) => {
    console.log(`Processing user: ${value}`);
});

// 5. Direct Iteration (Default behavior)
// Description: You can iterate directly over a Set, which is equivalent to using values().
for (const user of activeUsers) {
    console.log(user);
}

// 6. Converting Set to Array
// Description: You can convert a Set to an array using the spread operator.
const userArray = [...activeUsers];
console.log(userArray); // ['user1', 'user2', 'user3', 'user4']

Real-World Applications

Practical applications of Set in real-world scenarios:

// 1. Email Deduplication - Removing Duplicate Emails
// Description: One of the most common use cases for Set is removing duplicates from arrays.
// This is especially useful when processing user data, email lists, or any collection where uniqueness matters.
const duplicateEmails = ['john@example.com', 'jane@example.com', 'john@example.com', 'bob@example.com', 'jane@example.com'];
const uniqueEmails = [...new Set(duplicateEmails)];
console.log(uniqueEmails); // ['john@example.com', 'jane@example.com', 'bob@example.com']

// 2. User Permission Checking - Fast Membership Testing
// Description: Sets provide O(1) time complexity for membership testing, making them perfect
// for checking user permissions, roles, or any access control scenarios.
const adminUsers = new Set(['admin1', 'admin2', 'superuser', 'moderator']);
const currentUser = 'admin1';
console.log(adminUsers.has(currentUser)); // true - Fast lookup!

// 3. Mathematical Set Operations - Union, Intersection, Difference
// Description: Sets are perfect for mathematical operations, making them ideal for
// data analysis, filtering, and complex logic operations.
const setA = new Set([1, 2, 3, 4, 5]);
const setB = new Set([4, 5, 6, 7, 8]);

// Union - All elements from both sets
const union = new Set([...setA, ...setB]);
console.log([...union]); // [1, 2, 3, 4, 5, 6, 7, 8]

// Intersection - Elements that exist in both sets
const intersection = new Set([...setA].filter(x => setB.has(x)));
console.log([...intersection]); // [4, 5]

// Difference - Elements in setA but not in setB
const difference = new Set([...setA].filter(x => !setB.has(x)));
console.log([...difference]); // [1, 2, 3]

// 4. Tracking Unique Events - Event Logging
// Description: Sets are excellent for tracking unique events, user sessions, or any scenario
// where you need to ensure no duplicates are recorded.
const uniquePageViews = new Set();
uniquePageViews.add('homepage');
uniquePageViews.add('products');
uniquePageViews.add('homepage'); // Ignored - already exists
uniquePageViews.add('contact');
console.log(uniquePageViews.size); // 3 (not 4)

// 5. Tag Management - Unique Tags System
// Description: Sets are perfect for managing tags, categories, or labels where uniqueness is important.
const articleTags = new Set();
articleTags.add('javascript');
articleTags.add('react');
articleTags.add('web-development');
articleTags.add('javascript'); // Ignored
console.log([...articleTags]); // ['javascript', 'react', 'web-development']

Data Structure Conversions

One of the most powerful features of Map and Set is their ability to seamlessly convert between different data structures. This flexibility makes them incredibly useful in real-world applications:

Object ↔ Map Conversions

Converting between objects and Maps is one of the most common operations in modern JavaScript. This is especially useful when working with APIs, configuration objects, or when you need to switch between simple object notation and Map's advanced features.

// 1. Object to Map Conversion
// Description: Converting objects to Maps is useful when you need Map's advanced features
// like complex keys, preserved order, or better performance for frequent operations.

// Method 1: Using Object.entries() (Most Common)
const userSettings = { 
    darkMode: true, 
    fontSize: 14, 
    language: 'en',
    theme: 'dark',
    notifications: true 
};

// Convert object to Map
const settingsMap = new Map(Object.entries(userSettings));
console.log(settingsMap.get('darkMode')); // true
console.log(settingsMap.size); // 5

// Method 2: Manual conversion with custom logic
const configObject = { 
    apiUrl: 'https://api.example.com',
    timeout: 5000,
    retries: 3 
};

const configMap = new Map();
for (const [key, value] of Object.entries(configObject)) {
    configMap.set(key, value);
}

// 2. Map to Object Conversion
// Description: Converting Maps back to objects is useful for serialization,
// API responses, or when you need simple object notation.

// Method 1: Using Object.fromEntries() (ES2019+)
const userPreferencesMap = new Map([
    ['theme', 'dark'],
    ['fontSize', 16],
    ['sidebar', true],
    ['animations', false]
]);

const userPreferencesObj = Object.fromEntries(userPreferencesMap);
console.log(userPreferencesObj);
// Output: { theme: 'dark', fontSize: 16, sidebar: true, animations: false }

// Method 2: Manual conversion with filtering
const filteredMap = new Map([
    ['public', 'visible'],
    ['private', 'hidden'],
    ['internal', 'restricted']
]);

// Convert only specific entries
const publicSettings = Object.fromEntries(
    Array.from(filteredMap.entries()).filter(([key, value]) => value === 'visible')
);
console.log(publicSettings); // { public: 'visible' }

// 3. Advanced Object ↔ Map Conversions
// Description: These patterns handle complex scenarios like nested objects,
// type conversion, and data transformation.

// Converting nested objects to Maps
const nestedConfig = {
    database: {
        host: 'localhost',
        port: 5432,
        name: 'myapp'
    },
    cache: {
        enabled: true,
        ttl: 3600
    }
};

// Convert nested object to nested Maps
const nestedMap = new Map();
for (const [key, value] of Object.entries(nestedConfig)) {
    if (typeof value === 'object' && value !== null) {
        nestedMap.set(key, new Map(Object.entries(value)));
    } else {
        nestedMap.set(key, value);
    }
}

console.log(nestedMap.get('database').get('host')); // 'localhost'

// Converting back to nested objects
const backToNestedObj = {};
for (const [key, value] of nestedMap) {
    if (value instanceof Map) {
        backToNestedObj[key] = Object.fromEntries(value);
    } else {
        backToNestedObj[key] = value;
    }
}

// 4. Real-World Use Cases
// Description: Practical examples of when you'd use these conversions.

// API Response Processing
const apiResponse = {
    user: { id: 1, name: 'John' },
    permissions: ['read', 'write'],
    settings: { theme: 'dark', lang: 'en' }
};

// Convert to Map for processing
const responseMap = new Map(Object.entries(apiResponse));

// Process and convert back
const processedResponse = Object.fromEntries(responseMap);

// Configuration Management
const defaultConfig = { timeout: 5000, retries: 3 };
const userConfig = { timeout: 10000 };

// Merge configurations using Map
const defaultMap = new Map(Object.entries(defaultConfig));
const userMap = new Map(Object.entries(userConfig));

// Merge (user config overrides default)
for (const [key, value] of userMap) {
    defaultMap.set(key, value);
}

const finalConfig = Object.fromEntries(defaultMap);
console.log(finalConfig); // { timeout: 10000, retries: 3 }

// 5. Array ↔ Set Conversion (Deduplication)
// Description: This is one of the most powerful conversion patterns in JavaScript.
// It allows you to easily remove duplicates from any array.
const duplicateNumbers = [1, 2, 2, 3, 4, 4, 5, 1, 6, 2];
const uniqueNumbers = [...new Set(duplicateNumbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5, 6]

// Set back to Array conversion
const backToArray = Array.from(uniqueNumbers);
console.log(backToArray); // [1, 2, 3, 4, 5, 6]

// 6. Map ↔ Array Conversion
// Description: Converting Maps to arrays and vice versa is useful for data processing,
// serialization, and working with external APIs.
const colorCodes = new Map([
    ['red', '#FF0000'], 
    ['green', '#00FF00'], 
    ['blue', '#0000FF']
]);

// Map to Array conversion
const colorArray = [...colorCodes];
console.log(colorArray); // [['red', '#FF0000'], ['green', '#00FF00'], ['blue', '#0000FF']]

// Array back to Map conversion
const backToMap = new Map(colorArray);
console.log(backToMap.get('red')); // '#FF0000'

// 7. Advanced Conversion Patterns
// Description: These patterns combine multiple conversions for complex data transformations.

// Converting array of objects to Map with custom keys
const users = [
    { id: 1, name: 'John', email: 'john@example.com' },
    { id: 2, name: 'Jane', email: 'jane@example.com' },
    { id: 3, name: 'Bob', email: 'bob@example.com' }
];

// Create Map with user ID as key and user object as value
const userMap = new Map(users.map(user => [user.id, user]));
console.log(userMap.get(1).name); // 'John'

// Create Map with email as key and name as value
const emailToNameMap = new Map(users.map(user => [user.email, user.name]));
console.log(emailToNameMap.get('jane@example.com')); // 'Jane'

// 8. Set Operations with Arrays
// Description: Combining Sets with arrays enables powerful data manipulation operations.

// Finding unique values across multiple arrays
const array1 = [1, 2, 3, 4];
const array2 = [3, 4, 5, 6];
const array3 = [5, 6, 7, 8];

const allUniqueValues = [...new Set([...array1, ...array2, ...array3])];
console.log(allUniqueValues); // [1, 2, 3, 4, 5, 6, 7, 8]

// Finding common elements (intersection)
const commonElements = [...new Set(array1)].filter(x => 
    array2.includes(x) && array3.includes(x)
);
console.log(commonElements); // [] (no common elements in all three arrays)

Key Insights from Object ↔ Map Conversions:

• Object.entries(): This is the most common and efficient way to convert objects to Maps. It returns an array of [key, value] pairs that can be directly passed to the Map constructor.
• Object.fromEntries(): This ES2019 method is the standard way to convert Maps back to objects. It's clean, readable, and handles all edge cases properly.
• Nested Conversions: For complex nested objects, you need to recursively convert each level. This is useful for configuration management and API response processing.
• Filtering During Conversion: You can filter entries during conversion using Array methods like filter(), map(), or reduce().
• Configuration Merging: Converting to Map, merging, and converting back is a powerful pattern for configuration management.

When to Use Object ↔ Map Conversions:

• API Integration: When working with APIs that return objects but you need Map features
• Configuration Management: When merging default and user configurations
• Data Processing: When you need to process object data with Map methods
• Serialization: When you need to convert Map data back to JSON-compatible objects
• Legacy Code Integration: When working with existing code that uses objects

Performance Comparison

Understanding when to use Map/Set versus alternatives is crucial for writing efficient JavaScript code. Let's explore the performance characteristics and use cases:

// 1. Map vs Object Performance Comparison
// Description: Maps and Objects have different performance characteristics depending on the use case.
// Maps are generally better for frequent additions/deletions, while Objects are better for simple key-value storage.

const testMap = new Map();
const testObj = {};

// Insertion Performance Test
console.time('Map insertion');
for (let i = 0; i < 100000; i++) {
    testMap.set(i, i);
}
console.timeEnd('Map insertion'); // Generally faster for large datasets

console.time('Object insertion');
for (let i = 0; i < 100000; i++) {
    testObj[i] = i;
}
console.timeEnd('Object insertion');

// Lookup Performance Test
console.time('Map lookup');
for (let i = 0; i < 100000; i++) {
    testMap.get(i);
}
console.timeEnd('Map lookup');

console.time('Object lookup');
for (let i = 0; i < 100000; i++) {
    testObj[i];
}
console.timeEnd('Object lookup');

// 2. Set vs Array Performance Comparison
// Description: Sets provide O(1) time complexity for membership testing,
// while Arrays provide O(n) time complexity for the same operation.

const testSet = new Set();
const testArr = [];

// Adding elements
console.time('Set add');
for (let i = 0; i < 100000; i++) {
    testSet.add(i);
}
console.timeEnd('Set add');

console.time('Array push');
for (let i = 0; i < 100000; i++) {
    testArr.push(i);
}
console.timeEnd('Array push');

// Membership testing (the key difference!)
console.time('Set has');
for (let i = 0; i < 1000; i++) {
    testSet.has(99999); // O(1) - Constant time
}
console.timeEnd('Set has');

console.time('Array includes');
for (let i = 0; i < 1000; i++) {
    testArr.includes(99999); // O(n) - Linear time
}
console.timeEnd('Array includes'); // Much slower!

// 3. Memory Usage Comparison
// Description: Understanding memory usage is important for large-scale applications.

// Map memory usage
const mapMemory = new Map();
for (let i = 0; i < 10000; i++) {
    mapMemory.set(`key${i}`, `value${i}`);
}

// Object memory usage
const objMemory = {};
for (let i = 0; i < 10000; i++) {
    objMemory[`key${i}`] = `value${i}`;
}

// Set memory usage
const setMemory = new Set();
for (let i = 0; i < 10000; i++) {
    setMemory.add(`value${i}`);
}

// Array memory usage
const arrMemory = [];
for (let i = 0; i < 10000; i++) {
    arrMemory.push(`value${i}`);
}

console.log('Memory usage comparison completed');
console.log('Map size:', mapMemory.size);
console.log('Object keys:', Object.keys(objMemory).length);
console.log('Set size:', setMemory.size);
console.log('Array length:', arrMemory.length);

Best Practices

To make the most of Map and Set in your JavaScript applications, follow these best practices:

Map Best Practices:

• Use Maps for Complex Keys: When you need objects, functions, or other complex types as keys
• Preserve Insertion Order: When the order of key-value pairs matters
• Frequent Additions/Removals: When you frequently add or remove key-value pairs
• Size Tracking: When you need to know the exact number of entries
• Avoid Prototype Pollution: When you want to avoid inheriting properties from Object.prototype

Set Best Practices:

• Uniqueness Requirements: When you need to ensure all values are unique
• Fast Membership Testing: When you frequently check if a value exists
• Deduplication: When you need to remove duplicates from arrays
• Mathematical Operations: When you need to perform set operations (union, intersection, difference)
• Event Tracking: When you need to track unique events or user sessions

General Best Practices:

• Choose the Right Tool: Use Objects for simple key-value storage, Maps for complex scenarios
• Performance Considerations: Use Sets for membership testing, Arrays for ordered collections
• Memory Management: Clear Maps and Sets when they're no longer needed
• Type Safety: Be consistent with the types of keys/values you store
• Error Handling: Always check for existence before accessing values

Comprehensive Summary

• When to use Map:
  • Need complex keys (objects, functions)
  • Frequent additions/removals
  • Important insertion order
  • Need to know exact size
• When to use Set:
  • Need to enforce uniqueness
  • Fast membership checking
  • Mathematical set operations
  • Removing duplicates from arrays