唯一容器 Set
ES6 提供了新的数据结构 Set
Set 结构没有键名,只有键值(或者说 键名 和 键值 是同一个值)
它类似于数组,但是成员的值都是唯一的,没有重复的值
Set 内部判断两个值是否不同,使用的算法叫做“Same-value-zero equality”, NaN 等于自身
它类似于精确相等运算符(===),而 精确相等运算符 认为NaN不等于自身
Set 结构的实例默认可遍历,它的默认遍历器生成函数就是它的 values 方法
Set.prototype[Symbol.iterator] === Set.prototype.values // true
// 意味着 : 可以省略values方法,直接用for...of循环遍历 Set
- 数组去重(面试题)
let arr = [9, 3, 1, 5, 7]; let onlyOne = [...new Set(arr)];
const oneArr = Array.from(new Set(arr));// Array.from
方法可以将 Set 结构转为数组Set.prototype.size
返回Set
实例 的成员总数- Set.prototype.操作方法
setObj.add()
添加某个值,返回 Set 结构本身
setObj.delete()
删除某个值,返回一个布尔值,表示删除是否成功
setObj.has()
返回一个布尔值,表示该值是否为 Set
的成员
setObj.clear()
清除所有成员,没有返回值
// 对象的写法 const properties = { 'width': 1, 'height': 1 }; if (properties[someName]) { // do something } // Set的写法 const properties = new Set(); properties.add('width'); properties.add('height'); if (properties.has(someName)) { // do something }
- Set.prototype.遍历方法
setObj.keys()
返回键名的遍历器
setObj.values()
返回键值的遍历器
setObj.entries()
返回键值对的遍历器
setObj.forEach()
使用回调函数遍历每个成员
还可以有第二个参数,表示绑定处理函数内部的 this 对象
let set = new Set(['red', 'green', 'blue']); for (let item of set.keys()) { console.log(item); }; // red // green // blue for (let item of set.values()) { console.log(item); }; // red // green // blue for (let item of set.entries()) { console.log(item); }; // ["red", "red"] // ["green", "green"] // ["blue", "blue"]
Set 可以很容易地实现
并集(Union)
const unionArr = [...new Set([...arrA, ...arrB])]; // 求俩数组 并集
交集(Intersect)
const difArr = [...new Set(arrA.filter(each=>!setB.has(each)))]; // 求俩数组 差集
差集(Difference)
const difArr = [...new Set(arrA.filter(each=>!setB.has(each)))]; // 求俩数组 差集
let setA = new Set(arrA); // arrA 去重 let setB = new Set(arrB); // arrB 去重 const unionArr = [...new Set([...arrA, ...arrB])]; // 求俩数组 并集 const mixedArr = [...new Set(arrA.filter(each=>setB.has(each)))]; // 求俩数组 交集 const difArr = [...new Set(arrA.filter(each=>!setB.has(each)))]; // 求俩数组 差集 console.log(" arrA 去重 : "+[...setA]); console.log("arrB 去重 : "+[...setB]); console.log("------------------"); console.log("arrA 并集 arrB : "+unionArr); console.log("arrA 交集 arrB : "+mixedArr); console.log("arrA 差集 arrB : "+difArr);
var ws = mew WeakSet()
与 Set 类似,也是不重复的值的集合。但是,它与 Set 有两个区别:
- 首先,WeakSet 的成员只能是对象,而不能是其他类型的值
- WeakSet 中的对象都是弱引用,即垃圾回收机制不考虑 WeakSet 对该对象的引用
也就是说,如果其他对象都不再引用该对象,那么垃圾回收机制会自动回收该对象所占用的内存,不考虑该对象还存在于 WeakSet 之中
WeakSet 不能遍历,是因为成员都是弱引用,随时可能消失,遍历机制无法保证成员的存在,很可能刚刚遍历结束,成员就取不到了
- WeakSet.prototype.add(value)
向 WeakSet 实例添加一个新成员
- WeakSet.prototype.delete(value)
清除 WeakSet 实例的指定成员
- WeakSet.prototype.has(value)
返回一个布尔值,表示某个值是否在 WeakSet 实例之中
const elements = new WeakSet(); class Foo { constructor() { elements.add(this) } method () { if (!elements.has(this)) { throw new TypeError('Foo.prototype.method 只能在Foo的实例上调用!'); } } }
Map 对象,属性 key 可以是任意类型
属性 key 也是唯一的,前面的属性 会被 后面的属性 覆盖
背景:
传统上对象只能用字符串当作键
ES6 提供了 Map 数据结构。它类似于对象,也是键值对的集合,但是“键”的范围不限于字符串,
各种类型的值(包括对象)都可以当作键。
也就是说,Object 结构提供了“字符串—值”的对应,Map 结构提供了“值—值”的对应,是一种更完善的 Hash 结构实现。
如果你需要 “键值对” 的数据结构,Map 比 Object 更合适。
var newMap = new Map();
不仅仅是数组,任何具有 Iterator 接口、且每个成员都是 一个双元素的数组的数据结构 都可以当作Map构造函数的参数
Set 和 Map 都可以用来生成新的 Map
只有对同一个对象的引用,Map 结构才将其视为同一个键。这一点要非常小心
const map = new Map(); const k1 = ['a']; const k2 = ['a']; map .set(k1, 111) .set(k2, 222); map.get(k1); // 111 map.get(k2); // 222
newMap.size 属性
返回 Map 结构的成员总数
const map = new Map(); map.set('foo', true); map.set('bar', false); map.size // 2
newMap.set(key, value) 添加 键值对
设置键名 key 对应的键值为 value,然后返回整个 Map 结构,意味着可以链式调用
如果 key 已经有值,则键值会被更新,否则就新生成该键
const m = new Map(); m.set('edition', 6) // 键是字符串 m.set(262, 'standard') // 键是数值 m.set(undefined, 'nah') // 键是 undefined let map = new Map() .set(1, 'a') .set(2, 'b') .set(3, 'c');
newMap.get(key) 获取 键 对应的 值
读取 key 对应的键值
如果找不到 key,返回 undefined
const m = new Map(); const hello = function() {console.log('hello');}; m.set(hello, 'Hello ES6!'); // 键是函数 m.get(hello); // Hello ES6!
newMap.has(key) 查询 Map 实例 是否包含 键
返回一个布尔值,表示某个键是否在当前 Map 对象之中
const m = new Map(); m.set('edition', 6); m.set(262, 'standard'); m.set(undefined, 'nah'); m.has('edition'); // true m.has('years'); // false m.has(262); // true m.has(undefined); // true
newMap.delete(key)
删除 Map 实例的 某个键,返回 true。
如果删除失败,返回 false
newMap.clear()
清除所有成员,没有返回值
四种 遍历方法
- keys() 返回键名的遍历器
- values() 返回键值的遍历器
- entries() 返回所有成员的遍历器
- forEach() 遍历 Map 的所有成员
forEach方法还可以接受第二个参数,用来绑定this
const map = new Map([ ['F', 'no'], ['T', 'yes'], ]); for (let key of map.keys()) { console.log(key); }; // "F" // "T" for (let value of map.values()) { console.log(value); }; // "no" // "yes" for (let item of map.entries()) { console.log(item[0], item[1]); }; // "F" "no" // "T" "yes" // 或者 for (let [key, value] of map.entries()) { ; console.log(key, value); } // "F" "no" // "T" "yes" // 等同于使用map.entries()for (let [key, value] of map) { console.log(key, value); }; // "F" "no" // "T" "yes"
// 表示 Map 结构的默认遍历器接口(Symbol.iterator 属性),就是 entries 方法
map[Symbol.iterator] === map.entries // true- Map 结构转为数组结构,比较快速的方法是使用扩展运算符(...)
const map = new Map([ [1, 'one'], [2, 'two'], [3, 'three'], ]); [...map.keys()] // [1, 2, 3] [...map.values()] // ['one', 'two', 'three'] [...map.entries()] // [[1,'one'], [2, 'two'], [3, 'three']] [...map] // [[1,'one'], [2, 'two'], [3, 'three']]
返回键名的遍历器