集合

集合（不重复）的项组成。集合和没有重复项的组成的，用花括号{}包裹；还有一种概念叫空集，空集就是不包括任何元素的集合。

集合封装

  1. class Set {
  2.     constructor() {
  3.         this.items = {};
  4.     }
  5.     has(element) {
  6.         return element in this.items;
  7.         return Object.prototype.hasOwnProperty.call(this.items, element);
  8.     }
  9.     add(element) {
  10.         if (!this.has(element)) {
  11.             this.items[element] = element;
  12.             return true;
  13.         }
  14.         return false;
  15.     }
  16.     delete(element) {
  17.         if (!this.has(element)) {
  18.             delete this.items[element]
  19.             return true;
  20.         }
  21.         return false;
  22.     }
  23.     clear() {
  24.         this.items = {};
  25.     }
  26.     size() {
  27.         return Object.keys(this.items).length;
  28.     }
  29.     values() {
  30.         return Object.values(this.items);
  31.     }
  33.     // 交集：返回两个集合中共用元素的新集合
  34.     // 差集：返回存在第一个集合并且不存在第二个集合中的新集合
  35.     // 子集：验证一个集合是否是另一个集合的子集
  36. }

集合间操作

  • 并集：对于给定的两个集合，返回一个包含两个集合中 所有元素 的新集合
  • 交集：对于给定的两个集合，返回一个包含两个集合中 共有元素 的新集合
  • 差集：对于给定的两个集合，返回一个包含所有存在于第一个集合且不存在于第二个集合的新集合
  • 子集：验证一个给定的集合是否是另一个集合的子集，验证一个集合里面所有元素是否都存在于另一个集合中，有一个不是就返回false

image.png

并集

并集：返回两个集合中所有元素的新集合

  1.     union(otherSet) {
  2.         const set = new Set();
  3.         //  自己的集合
  4.         this.values().forEach(value => set.add(value));
  5.         // 传入的集合
  6.         otherSet.values().forEach(value => set.add(value));
  7.         return set.values();
  8.     }
  10.     const set1 = new Set();
  11.     const set2 = new Set();
  12.     set1.add('a');
  13.     set1.add('b');
  15.     set2.add('b');
  16.     set2.add('c');
  17.     const newSet = set1.union(set2);
  18.     console.log(newSet);    //    (3) ["a", "b", "c"]

交集

交集：返回两个集合中共用元素的新集合

  1.     intersection(otherSet){
  2.         const intersectionSet = new Set();
  3.         const values = this.values();
  4.         for (let i = 0; i < values.length; i++) {
  5.             // 传入的集合中有自己集合中这个项的话在插入数据
  6.             if(otherSet.has(values[i])){
  7.                 intersectionSet.add(values[i])
  8.             }
  10.         }
  11.         return intersectionSet;
  12.     }
  14.     const intersection =set1.intersection(set2);
  15.     console.log(intersection.values());    //    ['b']

差集

差集：返回存在第一个集合并且不存在第二个集合中的新集合

  1. //    差集和交集其实一样，唯一不同就是取反就能得到差集
  2. difference(otherSet){
  3.   const differenceSet = new Set();
  4.   this.values().forEach(element => {
  5.     if(!otherSet.has(element)){
  6.       differenceSet.add(element)
  7.     }
  8.   })
  9.   return differenceSet
  10. }
  11. const difference = set1.difference(set2);
  12. console.log(difference.values()); // ['a']

子集

子集：验证一个集合是否是另一个集合的子集
验证一个集合里面所有元素 是否都存在另一个集合中（有一个不是就返回 false）

  2. isSubsetOf(otherSet){
  3.   //  自己元素需要 大于 传入长度；
  4.   if(this.size() > otherSet.size()){
  5.     return false;
  6.   }
  7.   let isSbuset = true;    //  假设当前实例是给定集合的子集；
  8.   this.values().every(value => {
  9.     if(!otherSet.has(value)){
  10.       isSbuset = false;
  11.       return false;
  12.     }
  13.     return true;
  14.   })
  15.   return isSbuset;
  16. }
  18. const set1 = new Set();
  19. const set2 = new Set();
  20. set1.add('a');
  21. set1.add('b');
  23. set2.add('b');
  24. //    验证set2里面所有元素是否都存在set1中
  25. const isSubsetOf = set2.isSubsetOf(set1);
  26. console.log(isSubsetOf);    //    true

原生Set模拟

  2.     const set1 = new Set();
  3.     const set2 = new Set();
  4.     set1.add(1)
  5.     set1.add(2)
  6.     set1.add(3)
  8.     set2.add(2)
  9.     set2.add(3)
  10.     set2.add(4)
  11.     //  并集
  12.     const union = (set1,set2) => {
  13.         const newSet = new Set();
  14.         set1.forEach(element => {
  15.             newSet.add(element)
  16.         });
  17.         set2.forEach(element =>{
  18.             newSet.add(element)
  19.         })
  20.         return  newSet;
  21.     }
  22.     const unionResult = union(set1,set2);
  23.     console.log(unionResult);   //  Set(4) {1, 2, 3, 4}
  25.     // 交集
  26.     const intersection = (set1,set2)=>{
  27.         const newSet = new Set();
  28.         set1.forEach(element => {
  29.             if(set2.has(element)){
  30.                 newSet.add(element)
  31.             }
  32.         })
  33.         return newSet;
  34.     }
  35.     const inter = intersection(set1,set2)
  36.     console.log(inter);
  38.     //  差集
  39.     const difference =  (set1,set2)=>{
  40.         const newSet = new Set();
  41.         set1.forEach(element => {
  42.             if(!set2.has(element)){
  43.                 newSet.add(element)
  44.             }
  45.         })
  46.         return newSet;
  47.     }
  48.     const diff = difference(set1,set2)
  49.     console.log(diff);

es6模拟

  1. //  并集
  2. console.log(new Set([...set1,...set2]));
  3. //  交集
  4. console.log(new Set([...set1].filter(element => set2.has(element))));
  5. //  差集
  6. console.log(new Set([...set1].filter(element => !set2.has(element))));