mozilla
Your Search Results

    Map

    This is an experimental technology, part of the ECMAScript 6 (Harmony) proposal.
    Because this technology's specification has not stabilized, check the compatibility table for usage in various browsers. Also note that the syntax and behavior of an experimental technology is subject to change in future version of browsers as the spec changes.

    Summary

    The Map object is a simple key/value map. Any value (both objects and primitive values) may be used as either a key or a value.

    Syntax

    new Map([iterable])
    

    Parameters

    iterable
    Iterable is an Array or other iterable object whose elements are key-value pairs (2-element Arrays). Each key-value pair will be added to the new Map. null is treated as undefined.

    Description

    A Map object can iterate its elements in insertion order - a for..of loop will return an array of [key, value] for each iteration.

    Key equality

    Key equality is based on the "same-value" 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 earlier versions of the ECMAScript 6 draft -0 and +0 were considered distinct (even though -0 === +0), this has been changed in later versions and has been adapted in Gecko 29 (Firefox 29 / Thunderbird 29 / SeaMonkey 2.26) (bug 952870) and a recent nightly Chrome.

    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, Objects have been used as Maps historically; however, there are important differences between Objects and Maps that make using a Map better.

    • An Object has a prototype, so there are default keys in the map. However, this can be bypassed using map = Object.create(null).
    • The keys of an Object are Strings, where they can be any value for a Map.
    • You can get the size of a Map easily while you have to manually keep track of size for an Object.

    Use maps over objects when keys are unknown until run time, and when all keys are the same type and all values are the same type.

    Use objects when there is logic that operates on individual elements.

    Properties

    Map.length
    The value of the length property is 0.
    get Map[@@species]
    The constructor function that is used to create derived objects.
    Map.prototype
    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.

    Properties

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

    Methods

    Map.prototype.clear()
    Removes all key/value pairs from the Map object.
    Map.prototype.delete(key)
    Removes any value associated to the key and returns the value that Map.prototype.has(value) would have previously returned. Map.prototype.has(key) will return false afterwards.
    Map.prototype.entries()
    Returns 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.
    Map.prototype.get(key)
    Returns the value associated to the key, or undefined if there is none.
    Map.prototype.has(key)
    Returns a boolean asserting whether a value has been associated to the key in the Map object or not.
    Map.prototype.keys()
    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.
    Map.prototype.values()
    Returns a new Iterator object that contains the values for each element in the Map object in insertion order.
    Map.prototype[@@iterator]()
    Returns a new Iterator object that contains an array of [key, value] for each element in the Map object in insertion order.

    Examples

    Example: Using the Map object

    var myMap = new Map();
    
    var keyObj = {},
        keyFunc = function () {},
        keyString = "a string";
    
    // 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 () {}
    

    Example: 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"
    

    Example: 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) {
      alert(key + " = " + value);
    }
    // Will show 2 alerts; first with "0 = zero" and second with "1 = one"
    
    for (var key of myMap.keys()) {
      alert(key);
    }
    // Will show 2 alerts; first with "0" and second with "1"
    
    for (var value of myMap.values()) {
      alert(value);
    }
    // Will show 2 alerts; first with "zero" and second with "one"
    
    for (var [key, value] of myMap.entries()) {
      alert(key + " = " + value);
    }
    // Will show 2 alerts; first with "0 = zero" and second with "1 = one"
    
    myMap.forEach(function(value, key) {
      alert(key + " = " + value);
    }, myMap)
    // Will show 2 alerts; first with "0 = zero" and second with "1 = one"
    

    Example: 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 spread operator to transform a map into a 2D key-value Array.
    alert(uneval([...myMap])); // Will show you exactly the same Array as kvArray
    
    // Or use the spread operator on the keys or values iterator to get 
    // an array of only the keys or values
    alert(uneval([...myMap.keys()])); // Will show ["key1", "key2"]
    

    Specifications

    Specification Status Comment
    ECMAScript 6 (ECMA-262)
    The definition of 'Map' in that specification.
    Release Candidate Initial definition.

    Browser compatibility

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

    31 [1]
    38

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

    [1] The feature is available behind a preference. In chrome://flags, activate the entry “Enable Experimental JavaScript”.

    See also