MDN wants to learn about developers like you: https://qsurvey.mozilla.com/s3/MDN-dev-survey

To tłumaczenie jest niekompletne. Pomóż przetłumaczyć ten artykuł z języka angielskiego.

Map jest prostym obiektem mapującym klucze/wartości. Każdy element (zarówno objekt jak i wartości proste) mogą być użyte zarówno jako klucz jak i wartość.

Składnia

new Map([iterable])

Parametry

iterable
Iterable jest tablicą lub innym iterowalnym obiektem, którego elementy są parami typu klucz-wartość (np. 2 elementowa tablica). Każda para klucz-wartość jest dodawana obiektu new Map. null jest jest traktowane jako undefined

Opis

Obiekt Map iteruje swoje elementy we wprowadzonej kolejności — pętla for...of zwraca tablicę  [key, value] dla każdej iteracji.

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.  

Równość kluczy


Równość kluczy jest bazowana na tzw. algorytmie "same-value" (tej samej wartości). NaN jest traktowana jako równa NaN (nawet jeśli NaN !== NaN) jak i wszystkie inne wartości są uważane za równe, zgodnie z semantyką === operatora równości. We wcześniejszych wersjach szkiców ECMAScript 2015 rozważano rozróżnienie -0 and +0 (even though -0 === +0), to zostało zmienione w późniejszych wersjach i adaptowane w Gecko 29 (Firefox 29 / Thunderbird 29 / SeaMonkey 2.26) (błąd 952870) jak i recent nightly Chrome.

Porównanie Obiektów i Map.

Obiekty są podobne do Map. W obu przypadkach pozwalają ustawić klucze dla wartości, zwracają te wartości, usuwają klucze i wykrywają czy coś jest przechowywane jako klucz. Z tego powodu (i ponieważ nie było innych wbudowanych alternatyw), Objects  były używane wcześniej jako Map'y; jednakże, istnieją ważne różnice pomiędzy Obiektami i Mapami które czynią używanie Map lepszym:

  • Obiekt posiada prototyp, tak więc istnieją domyślne klucze które mogą kolidować z Twoimi kluczami jeśli nie jesteś ostrożny. Można by to ominąć używając Object.create(null) od ES5, ale było rzadko stosowane.
  • Klucze obiektu są Strings'ami i Symbol'ami, podczas gdy dla Map mogą być dowolną wartością włączając funkcje, obiekty, czy wartości proste.
  • Można łatwo pobrać wielkość mapy używając właściwości size , podczas gdy wielkość obiektu musi być określana ręcznie.

To nie oznacza, że powinno się używać Maps wszędzie. Obiekty są używane wciąż w większości przypadków.  Instancje Map są użyteczne jedynie dla kolekcji. Warto rozważyć ich zaadaptowanie jedynie w przypadkach gdy wcześniej używano dla nich obiektów. Obiekty powinny być używane jako rejestr z polami i metodami. Jesli wciąż nie jesteś pewien czego użyć, pomocne mogą okazać się poniższe pytania:

  • Czy klucze są zazwyczaj nieznane do momentu uruchomienia programu. Czy potrzebujesz wyszukiwać je dynamicznie?
  • Czy wszystkie wartości mają ten sam typ? Czy mogą być użyte naprzemiennie?
  • Do all values have the same type? Can they be used interchangeably?
  • Czy potrzebujesz kluczy które nie są typu string?
  • Czy pary klucz-wartość są często dodawane lub usuwane?
  • Czy masz dowolną (łatwo zmienialną) liczbę par klucz-wartość?
  • Czy kolekcja jest iterowalna?

If you answered 'yes' to any of those questions, that is a sign that you might want to use a Map. In contrast — if you have a fixed amount of keys, operate on them individually, and distinguish between their usage, then you probably want to use an object.

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(key) would have previously returned. Map.prototype.has(key) will return false afterwards.
Map.prototype.entries()
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

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()) {
  console.log(key);
}
// 0
// 1

for (var value of myMap.values()) {
  console.log(value);
}
// 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 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"]

Specifications

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.
Draft  

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
38
12 19 (19) 11 25 7.1
Map.keys(), Map.values(), Map.entries() 37
38
12 20 (20) No support 25 7.1
Map.forEach() 36
38
12 25 (25) 11 25 7.1
Key equality for -0 and 0 34
38
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 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 9
iterable No support No support 17.0 (17) No support No support 8
Map.clear() No support 31
38
19.0 (19) No support No support 8
Map.keys(), Map.values(), Map.entries() No support 37
38
20.0 (20) No support No support 8
Map.forEach() No support 36
38
25.0 (25) No support No support 8
Key equality for -0 and 0 No support 34
38
29.0 (29) No support No support No support
Constructor argument: new Map(null) ? (Yes) 37.0 (37) ? ? 9
Monkey-patched set() in Constructor ? (Yes) 37.0 (37) ? ? 9
Map[@@species] ? ? 41.0 (41) ? ? 10
Map() without new throws 5.1 ? 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

Autorzy i etykiety dokumentu

 Autorzy tej strony: broslukasz
 Ostatnia aktualizacja: broslukasz,