- 是一种叫做集合的数据结构(ES6新增的)
- 类似于数组,可以说是伪数组了(因此可以用Array.from转成数组,或者ES6的...扩展运算符)
const items = new Set([1, 2, 3, 1])
const array = Array.from(items)
console.log(array)
const arr = [...items]
console.log(arr)
- 本身是一个构造函数,用来生成Set数据结构
new Set([iterable])
- 成员唯一、无序且不重复
const s = new Set([1,2,3,5,4,3,2,1])
- [value, value]，键值与键名是一致的（或者说 只有键值，没有键名）
- 允许储存任何类型的唯一值，无论是原始值或者是对象引用
new Set({a:"123",b:"1234"})
const s = new Set();
s.add({a:"123",b:"1234"})
- 可以遍历 用for of
const s = new Set([1,2,3,5,4,3,2,1])
for (let i of s) {
console.log(i)
}
- 向Set add值的时候，不会发生类型转换
let s = new Set()
s.add(1)
s.add('1')
console.log([...s])
- Set 实例属性有:
- constructor： 构造函数
- size：元素数量
let set = new Set([1,2,3,5,4,3,2,1])
console.log(set.size)
console.log(set.length)
- 操作方法有：add、delete、has、clear
- add(value)：新增，相当于 array里的push
- delete(value)：存在即删除集合中value
- has(value)：判断集合中是否存在 value
- clear()：清空集合
let set = new Set()
set.add(1).add(2).add(3)
set.has(1)
set.has(4)
set.delete(1)
set.has(1)
- 遍历方法有:keys values entries forEach（遍历顺序为插入顺序）
- keys()：返回一个包含集合中所有键的迭代器
- values()：返回一个包含集合中所有值得迭代器(其实keys()跟values()是一样的因为键值与键名是一致的)
如图:
- entries()：返回一个包含Set对象中所有元素得键值对迭代器
其实就是键跟值一样的结构如下截图
4.forEach(callbackFn, thisArg)：用于对集合成员执行callbackFn操作，如果提供了 thisArg 参数，回调中的this会是这个参数，没有返回值
- Set 可默认遍历，默认迭代器生成函数是 values() 方法
Set.prototype[Symbol.iterator] === Set.prototype.values
- Set可以使用 map、filter 方法
- Set 可以很方便的实现交集（Intersect）、并集（Union）
let set1 = new Set([1, 2, 3, 5])
let set2 = new Set([4, 3, 2, 1])
let intersect = new Set([...set1].filter(value => set2.has(value)))
let union = new Set([...set1, ...set2])
console.log(intersect)
console.log(union)
- 是一种叫做字典的数据结构
- 本质上是键值对的集合，类似集合
- 可以遍历，方法很多可以跟各种数据格式转换
- Map 实例属性有:
- constructor：构造函数
- size：返回字典中所包含的元素个数
const map = new Map([
['name', 'long'],
['age', 12]
]);
map.size
map.length
- Map的操作方法有:set,get,has,delete,clear
- set(key, value)：向字典中添加新元素
- get(key)：通过键查找特定的数值并返回
- has(key)：判断字典中是否存在键key
- delete(key)：通过键 key 从字典中移除对应的数据
- clear()：将这个字典中的所有元素删除
const m = new Map()
const o = {name: 'long'}
m.set(o, 'liangliang')
m.get(o)
m.has(o)
m.delete(o)
m.has(o)
- 遍历方法有:Keys,values,entries,forEach
- Keys()：将字典中包含的所有键名以迭代器形式返回
- values()：将字典中包含的所有数值以迭代器形式返回
- entries()：返回所有成员的迭代器
- forEach(callbackFn,thisArg)：遍历字典的所有成员,对集合成员执行callbackFn操作，如果提供了thisArg参数，回调中的this会是这个参数，没有返回值
const map = new Map([
['name', 'long'],
['age', 16]
]);
console.log(map.entries())
console.log(map.keys())
console.log(qmap.values())
const reporter = {
report: function(key, value) {
console.log("Key: %s, Value: %s", key, value);
}
};
let map = new Map([
['name', 'long'],
['age', 16]
])
map.forEach(function(value, key, map) {
this.report(key, value);
}, reporter);
- Map 默认遍历器接口（Symbol.iterator属性），是entries方法
const map = new Map()
map[Symbol.iterator] === map.entries
Map.prototype[Symbol.iterator] === Map.prototype.entries
- 集合 与 字典 的区别：
- 共同点：集合,字典 都可以储存不重复的值
- 不同点：集合 是以 [value, value]的形式储存元素，字典 是以 [key, value] 的形式储存
- 注意事项
- Map与其他数据结构的相互转换如下:
- Map 转 Array
const map = new Map([[1, 1], [2, 2], [3, 3]])
console.log([...map])
- Array 转 Map
const map = new Map([[1, 1], [2, 2], [3, 3]])
console.log(map)
- Map 转 Object
- 因为Object的键名都为字符串,而Map的键名为对象,所以转换的时候会把非字符串键名转换为字符串键名.
function mapToObj(map) {
let obj = Object.create(null)
for (let [key, value] of map) {
obj[key] = value
}
return obj
}
const map = new Map().set('name', 'long').set('age', 16)
mapToObj(map)
- Object 转 Map
function objToMap(obj) {
let map = new Map()
for (let key of Object.keys(obj)) {
map.set(key, obj[key])
}
return map
}
objToMap({'name': 'long', 'age': 16})
- Map 转 JSON
function mapToJson(map) {
return JSON.stringify([...map])
}
let map = new Map().set('name', 'LONG').set('age', 16)
mapToJson(map)
- JSON 转 Map
function objToMap(obj) {
let map = new Map()
for (let key of Object.keys(obj)) {
map.set(key, obj[key])
}
return map
}
function jsonToStrMap(jsonStr) {
return objToMap(JSON.parse(jsonStr));
}
jsonToStrMap('{"name": "long", "age": 16}')
