Set

Set和WeakSet

Set

基本用法

ES6提供的一种新数据结构。类似于数组，但成员的值都是唯一的，没有重复的值
Set本身是一个构造函数，用来生成Set数据结构

      const s = new Set()
      ;[2, 3, 4, 5, 2, 2].forEach(element => {
        s.add(element)
      })
      for (let i of s) {
        console.log(i)
      }
      console.log(s)

上面代码表明了Set结构不会添加重复的值

Set函数还可以接受一个数组（或者具有iterable接口的其他数据结构）作为参数，用来初始化。
set可以用来去除数组重复成员和字符串里面的重复字符

      const set = new Set([1, 2, 3, 4, 4])
      console.log(set)

      console.log([...new Set('ababbc')].join(''))

向Set加入值的时候，不会发生类型转换，数字和字符串类型的数字是两个不同的值。
Set内部判断两个值是否相同，使用的算法为“same-value-zero equality”，类似于精确相等运算符（===），主要区别为：此算法认为NaN 等于自身，而精确运算符认为NaN不等于自身 ,并且两个对象总是不相等，即便是两个空对象

 let set = new Set()
      let a = NaN
      let b = NaN
      set.add(a)
      set.add(b)
      console.log(set)
      
      let set2 = new Set()
      set2.add({})
      console.log(set2.size)
      set2.add({})
      console.log(set2.size)
      console.log(set2)

Set实例的属性和方法

属性：

• Set.prototype.constructor：构造函数，默认为Set函数
• Set.prototype.size：返回Set实例的成员总数

方法：

• 操作方法
  • Set.prototype.add(value):添加某个值，返回Set结构本身
  • Set.prototype.delete(value):删除某个值，返回一个布尔值，表示删除是否成功
  • Set.prototype.has(value):返回一个布尔值，表示该值是否为Set的成员
  • Set.prototype.clear():清除所有成员，没有返回值
• 遍历方法
  • Set.prototype.keys():返回键名的遍历器
  • Set.prototype.values():返回键值的遍历器
  • Set.prototype.entries():返回键值对的遍历器
  • Set.protptype.forEach():使用回调函数遍历每个成员
    Set的遍历顺序就是插入顺序。

由于Set结构没有键名，只有键值（或者键值与键名是同一个值），所以keys方法和values方法的行为完全一致。

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

      for (let item of set.keys()) {
        console.log(item)
      }
      for (let item of set.values()) {
        console.log(item)
      }
      for (let item of set.entries()) {
        console.log(item)
      }

Set结构的实例默认可遍历，它的默认遍历器生成函数就是它的values方法。
意味着可以省略values方法，直接用for…of循环遍历Set

forEach()方法的参数就是一个处理函数，该函数的参数与数组的forEach一致，依次为键值。键名。集合本身。

遍历的应用

      /* 去除数组重复的成员 */
      let arr = [3, 5, 2, 2, 5, 5]
      let unique = [...new Set(arr)]
      console.log(unique)

      /* 数组的map和filter方法可以间接用于Set结构 */
      let set = new Set([1, 2, 3])
      set = new Set([...set].map(x => x * 2))
      console.log(set)

      let set2 = new Set([1, 2, 3, 4, 5])
      set2 = new Set([...set2].filter(x => x % 2 == 0))
      console.log(set2)

      /* 使用Set可以很容易地实现并集（Union)、交集（Intersect）和差集（Difference） */
      let a = new Set([1, 2, 3])
      let b = new Set([4, 3, 2])
      let union = new Set([...a, ...b])
      let intersect = new Set([...a].filter(x => b.has(x)))
      let difference = new Set([...a].filter(x => !b.has(x)))

      console.log('交集:', union, '并集:', intersect, '差集：', difference)

      /* 改变原来的Set结构 */
      //方法一
      let set3 = new Set([1, 2, 3])
      set3 = new Set([...set3].map(val => val * 2))
      //方法二
      let set4 = new Set([1, 2, 3])
      set4 = new Set(Array.from(set4, val => val * 2))

      console.log(set3, set4)

WeakSet

含义

WeakSet结构与Set类似，也是不重复的值的集合，但是与Set有两个区别：

1. WeakSet的成员只能是对象，不能是其他类型的值
2. WeakSet中的对象都是弱引用，即垃圾回收机制不考虑WeakSet对该对象的引用——如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于WeakSet之中。所以WeakSet内部有多少个成员，取决于垃圾回收机制有没有运行，运行前后很有可能成员个数不同。因此ES6规定WeakSet不可遍历

语法

作为构造函数，WeakSet可以接受一个数组或者类似数组的对象作为参数（实际上，任何具有Iterable接口的对象，都可以作为WeakSet的参数）。该组的所有成员都会自动成为WeakSet实例对象的成员。

      const a = [[1, 2], [3, 4]]
      const ws = new WeakSet(a)
      console.log(ws)

      const b = [3, 4]
      const ws2 = new WeakSet(b)
      console.log(ws2)

这里是a数组的成员成为WeakSet的成员，而不是a数组本身，这意味着，数组的成员必须是对象，不然会报错

方法

• WeakSet.prototype.add(value):向WeakSet实例添加一个新成员
• WeakSet.prototype.delete(value):清除WeakSet实例的指定成员
• WeakSet.prototype.has(value)：返回一个布尔值，表示；某个值是否在WeakSet实例之中。

WeakSet没有size属性，没有办法遍历它的成员(size和forEach)

用途

1. 存储DOM节点，不用担心这些节点从文档移除时，会引发内存泄漏。
2. 下面的代码保证了Foo的实例方法，只能在Foo的实例上调用，这里使用WeakSet的好处：Foo对实例的引用，不会被计入内存回收机制，所以删除实例的时候，不用考虑foos，也不会出现内存泄漏

   const foos = new WeakSet()
      class Foo {
        constructor(){
          foos.add(this)
        }
        method(){
          if(!foo.has(this)){
            throw new TypeError('Foo.prototype.method 只能在Foo实例上调用')
          }
        }
      }