What are TypeScript merge maps?

Key takeaways:

  • In TypeScript, maps can be merged using the spread operator, Map.forEach() with Map.set(), or the for...of loop, each offering different flexibility and control depending on the use case.

    • Spread operator combines maps by unpacking entries into a new map.

    • Map.forEach() with Map.set() iterates over one map and adds its entries to another.

    • for...of iterates over one map and adds entries to another map.

  • The Map.forEach() and for...of loop with Map.set() provide more control for merging with custom logic, such as handling duplicates.

In TypeScript, maps are a commonly used data structure that allows you to store key-value pairs. Merging maps combines the contents of two or more maps into a single map, and TypeScript provides several ways to achieve this. This Answer will explore different ways to merge maps with code examples.

Different ways to merge TypeScript maps

Let’s go through various ways to merge two or more Map objects in TypeScript, using different techniques:

  1. Spread operator

  2. Map.forEach() with Map.set()

  3. for...of loop

Method 1: Using the spread operator (...)

The most straightforward method to merge two maps in TypeScript is to use the spread operator (...). This allows us to unpack the entries from the original maps and create a new Map instance.

// Function to merge two maps
function mergeMaps<K, V>(map1: Map<K, V>, map2: Map<K, V>): Map<K, V> {
    // Use the spread operator to create a new map with the combined key-value pairs
    const mergedMap = new Map([...map1, ...map2]);
    return mergedMap;
}
// Example usage
const map1 = new Map<number, string>([[1, 'one'], [2, 'two']]);
const map2 = new Map<number, string>([[3, 'three'], [4, 'four']]);
const mergedMap = mergeMaps(map1, map2);
// Display the merged map
console.log("Merged Map:", mergedMap);

Explanation

  • Line 2: The mergeMaps function takes two Map objects (map1 and map2) as input parameters. Inside the function, the spread operator (...) creates a new array containing all the key-value pairs from both maps.

  • Lines 4: The new Map([...map1, ...map2]) syntax is then used to create a new Map object with the combined key-value pairs.

  • Line 5: The merged map (mergedMap) is returned from the function.

  • Lines 9–10: In the example usage, two maps (map1 and map2) are created with numeric keys and string values.

  • Line 12: The mergeMaps function is called with these two maps, and the resulting merged map is stored in the mergedMap variable.

  • Line 15: Finally, the merged map is displayed using console.log.

Method 2: Using Map.forEach() with Map.set()

Another approach for merging maps is using the forEach() method of the Map object. This allows us to iterate over the entries of one map and add them to another map.

// Function to merge two maps
function mergeMaps<K, V>(map1: Map<K, V>, map2: Map<K, V>): Map<K, V> {
    const mergedMap = new Map(map1); // Start with a copy of map1
    map2.forEach((value, key) => {
        mergedMap.set(key, value); // Add each entry from map2 to the mergedMap
    });
    return mergedMap;
}
// Example usage
const map1 = new Map<number, string>([[1, 'one'], [2, 'two']]);
const map2 = new Map<number, string>([[3, 'three'], [4, 'four']]);
const mergedMap = mergeMaps(map1, map2);
// Display the merged map
console.log("Merged Map:", mergedMap);

Explanation

  • Line 3: We create a copy of map1 using new Map(map1), so map1 remains unchanged

  • Line 4: The forEach() method is used to iterate over map2 and add each entry to the merged map using the Map.set() method.

Method 3: Using for...of loop

The for...of loop is a TypeScript construct allowing us to iterate over iterable objects, such as arrays, strings, Map objects, and Set objects. Here’s an example of how we can use them for...of loop to merge two Map objects and add custom logic for handling duplicate keys:

// Function to merge two maps
function mergeMaps<K, V>(map1: Map<K, V>, map2: Map<K, V>): Map<K, V> {
     const mergedMap = new Map<K, V>(map1); // Start with map1's entries
    // Iterate over map2's entries
    for (const [key, value] of map2) {
        mergedMap.set(key, value); // Add each entry to the mergedMap
    }
    return mergedMap;
}
// Example usage
const map1 = new Map<number, string>([[1, 'one'], [2, 'two']]);
const map2 = new Map<number, string>([[3, 'three'], [4, 'four']]);
const mergedMap = mergeMaps(map1, map2);
// Display the merged map
console.log("Merged Map:", mergedMap);

Conclusion

Merging maps in TypeScript can be done in various ways, depending on the specific needs of our application. Each of these methods can be used in different scenarios, depending on the complexity of the data and how we need to handle key-value pairs. By understanding these approaches, we can confidently merge maps and combine data structures in a type-safe and efficient manner in TypeScript.

Frequently asked questions

Haven’t found what you were looking for? Contact Us

What are maps in TypeScript?

In TypeScript, a map is a data structure that stores key-value pairs. Unlike arrays, which use integer indices to access elements, maps use arbitrary keys to access values. This makes maps versatile for storing data where the key-value relationship is more important than the order of elements.

What is a TypeScript map file?

A TypeScript map file is a .map file that contains debugging information about the original source code. This information is essential for tools like source maps to map the generated JavaScript code back to the original TypeScript code. This enables better debugging experiences and code understanding.

Free Resources

Copyright ©2026 Educative, Inc. All rights reserved