Map

Map オブジェクトはキーと値の組を保持し、キーが最初に挿入された順序を覚えています。キーや値には任意の値 (オブジェクトとプリミティブ値)を使用することができます。

解説

Map オブジェクトは、その要素について挿入順で反復処理を行うことができます。 for...of ループは各反復で [キー, 値] の配列を返します。

キーの等価性

• キーの等価性は sameValueZero アルゴリズムに基づきます。
• NaN は NaN と同じとみなされ (NaN !== NaN であっても)、他の値はすべて === 演算子の意味に従って等価性が考慮されます。
• 現在の ECMAScript 仕様書では、 -0 と +0 は等しいと考えられています。但し、以前の草稿ではそのようになっていませんでした。詳細は "Value equality for -0 and 0" をブラウザーの互換性一覧で確認してください。

Object と Map の比較

Object と Map は似ています。 — どちらもキーを値に設定したり、それらの値を受け取ったり、キーを削除したり、キーに何かが格納されているかどうかを判定したりすることができます。この意味で (そして他の内蔵オブジェクトがなかったため)、従来 Object は Map として使われてきました。

しかし、いくつかの場面で Map の方が勝るような重要な違いがあります。

コンストラクター

Map()

新しい Map オブジェクトを生成します。

プロパティ

Map.length

length プロパティの値は 0 です。
Map にいくつの項目があるかを数えるには、 Map.prototype.size を使用してください。

get Map[@@species]

派生クラスを生成するためのコンストラクター関数です。

Map.prototype

Map コンストラクターのプロトタイプを表します。すべての Map オブジェクトに追加のプロパティを定義できます。

Map インスタンス

すべての Map インスタンスは Map.prototype を継承しています。

プロパティ

Map.prototype.constructor

インスタンスのプロトタイプを生成した関数を返します。これは既定では Map 関数です。

Map.prototype.size

Map オブジェクトの中のキーと値の組の数を返します。

メソッド

Map.prototype.clear()

Mapオブジェクトからすべてのキーと値の組を削除します。

Map.prototype.delete(key)

Map オブジェクトに要素が存在し、削除された場合は true を返します、要素が存在しなければ false を返します。その後では Map.prototype.has(key) が false を返すようになります。

Map.prototype.entries()

Mapオブジェクト内の要素に対して挿入順にすべての要素の [key, value] の配列を含む、新しい Iterator オブジェクトを返します。

Map.prototype.forEach(callbackFn[, thisArg])

callbackFn を、 Map オブジェクトに存在するそれぞれのキーと値の組に対して1回ずつ、挿入順に呼び出します。 thisArg 引数が forEach に与えられた場合は、それぞれのコールバックでこれを this の値として使用します。

Map.prototype.get(key)

key で指定されたキーに結び付けられた値を返します。存在しない場合は undefined を返します。

Map.prototype.has(key)

key で指定されたキーに結び付けられた要素が Map オブジェクト内に存在するかどうかを示す boolean を返します。

Map.prototype.keys()

新しい Iterator オブジェクトを返し、これには Mapオブジェクト内の各要素のキーが挿入順で含まれます。

Map.prototype.set(key, value)

Map オブジェクト内の key で指定されたキーの値を value に設定します。その Map オブジェクトを返します。

Map.prototype.values()

新しい Iterator オブジェクトを返し、これには Mapオブジェクト内の各要素の値が挿入順で含まれます。

Map.prototype[@@iterator]()

新しい Iterator オブジェクトを返し、これには Mapオブジェクト内の各要素の [key, value] の配列が挿入順で含まれます。

例

Map オブジェクトの使用

let myMap = new Map()

let keyString = '文字列'
let keyObj    = {}
let keyFunc   = function() {}

// 値を設定する
myMap.set(keyString, "'文字列' と結び付けられた値")
myMap.set(keyObj, "keyObj と結び付けられた値")
myMap.set(keyFunc, "keyFunc と結び付けられた値")

myMap.size              // 3

// 値を取得する
myMap.get(keyString)    // "'文字列' と結び付けられた値"
myMap.get(keyObj)       // "keyObj と結び付けられた値"
myMap.get(keyFunc)      // "keyFunc と結び付けられた値"

myMap.get('文字列')      // "'文字列' と結び付けられた値"
                         // keyString === '文字列' であるため
myMap.get({})            // undefined, keyObj !== {} であるため
myMap.get(function() {}) // undefined, keyFunc !== function () {} であるため

NaN の Map のキーとしての使用

NaN もまたキーとして使うことができます。すべての NaN は自身と等しくない (NaN !== NaN は真) にもかかわらず、以下の例は動作します。これは NaN が互いに区別できないためです。

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

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

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

for..of を使用した Map の反復処理

Map は for..of ループを使用して反復処理を行うことができます。

let myMap = new Map()
myMap.set(0, 'zero')
myMap.set(1, 'one')

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

for (let key of myMap.keys()) {
  console.log(key)
}
// 0
// 1

for (let value of myMap.values()) {
  console.log(value)
}
// zero
// one

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

forEach() で Maps を反復処理

Map は forEach() メソッドを使用して反復できます。

myMap.forEach(function(value, key) {
  console.log(key + ' = ' + value)
})
// 0 = zero
// 1 = one

Array オブジェクトとの関係

let kvArray = [["キー1", "値1"], ["キー2", "値2"]];

// 通常の Map コンストラクターを使って、キー・値の 2 次元配列をマップに変換する
let myMap = new Map(kvArray)

myMap.get("キー1") // "値1" を返す

// 展開演算子を使って、マップをキー・値の 2 次元配列に変換する
console.log(Array.from(myMap)) // kvArray とまったく同じ Array を表示する

// あるいは展開演算子をキーまたは値のイテレーターに使って、キーまたは値のみの配列を得る
console.log([...myMap])

// または keys() や values() のイテレーターを使用して配列に変換する
console.log(Array.from(myMap.keys())) // ["key1", "key2"] が出力される

Map の複製と混合

Array のように、 Map は複製することができます。

let original = new Map([
  [1, 'one']
])

let clone = new Map(original)

console.log(clone.get(1))       // one
console.log(original === clone) // false (useful for shallow comparison)

Map はキーの固有性を保持しながら混合可能です。

let first = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
])

let second = new Map([
  [1, 'uno'],
  [2, 'dos']
])

// 2つのマップを混合します。重複するキーは後勝ちになります。
// スプレッド演算子は基本的に Map を Array に変換します。
let merged = new Map([...first, ...second])

console.log(merged.get(1)) // uno
console.log(merged.get(2)) // dos
console.log(merged.get(3)) // three

Map は Array と混合することもできます。

let first = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
])

let second = new Map([
  [1, 'uno'],
  [2, 'dos']
])

// マップと配列を混合します。重複するキーは後勝ちになります。
let 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

使用上のメモ

ご注意ください。 Map オブジェクトに対するオブジェクトプロパティをの設定は正しく動作しますが、考えられる混乱を引き起こすことがあります。

従って、これは一応動作します・・・

let wrongMap = new Map()
wrongMap['bla'] = 'blaa'
wrongMap['bla2'] = 'blaaa2'

console.log(wrongMap)  // Map { bla: 'blaa', bla2: 'blaaa2' }

・・・しかし、期待通りには動作しません。

wrongMap.has('bla')    // false
wrongMap.delete('bla') // false
console.log(wrongMap)  // Map { bla: 'blaa', bla2: 'blaaa2' }

そして、正しい使い方との違いはわずかです。

let myMap = new Map()
myMap.set('bla','blaa')
myMap.set('bla2','blaa2')
console.log(myMap)  // Map { 'bla' => 'blaa', 'bla2' => 'blaa2' }

myMap.has('bla')    // true
myMap.delete('bla') // true
console.log(myMap)  // Map { 'bla2' => 'blaa2' }

仕様書

ブラウザーの互換性

関連情報

• Set
• WeakMap
• WeakSet