The The key of the element to return from the The element associated with the specified key, or get[]
method returns a specified element from a Map
object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map
object. Try it
Syntax
Parameters
key
Map
object.Return value
undefined
if the key can't be found in the Map
object. Examples
Using get[]
const myMap = new Map[];
myMap.set['bar', 'foo'];
console.log[myMap.get['bar']]; // Returns "foo"
console.log[myMap.get['baz']]; // Returns undefined
Using get[] to retrieve a reference to an object
const arr = [];
const myMap = new Map[];
myMap.set['bar', arr];
myMap.get['bar'].push['foo'];
console.log[arr]; // ["foo"]
console.log[myMap.get['bar']]; // ["foo"]
Note that the map holding a reference to the original object
effectively means the object cannot be garbage-collected, which may lead to unexpected memory issues. If you want the object stored in the map to have the same lifespan as the original one, consider using a WeakMap
.
Specifications
ECMAScript Language Specification # sec-map.prototype.get |
Browser compatibility
BCD tables only load in the browser
See also
The The specification requires maps to be implemented "that, on average, provide access times that are sublinear on the number of elements in the collection". Therefore, it could be represented internally as a hash table [with O[1] lookup], a search tree [with
O[log[N]] lookup], or any other data structure, as long as the complexity is better than O[N]. Value equality is based on the
SameValueZero algorithm. [It used to use SameValue, which treated Map
object holds key-value pairs and remembers the original insertion order of the keys. Any value [both objects and primitive values] may be used as either a key or a value. Try it
Description
Map
objects are collections of key-value pairs. A key in the Map
may
only occur once; it is unique in the Map
's collection. A Map
object is iterated by key-value pairs — a for...of
loop returns a 2-member array of [key, value]
for each iteration. Iteration happens in insertion order, which corresponds to the order in which each key-value pair was first inserted into the map by the
set[]
method [that is, there wasn't a key with the same value already in the map when set[]
was called].Key equality
0
and -0
as different. Check
browser compatibility.] This means 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.Objects vs. Maps
Object
is similar to Map
—both let you set keys to values, retrieve those values, delete keys, and detect whether
something is stored at a key. For this reason [and because there were no built-in alternatives], Object
has been used as Map
historically.
However, there are important differences that make Map
preferable in some cases:
Setting object properties
Setting Object properties works for Map objects as well, and can cause considerable confusion.
Therefore, this appears to work in a way:
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
But that way of setting a property does not interact with the Map data structure. It uses the feature of the generic object. The value of 'bla' is not stored in the Map for queries. Other operations on the data fail:
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
The correct usage for storing data in the Map is through the set[key, value]
method.
const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
Constructor
Map[]
Creates a new Map
object.
Static properties
get Map[@@species]
The constructor function that is used to create derived objects.
Instance properties
Map.prototype.size
Returns the number of key/value pairs in the Map
object.
Instance methods
Map.prototype.clear[]
Removes all key-value pairs from the Map
object.
Map.prototype.delete[]
Returns true
if an element in the Map
object existed and has been removed, or false
if the element does not exist. map.has[key]
will return false
afterwards.
Map.prototype.get[]
Returns the value associated to the passed key, or undefined
if there is none.
Map.prototype.has[]
Returns a boolean indicating whether a value has been associated with the passed key in
the Map
object or not.
Map.prototype.set[]
Sets the value for the passed key in the Map
object. Returns the Map
object.
Map.prototype[@@iterator][]
Returns a new Iterator
object that contains a two-member array of [key, value]
for each element in the Map
object in insertion order.
Map.prototype.keys[]
Returns a new Iterator object that contains the keys for each element in the Map
object in insertion order.
Map.prototype.values[]
Returns a new Iterator object that contains the values for each element in the Map
object in insertion order.
Map.prototype.entries[]
Returns a new Iterator object that contains a two-member array
of [key, value]
for each element in the Map
object in insertion order.
Map.prototype.forEach[]
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.
Examples
Using the Map object
const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const 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'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[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 NaN
s are indistinguishable from each other:
const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
Iterating Map with for...of
Maps can be iterated using a for...of
loop:
const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
Iterating Map with forEach[]
Maps can be iterated using the
forEach[]
method:
myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
Relation with Array objects
const kvArray = [['key1', 'value1'], ['key2', 'value2']];
// Use the regular Map constructor to transform a 2D key-value Array into a map
const myMap = new Map[kvArray];
console.log[myMap.get['key1']]; // "value1"
// Use Array.from[] to transform a map into a 2D key-value Array
console.log[Array.from[myMap]]; // Will show you exactly the same Array as kvArray
// A succinct way to do the same, using the spread syntax
console.log[[...myMap]];
// Or use the keys[] or values[] iterators, and convert them to an array
console.log[Array.from[myMap.keys[]]]; // ["key1", "key2"]
Cloning and merging Maps
Just like Array
s, Map
s can be cloned:
const original = new Map[[
[1, 'one'],
]];
const clone = new Map[original];
console.log[clone.get[1]]; // one
console.log[original === clone]; // false [useful for shallow comparison]
Note: Keep in mind that the data itself is not cloned.
Maps can be merged, maintaining key uniqueness:
const first = new Map[[
[1, 'one'],
[2, 'two'],
[3, 'three'],
]];
const second = new Map[[
[1, 'uno'],
[2, 'dos'],
]];
// Merge two maps. The last repeated key wins.
// Spread syntax essentially converts a Map to an Array
const merged = new Map[[...first, ...second]];
console.log[merged.get[1]]; // uno
console.log[merged.get[2]]; // dos
console.log[merged.get[3]]; // three
Maps can be merged with Arrays, too:
const first = new Map[[
[1, 'one'],
[2, 'two'],
[3, 'three'],
]];
const second = new Map[[
[1, 'uno'],
[2, 'dos'],
]];
// Merge maps with an array. The last repeated key wins.
const merged = new Map[[...first, ...second, [1, 'eins']]];
console.log[merged.get[1]]; // eins
console.log[merged.get[2]]; // dos
console.log[merged.get[3]]; // three
Specifications
ECMAScript Language Specification # sec-map-objects |
Browser compatibility
BCD tables only load in the browser
See also
- A polyfill of
Map
is available incore-js
Set
WeakMap
WeakSet