The Map object holds key-value pairs. Any value (both objects and primitive values) may be used as either a key or a value.


new Map([iterable])


An Array or other iterable object whose elements are key-value pairs. Each key-value pair is added to the new Map; null values are treated as undefined.


A Map object iterates its elements in insertion order — a for...of loop returns an array of [key, value] for each iteration.

It should be noted that a Map which is a map of an object, especially a dictionary of dictionaries, will only map to the object's insertion order—which is random and not ordered.

Key equality

Key equality is based on the "SameValueZero" algorithm: NaN is considered the same as NaN (even though NaN !== NaN) and all other values are considered equal according to the semantics of the === operator. In the current ECMAScript specification -0 and +0 are considered equal, although this was not so in earlier drafts. See "Value equality for -0 and 0" in the browser compatibility table for details.

Objects and maps compared

Objects are similar to Maps in that both let you set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. Because of this (and because there were no built-in alternatives), Objects have been used as Maps historically; however, there are important differences that make using a Map preferable in certain cases:

  • An Object has a prototype, so there are default keys in the map that could collide with your keys if you're not careful. As of ES5 can be bypassed by using map = Object.create(null), but is seldom done.
  • The keys of an Object are Strings and Symbols, whereas they can be any value for a Map, including functions, objects, and any primitive.
  • You can get the size of a Map easily with the size property, while the size of an Object must be determined manually.

This does not mean you should use Maps everywhere. If you're not sure which one to use, ask yourself the following questions:

  • Are keys usually unknown until run time? Do you need to look them up dynamically?
  • Do all values have the same type? Can they be used interchangeably?
  • Do you need keys that aren't strings?
  • Are key-value pairs frequently added or removed?
  • Do you have an arbitrary (easily changing) number of key-value pairs?
  • Is the collection iterated?

If you answered 'yes' to any of those questions, that is a sign that you might want to use a Map. Contrariwise, if you have a fixed number of keys, operate on them individually, or distinguish between their usage, then you probably want to use an Object.


The value of the length property is 0.
get Map[@@species]
The constructor function that is used to create derived objects.
Represents the prototype for the Map constructor. Allows the addition of properties to all Map objects.

Map instances

All Map instances inherit from Map.prototype.


Returns the function that created an instance's prototype. This is the Map function by default.
Returns the number of key/value pairs in the Map object.


Removes all key/value pairs from the Map object.
Removes any value associated to the key and returns the value that Map.prototype.has(key) would have previously returned. Map.prototype.has(key) will return false afterwards.
Returns a new Iterator object that contains an array of [key, value] for each element in the Map object in insertion order.
Map.prototype.forEach(callbackFn[, thisArg])
Calls callbackFn once for each key-value pair present in the Map object, in insertion order. If a thisArg parameter is provided to forEach, it will be used as the this value for each callback.
Returns the value associated to the key, or undefined if there is none.
Returns a boolean asserting whether a value has been associated to the key in the Map object or not.
Returns a new Iterator object that contains the keys for each element in the Map object in insertion order.
Map.prototype.set(key, value)
Sets the value for the key in the Map object. Returns the Map object.
Returns a new Iterator object that contains the values for each element in the Map object in insertion order.
Returns a new Iterator object that contains an array of [key, value] for each element in the Map object in insertion order.


Using the Map object

var myMap = new Map();

var keyString = 'a string',
    keyObj = {},
    keyFunc = function() {};

// setting the values
myMap.set(keyString, "value associated with 'a string'");
myMap.set(keyObj, 'value associated with keyObj');
myMap.set(keyFunc, 'value associated with keyFunc');

myMap.size; // 3

// getting the values
myMap.get(keyString);    // "value associated with 'a string'"
myMap.get(keyObj);       // "value associated with keyObj"
myMap.get(keyFunc);      // "value associated with keyFunc"

myMap.get('a string');   // "value associated with 'a string'"
                         // because keyString === 'a string'
myMap.get({});           // undefined, because keyObj !== {}
myMap.get(function() {}) // undefined, because keyFunc !== function () {}

Using NaN as Map keys

NaN can also be used as a key. Even though every NaN is not equal to itself (NaN !== NaN is true), the following example works because NaNs are indistinguishable from each other:

var myMap = new Map();
myMap.set(NaN, 'not a number');

myMap.get(NaN); // "not a number"

var otherNaN = Number('foo');
myMap.get(otherNaN); // "not a number"

Iterating Maps with for..of

Maps can be iterated using a for..of loop:

var myMap = new Map();
myMap.set(0, 'zero');
myMap.set(1, 'one');
for (var [key, value] of myMap) {
  console.log(key + ' = ' + value);
// 0 = zero
// 1 = one

for (var key of myMap.keys()) {
// 0
// 1

for (var value of myMap.values()) {
// zero
// one

for (var [key, value] of myMap.entries()) {
  console.log(key + ' = ' + value);
// 0 = zero
// 1 = one

Iterating Maps with forEach()

Maps can be iterated using the forEach() method:

myMap.forEach(function(value, key) {
  console.log(key + ' = ' + value);
// Will show 2 logs; first with "0 = zero" and second with "1 = one"

Relation with Array objects

var kvArray = [['key1', 'value1'], ['key2', 'value2']];

// Use the regular Map constructor to transform a 2D key-value Array into a map
var myMap = new Map(kvArray);

myMap.get('key1'); // returns "value1"

// Use the Array.from functon to transform a map into a 2D key-value Array
console.log(Array.from(myMap)); // Will show you exactly the same Array as kvArray

// Or use the keys or values iterators and convert them to an array
console.log(Array.from(myMap.keys())); // Will show ["key1", "key2"]


Browser compatibility

Feature Chrome Edge Firefox (Gecko) Internet Explorer Opera Safari
Basic support

38 [1]

12 13 (13) 11 25 7.1
Constructor argument: new Map(iterable) 38 12 13 (13) No support 25 9
iterable 38 12 17 (17) No support 25 7.1
Map.clear() 31
12 19 (19) 11 25 7.1
Map.keys(), Map.values(), Map.entries() 37
12 20 (20) No support 25 7.1
Map.forEach() 36
12 25 (25) 11 25 7.1
Key equality for -0 and 0 34
12 29 (29) No support 25 9
Constructor argument: new Map(null) (Yes) 12 37 (37) 11 (Yes) 9
Monkey-patched set() in Constructor (Yes) 12 37 (37) No support (Yes) 9
Map[@@species] 51 13 41 (41) No support 38 10
Map() without new throws (Yes) 12 42 (42) 11 (Yes) 9
Feature Android Chrome for Android Edge Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support No support 38 [1] (Yes) 13.0 (13) No support No support 8
Constructor argument: new Map(iterable) No support 38 (Yes) 13.0 (13) No support No support 9
iterable No support No support (Yes) 17.0 (17) No support No support 8
Map.clear() No support 31
(Yes) 19.0 (19) No support No support 8
Map.keys(), Map.values(), Map.entries() No support 37
(Yes) 20.0 (20) No support No support 8
Map.forEach() No support 36
(Yes) 25.0 (25) No support No support 8
Key equality for -0 and 0 No support 34
(Yes) 29.0 (29) No support No support No support
Constructor argument: new Map(null) ? (Yes) (Yes) 37.0 (37) ? ? 9
Monkey-patched set() in Constructor ? (Yes) (Yes) 37.0 (37) ? ? 9
Map[@@species] ? ? (Yes) 41.0 (41) ? ? 10
Map() without new throws 5.1 ? (Yes) 42.0 (42) ? ? 9

[1] Starting with Chrome 31, the feature was available behind a preference. In chrome://flags, activate the entry “Enable Experimental JavaScript”.

See also

© 2005–2017 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.