Set 属性和方法

属性

• Set.prototype.constructor: 构造函数，默认就是 Set 函数

• Set.prototype.size: 返回 Set 实例的成员总数

方法

Set 实例的方法主要分为：操作方法和遍历方法两大类

操作方法

• Set.prototype.add(value)：添加某个值，返回 Set 结构本身

• Set.prototype.delete(value)：删除某个值，返回一个布尔值，表示删除是否成功

• Set.prototype.has(value)：返回一个布尔值，表示该值是否为 Set 的成员

• Set.prototype.clear()：清除所有成员，没有返回值

上面这些属性和方法的实例如下：

s.add(1).add(2).add(2)
// tips: 2 has added for twice

s.size // 2

s.has(1) // true
s.has(2) // true
s.has(3) // false

s.delete(2)
s.has(2) // false

数组去重

Array.from 可以将 Set 结构转为数组

const items = new Set([1, 2, 3, 4, 5])
const array = Array.from(items)

数组去重：

function dedupe(array) {
  return Array.from(new Set(array))
}

dedupe([1, 1, 2, 3]) // [1, 2, 3]

遍历方法

• Set.prototype.keys()：返回键名的遍历器

• Set.prototype.values()：返回键值的遍历器

• Set.prototype.entries()：返回键值对的遍历器

• Set.prototype.forEach()：使用回调函数遍历每个成员

需要特别指出的是，Set 的遍历顺序就是插入顺序。这个特性有时非常有用，比如使用 Set 保存一个回调函数列表，调用时就能保证按照添加顺序调用

keys()，values()，entries()

这三个方法都是遍历器对象。由于 Set 结构没有键名，只有键值（或者说键名和键值都是同一个值），所以 keys 和 values 方法的行为完全一致

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"]

forEach()

Set 结构的实例和数组一样，拥有 forEach 方法，用于对每个成员执行某种操作，没有返回值

let set = new Set([1, 4, 9])
set.forEach((value, key) => console.log(key + ' : ' + value))

遍历的应用

扩展运算符(...)内部使用 for...of 循环，所以也可以用于 Set 结构

let set = new Set(['red', 'green', 'blue'])
let arr = [...set]
// ['red', 'green', 'blue']

扩展符和 Set 结构相结合，就可以去除数组的重复成员

let arr = [3, 5, 2, 2, 5, 5]
let unique = [...new Set(arr)]
// [3, 5, 2]

而且，数组的 map 和 filter 方法也可以间接用于 Set 了

let set = new Set([1, 2, 3])
set = new Set([...set].map(x => x * 2))
// 返回 Set 结构： {2, 4, 6}

let set = new Set([1, 2, 3, 4, 5])
set = new Set([...set].filter(x => (x % 2) == 0))
// 返回 Set 结构： {2, 4}

并集、交集、差集

let a = new Set([1, 2, 3])
let b = new Set([4, 3, 2])

// 并集
let union = new Set([...a, ...b])
// Set {1, 2, 3, 4}

// 交集
let intersect = new Set([...a].filter(x => b.has(x)))
// Set {2, 3}

// 差集
let diif = new Set([...a].filter(x => !b.has(x)))
// Set {1}