ES6之map

語法

new Map([iterable])

• 參數:能夠是數組或者其餘的可迭代對象.null會被看成undefined

• Map同Set相似,NaN是相同的,對象和數組是不一樣的.

  //對象
  
  var data = {};
  
  var o = {a:1};
  
  data[o] = 222;
  
  console.log(data); // {[object Object]: 1}

  上例中,由於對象的key爲字符串,當爲對象的時候,自動轉換成字符串"[object Object]"

  let myMap = new Map([
  
  ['age',24],
  
  ['name','xixixi']
  
  ])
  
  myMap // {"age" => 24, "name" => "xixixi"}
  
  myMap.size // 2

Object 和 Map 比較

• 對象的鍵只能爲字符串,可是Map的鍵能夠是任意值

• 能夠經過map.size來獲取Map的個數,而Object必需要遍從來手動獲取

Map.prototype.set() && Map.prototype.get()

set() 方法爲Map對象添加一個指定鍵（key）和值（value）的新元素。返回Map對象.

若已經存在鍵,則更新鍵值,不然,從新創建新鍵

myMap.set(key, value);

get() 方法用來獲取一個 Map 對象中指定的元素。

myMap.get(key);

• 參數:必填

• 返回值爲Map對象

  let obj = {a:1};
  
  let arr = [1]
  
  let arr2 = [1]

  在Map中,只有引用同一個對象,才視爲是同一個鍵;

  let map = new Map()
  
      .set(obj,'xixi')  // 可用鏈式
  
  map.get(obj) // 'xixi'
  
  map.get({a:1}) //undefined  obj和{a:1}內存地址不同,因此找不到{a:1}

  arr和arr2雖然看似相同,可是指向的指針並不一樣,因此Map中也是區分他們不爲同一個鍵

  map.set(arr,1111)
  
      .set(arr2,2222)
  
  get(arr)  //1111
  
  map.get(arr2) //2222

  如果同一個鍵被賦值了屢次,後面的會覆蓋以前的值

  map.set(arr,'從新賦值');
  
  map.get(arr) // '從新賦值'

  Map對象將 0 -0 +0視爲同一個值

  map.set(-0,'0相等');
  
  map.get(0); // 0相等
  
  map.get(+0); // 0相等

  Map視NaN相等

  map.set(NaN,'相等');
  
  map.get(Number('xixixi')) // '相等'

  布爾值true和'true'是兩個不一樣的鍵,undefined和null也是兩個不一樣的鍵

  map.set(true,111)
  
  map.set('true',222)
  
  map.set(undefined,333)
  
  map.set(null,444)
  
  map.get(undefined) // 333
  
  map.get(true) //111

Map.prototype.has()

返回一個bool值，用來代表map 中是否存在指定元素.

myMap.has(key);

• 參數:必需

• 返回值:布爾值,若存在於Map中,則返回true

  //接以上案例
  
  map.has(arr) //true
  
  map.has([1]) //false

Map.prototype.delete()

移除 Map 對象中指定的元素。

myMap.delete(key);

• 參數: 必需

• 返回值:布爾值,若爲true,則刪除成功

  map.delete(arr) //true
  
  map.has(arr)  //false
  
  map.delete([1]) //false

Map.prototype.clear()

清除全部成員,沒有返回值

map.clear()

map.size // 0

Map.prototype.keys()

返回鍵名的遍歷器

myMap.keys()

• 例子

  var map = new Map()
  
      .set('aa',11)
  
      .set('bb',22)
  
  for(let key of map.keys()){
  
      console.log(key)
  
  }
  
  //aa
  
  //bb

Map.prototype.values()

返回鍵值的遍歷器

myMap.values()

• 例子

  for(let value of map.values()){
  
      console.log(value)
  
  }
  
  //11
  
  //22

Map.prototype.entries()

返回全部成員的遍歷器

myMap.entries()

• 例子

  for(let item of map.entries()){
  
      console.log(item)
  
   }
  
   // ['aa',11]
  
   // ['bb',22]
  
  
  
   for(let [key,value] of map.entries()){
  
   console.log(key,value)
  
   }
  
   // aa 11
  
   // bb 22
  
  
  
   for (let [key,value] of map){
  
   console.log(key,value)
  
   }
  
   //等同於map.entries();結果和上一個相同

Map.prototype.forEach()

myMap.forEach(callback[, thisArg])

• callback: 和Set相似,有三個參數,第一個爲鍵值,第二個爲鍵名,第三個爲Map,

• thisArg:this,可選

  var map = new Map()
  
      .set('aa',11)
  
      .set('bb',22)
  
  map.forEach(function (value,key,mymap){
  
  console.log(value,key,mymap)
  
  })
  
  // 11 "aa"  {"aa" => 11, "bb" => 22}
  
  // 22 "bb"  {"aa" => 11, "bb" => 22}

Map 和 數組

• map轉數組

  var map = new Map()
  
      .set('aa',11)
  
      .set('bb',22)
  
      .set('cc',33)
  
  
  
      [...map] // [ ['aa',11],['bb',22],['cc',33] ]
  
      [...map.keys()] //  ["aa", "bb", "cc"]
  
      [...map.values()] // [11, 22, 33]
  
      [...map.entries()] //  [ ['aa',11],['bb',22],['cc',33] ]

• 數組轉map

  let myMap = new Map([
  
  ['age',24],
  
  ['name','xixixi']
  
  ])

Map 和 對象

• map轉對象(map中全部的鍵是字符串,能夠轉對象)

  function mapToObj(myMap){
  
      let obj = Object.create(null);
  
      for(let [key,val] of myMap){
  
          obj[k] = v
  
      }
  
      return obj;
  
  }

• 對象轉Map

  function objToMap(obj){
  
          let map = new Map();
  
          for(let k in obj){
  
              map.set(k,obj[k])
  
          }
  
          return map;
  
      }

WeakMap

相似Map,可是鍵必須是對象(null除外)，值能夠是任意值;

• es5作法

  let obj1 = {a:1,b:2};
  
  let obj2 = {a2:1,b2:2};
  
  let arr = [
  
      [obj1,'xixi'],
  
      [obj2,'haha']
  
  ]

  arr中引用了兩個對象,若是不須要這兩個對象的時候,咱們就要手動刪除arr中的引用,不然垃圾回收機制不會釋放obj1,obj2中的內存

  arr[0] = null;
  
  arr[1] = null;

• es5作法很麻煩,WeakMap解決了這個問題.他的鍵名對象都是弱引用,即垃圾回收機制不將其考慮在內.只要被引用的對象都被清除,垃圾回收機制就會釋放改對象所佔的內存;一旦再也不須要,WeakMap裏面的鍵值對象和所對應的鍵值就會消失,不須要再手動刪除引用.

• 正是由於是弱引用,因此內部的key不可枚舉.

• 有助於防止內存泄漏.

• WeakMap弱引用的只有鍵名,鍵值是正常引用

  let wm = new WeakMap();
  
  let key = {};
  
  let obj = {aa: 1};
  
  
  
  wm.set(key, obj);
  
  obj = null;
  
  wm.get(key) // {aa:1}

  由於鍵值的引用是正常引用,即便外部已經消除了obj的引用,可是內部鍵值的引用依然存在.

• 只有set() ;get() ;has(); delete() 四種方法,無size屬性