Set 和 Map 数据结构

1. Set
2. WeakSet
3. Map
4. WeakMap

1.Set

相似于 数组 ，成员值都是 惟一 的
Set 自身是一个构造函数，用来生成 Set 数据结构

let s = new Set([1])
console.log(s);

• Set 中能够承受具备 iterable 接口的其余数据结构
• 能够用 [...new Set(arr)] 数组去重
• Array.from(new Set(arr))也可

Set 的属性

1. constructor
2. size

let s = new Set([1, 2])
console.dir(s.__proto__.constructor === Set.prototype.constructor);//true
console.log(s.size) //2

• size 示意 成员数量 ，相似于数组的length 属性

Set 的办法

1. 操作方法：add delete has clear
2. 遍历办法：values keys entries forEach

1- 操作方法

• add(value) 增加值，返回Set 自身

  let s = new Set([1, 2])
  let s1 = s.add(3)
  console.log(s, s1);

• detele(value) 删除值，返回 布尔值，确定删除胜利

  let s = new Set([1, 2])
  let s1 = s.delete(1)
  console.log(s, s1);

• has(value)返回 布尔值, 确定是否有某个值，相似数组的 includes

  let s = new Set([1, 2])
  let s1 = s.has(2)
  console.log(s, s1);

• clear() 革除所有成员，无 返回值

  let s = new Set([1, 2])
  let s1 = s.clear()
  console.log(s, s1);

2- 遍历办法

• keys() 返回键名的遍历器

  let s = new Set([1, 2, "a", "b"])
  let s1 = s.keys()
  console.log(s1);
  for (const i of s1) {console.log(i);
  }

• values() 返回键值的遍历器

  let s = new Set([1, 2, "a", "b"])
  let s1 = s.values()
  console.log(s1);
  for (const i of s1) {console.log(i);
  }

  能够看出 keys 与 values 遍历出的值是雷同的

• entries() 返回键值对

  let s = new Set([1, 2, "a", "b"])
  let s1 = s.entries()
  console.log(s1);
  for (const i of s1) {console.log(i);
  }

• forEach() 应用回调函数遍历每个成员，无返回值

  let s = new Set([1, 2, 3, 4])
  s.forEach(x => {console.log(x * 2); //2 4 6 8
  })

2.WeakSet

• WeakSet 的成员只能是 对象，否则会报错

  let s = new WeakSet([1, 2, 3, 4])
  console.log(s);

• WeakSet 中的对象为弱援用
• 不可遍历
• 没有 size 属性

• 办法：add delete has

  let obj = {a: 1}
  let s = new WeakSet([[0], [1]])
  s.add(obj)
  console.log(s);

3.Map

键值对汇合，键能够是 对象，一种更欠缺的 Hash 构造

• Map 构造函数

  const set = new Set([["a", 1], ["b", 2]])
  const map = new Map(set)
  console.log(map);

  Map 能够接管一个具备 Iterator 接口且每个成员都是一个双元素数组的数据结构
  Map 上也有size 属性，示意 成员数量
  Map 的键是与 内存 绑定的，内存不一样则视为两个键，NaN 视为同一个键

Map 的办法

1. 操作方法：set get has delete clear
2. 遍历办法 keys values entries forEach

1- 操作方法

• set(key,value) get(key) 增加成员 获取值 返回 Map

  const map = new Map()
  map.set("a", 1)
  console.log(map);
  console.log(map.get("a"));

• has(key) 返回布尔值，某个键是否在 Map 中

  const map = new Map([["a", 1]])
  let m1 = map.has("a")
  console.log(map, m1);

• delete(key) 删除一个键，返回布尔值

  const map = new Map([["a", 1], ["b", 2]])
  let m1 = map.delete("a")
  console.log(map, m1);

• clear() 清空所有成员，无放回值

  const map = new Map([["a", 1], ["b", 2]])
  let m1 = map.clear()
  console.log(map, m1);

2- 遍历办法

• keys() 返回键名的遍历器
• values() 返回键值的遍历器
• entries() 返回键值对的遍历器
• forEach(callback,thisArg) 遍历 Map 的所有成员

遍历办法与 Set 大致相同，不再举例介绍
要留神的是 for(let [key,value] of map) 等同于应用 map.entries()
同样 entries 遍历器也能够赋值给这样的 两个参数

Map 与其余数据结构的转换

1. 数组
2. 对象
3. JSON

1.Map 与数组的转换

• Map 转数组

• 扩大符 操作

  const map = new Map([["a", 1], ["b", 2]])
  console.log([...map]);//[["a",1],["b",2]]

• 数组转 Map

• 将数组写入 Map 构造函数中即可

  let map = new Map(["a", 0],
    [{"b": true}, 2]
  )
  console.log(map);

2.Map 与对象转换

• Map 转对象

• Map 的所有键都是字符串，能够将其转为对象

  function toObj(map) {let obj = Object.create(null)
    for (let [k, v] of map) {obj[k] = v
    }
    return obj
  }// 遍历 map 将 key value 逐对赋值给一个对象
  let map = new Map([["a", 1],
    ["b", 2]
  ])
  console.log(toObj(map));//{"a":1,"b":2}

• 对象转 Map

• 遍历对象，用 set 的形式为 Map 增加键值对

  function objToMap(obj) {let map = new Map()
    for (let k of Object.keys(obj)) {map.set(k, obj[k])
    }
    return map
  }
  let obj = {a: 1, b: 2}
  console.log(objToMap(obj)); // {"a" => 1 , "b" => 2}

3.Map 与 JSON 的转换

• Map 转对象 JSON

• Map 的键名都是字符串

  function toObj(map) {let obj = Object.create(null)
    for (let [k, v] of map) {obj[k] = v
    }
    return obj
  }
  function toObjJson(map) {return JSON.stringify(toObj(map))
  }
  let map = new Map([["a", 1],
    ["b", 2]
  ])
  console.log(toObjJson(map)); //'{"a":1,"b":2}'

  先把 Map 转为对象，再用 JSON 序列化

• Map 转数组 JSON

• Map 中键名有非字符串

  function toObjJson(map) {return JSON.stringify([...map])
  }
  let map = new Map([[true, 1],
    [false, 0]
  ])
  console.log(toObjJson(map));//'[[true,1],[false,0]]'

  先将 Map 转为数组，再用 JSON 序列化

• 对象 JSON 转 Map

• 键名都为字符串

  function objToMap(obj) {let map = new Map()
    for (let k of Object.keys(obj)) {map.set(k, obj[k])
    }
    return map
  }
  function jsonToStrMap(json) {return objToMap(JSON.parse(json))
  }
  let json = '{"a":1,"b":2}'
  console.log(jsonToStrMap(json));//{"a" => 1 , "b" => 2}

  先将 json 反序列换转为对象，再将对象转为 Map

• 数组 JSON 转为 Map

• JSON 自身是一个数组，每个成员是蕴含两个元素的数组

  function jsonToMap(json) {return new Map(JSON.parse(json))
  }
  let json = '[[true,1],[false,0]]'
  console.log(jsonToMap(json));// {true => 1 , false => 0}

  先将 JSON 反序列化为数组，再将数组转为 Map

4.WeakMap

与 Map 的构造相似，也是一个键值对汇合
区别

• WeakMap 只承受对象作为键名

• 键名所指向的对象不计入垃圾回收机制

  与 WeakSet 相似，对象的援用都是弱援用
  没有 size 属性

操作

• 没有 遍历的操作 即没有 keys values entries forEach 这些办法
• 键名是若援用的，防止出现不确定性，因而对立规定不能取到键名
• 不能清空，没有 clear 办法
• 可用办法 set get has delete

对于 WeakMap，实用于将 DOM 节点作为键名