关于javascript:jsSet和Map数据结构

Set
WeakSet
Map
WeakMap

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

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

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

constructor
size

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

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

操作方法：add delete has clear
遍历办法：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
})

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);

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

Map 构造函数
```
const set = new Set([["a", 1], ["b", 2]])
const map = new Map(set)
console.log(map);
```
Map 能够接管一个具备 Iterator 接口且每个成员都是一个双元素数组的数据结构
Map 上也有size 属性，示意 成员数量
Map 的键是与 内存 绑定的，内存不一样则视为两个键，NaN 视为同一个键

操作方法：set get has delete clear
遍历办法 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 遍历器也能够赋值给这样的 两个参数

数组
对象
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

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

WeakMap 只承受对象作为键名
键名所指向的对象不计入垃圾回收机制

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

操作

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

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

Set 和 Map 数据结构

1.Set

Set 的属性

Set 的办法

2.WeakSet

3.Map

Map 的办法

Map 与其余数据结构的转换

4.WeakMap