현재 번역은 완벽하지 않습니다. 한국어로 문서 번역에 동참해주세요.

Map 객체는 간단한 key/value map 이다. 어떠한 value ( 객체들과 primitive values 둘 모두, 키 또는 값으로서 사용될 수 있을 것이다.


new Map([iterable])


Iterable 은 배열이거나, element 들이 key-value 쌍(2-element Arrays)을 이루는 다른 iterable 객체이다. 각 key-value 쌍은 새로운 Map 에 추가된다. nullundefined 로서 취급된다.


Map 객체는 삽입 순서대로 그것의 element 들을 순회한다. — for...of loop 는 각 반복 동안 [key, value] 배열을 반환한다.

It should be noted that a Map that 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 "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 (and because there were no built-in alternatives), 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. This could be bypassed by using map = Object.create(null) since ES5, but was seldomly done.
  • The keys of an Object are Strings and Symbols, 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.

This does not mean you should use Maps everywhere, objects still are used in most cases. Map instances are only useful for collections, and you should consider adapting your code where you have previously used objects for such. Objects shall be used as records, with fields and methods.
If you're still 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, and can be used interchangeably?
  • Do you need keys that aren't strings?
  • Are key-value pairs often added or removed?
  • Do you have an arbitrary (easily changing) amount of key-value pairs?
  • Is the collection iterated?

Those all are signs that you want a Map for a collection. If in contrast you have a fixed amount of keys, operate on them individually, and distinguish between their usage, then you want an object.


length 속성의 값은 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

모든 Map instance 들은 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

Map 들은 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()

Map 들은 forEach() 메소드의 사용으로 순회할 수 있다. :

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 spread operator to transform a map into a 2D key-value Array.
console.log(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
console.log(uneval([...myMap.keys()])); // Will show ["key1", "key2"]


Specification Status Comment
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'Map' in that specification.
Standard Initial definition.
ECMAScript 2017 Draft (ECMA-262)
The definition of 'Map' in that specification.

Browser compatibility

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

38 [1]

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

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

See also

문서 태그 및 공헌자

 이 페이지의 공헌자: dragmove
 최종 변경: dragmove,