1. 集合是保存不重复数据的无序数据集
   1. 数据不重复
   2. 无序

采用对象的形式封装set

/**
 * 集合：没有重复数据的无序数据集
 *
 * 1.add(element) 向集合中添加元素
 * 2.delete(element) 向集合中删除元素
 * 3.has(element) 判断是否包含某元素
 * 4.clear 清空集合
 * 5.size 集合元素数量
 * 6.values 返回一个包含集合中所有元素的数组
 */
class Set {
  constructor() {
    // 用对象存储数据
    this.items = {};
  }
  has(element) {
    // return element in this.items
    return Object.prototype.hasOwnProperty.call(this.items, element);
  }
  add(element) {
    if (this.has(element)) {
      return false;
    } else {
      this.items[element] = element;
      return true;
    }
  }
  delete(element) {
    if (this.has(element)) {
      return false;
    } else {
      delete this.items[element];
      return true;
    }
  }
  clear() {
    this.items = {};
  }
  size() {
    return Object.keys(this.items).length;
  }
  values() {
    //     const arr = [];
    //     for (let key in this.items) {
    //       arr.push(this.items[key]);
    //     }
    //     return arr;
    //   使用Object.values方法  -- 返回value值组成的数组
    return Object.values(this.items);
  }
}

集合运算

并集

1. 对于给定的两个集合，返回一个包含两个几个中所有元素的集合

union(otherSet) {
    const newSet = new Set();
    //   1.遍历当前集合，插入到新的集合中
    this.values().forEach((item) => newSet.add(item));
    //   2.遍历参数集合，插入到新的集合
    otherSet.values().forEach((item) => newSet.add(item));
    return newSet;
  }

交集

1. 对于给定的两个集合，返回一个包含两个集合共有元素的新集合

代码优化：通过判断哪个集合元素更少，遍历较少元素的集合

intersection(otherSet) {
    const newSet = new Set();
    // 通过function - has判断是否两个几个都包含该元素
    this.values().forEach((item) => {
      if (otherSet.has(item)) {
        newSet.add(item);
      }
    });
    return newSet;
  }
  intersection(otherSet) {
    let newSet = new Set();
    let diffSet1 =
      this.values().length > otherSet.values().length ? otherSet : this;
    let diffSet2 =
      this.values().length < otherSet.values().length ? otherSet : this;
    diffSet1.values().forEach((item) => {
      if (diffSet2.has(item)) {
        newSet.add(item);
      }
    });
    return newSet;
  }

差集

1. 对于给定的两个集合，返回一个A集合有但是B集合没有的集合 - 交集的判断反过来即可

diff(otherSet) {
    const newSet = new Set();
    this.values().forEach((item) => {
      // A有B无
      if (!otherSet.has(item)) {
        newSet.add(item);
      }
    });
    return newSet;
  }

子集

判断一个集合是否为该集合的子集

sub(subSet) {
    if (subSet.values().length > this.values().length) {
      return false;
    }
    // 参数集合中的每个元素都能在父集合中找到
    let right = true;
    subSet.values().forEach((item) => {
      if (!this.has(item)) {
        right = false;
      }
    });
    return right;
  }

原生set方法

1. 与封装不同的是，打印set 结果是一对花括号包裹一个字符序列
2. function
   1. add：添加元素
   2. delete：删除元素
   3. size：集合元素数量
   4. clear：清空集合
   5. has：判断是否包含该元素
   6. values：返回迭代器
3. 原生set可以直接使用数组的遍历方法forEach
4. new Set接收数组作为参数

扩展运算符+set：去除数组重复元素

1. set需要传入数组作为参数

let arr = [1, 2, 3, 3, 3, 4, 5, 2, 1, 3, 4];
      arr = [...new Set(arr)];
      console.log(arr);
      console.log(...arr);
      console.log([...arr]);