函数集合

  1. /*
  2.  * @Author: yongyuan at <yongyuan253015@gmail.com>
  3.  * @Date: 2021-08-01 22:59:12
  4.  * @LastEditTime: 2021-08-01 23:39:16
  5.  * @LastEditors: yongyuan at <yongyuan253015@gmail.com>
  6.  * @Description: 函数实现集合
  7.  * @FilePath: \JavaScript\collection\collection-function.js
  8.  * 
  9.  */
  10. function Set() {
  11.     let items = {};
  13.     this.has = function (value) {
  14.         return items.hasOwnProperty(value)
  15.     }
  17.     this.add = function (value) {
  18.         if (!this.has(value)) {
  19.             items[value] = value;
  20.             return true;
  21.         }
  22.         return false;
  23.     }
  25.     this.remove = function (value) {
  26.         if (this.has(value)) {
  27.             delete items[value];
  28.             return true;
  29.         }
  31.         return false
  32.     }
  34.     this.clear = function () {
  35.         items = {}
  36.     }
  38.     this.size = function () {
  39.         return Object.keys(items).length;
  40.     }
  42.     this.values = function () {
  43.         return Object.values(items)
  44.     }
  45.     // 并集
  46.     this.union = function (otherSet) {
  47.         const unionSet = new Set();
  49.         this.values().map((item) => {
  50.             unionSet.add(item)
  51.         })
  53.         otherSet.values().map((item) => {
  54.             unionSet.add(item)
  55.         })
  57.         return unionSet
  58.     }
  59.     // 交集
  60.     this.intersection = function (otherSet) {
  61.         const intersectionSet = new Set();
  62.         const values = this.values();
  63.         const otherValues = otherSet.values();
  65.         let biggerSet = values;
  66.         let smallerSet = otherValues;
  68.         if (otherValues.length - values.length > 0) {
  69.             biggerSet = otherValues;
  70.             smallerSet = values;
  71.         }
  73.         smallerSet.map((item) => {
  74.             if (biggerSet.includes(item)) {
  75.                 intersectionSet.add(item)
  76.             }
  77.         })
  79.         return intersectionSet;
  80.     }
  81.     // 差集
  82.     this.difference = function (otherSet) {
  83.         const differenceSet = new Set();
  84.         this.values().map((item) => {
  85.             if (!otherSet.has(item)) {
  86.                 differenceSet.add(item);
  87.             }
  88.         });
  89.         return differenceSet;
  90.     }
  91.     // 子集
  92.     this.isSubsetOf = function (otherSet) {
  93.         if (this.size() > otherSet.size()) {
  94.             return false;
  95.         }
  97.         let isSubset = this.values().every((value) => otherSet.has(value));
  99.         return isSubset
  100.     }
  101. }
  104. const set = new Set();
  105. set.add(1);
  106. set.add(2);
  107. set.add(31);
  108. set.add(0);
  109. console.log(set.values());
  110. console.log(set.has(3));
  111. console.log(set.size());
  113. const setB = new Set();
  115. setB.add(10);
  116. setB.add(0);
  117. console.log(set.union(setB).values());
  118. console.log(set.intersection(setB).values());
  119. console.log(set.difference(setB).values());
  120. console.log(set.isSubsetOf(setB));

Class集合

  1. /*
  2.  * @Author: yongyuan at <yongyuan253015@gmail.com>
  3.  * @Date: 2021-07-30 23:21:43
  4.  * @LastEditTime: 2021-07-31 18:06:52
  5.  * @LastEditors: yongyuan at <yongyuan253015@gmail.com>
  6.  * @Description: 集合的类声明
  7.  * @FilePath: \JavaScript\collection\collection-class.js
  8.  * 
  9.  */
  10. class Set {
  11.     constructor() {
  12.         this.items = {}; // 用对象来表示集合
  13.     }
  15.     has(element) {
  16.         // Object原型有hasOwnProperty方法，它返回一个表明对象是否具有特定属性的布尔值
  17.         //  in 运算符返回的是对象在原型链上是否具有特定属性的布尔值
  18.         return Object.prototype.hasOwnProperty.call(this.items, element)
  19.     }
  20.     // 往集合添加成员
  21.     add(element) {
  22.         if (!this.has(element)) {
  23.             this.items[element] = element;
  24.             return true;
  25.         }
  26.         return false;
  27.     }
  28.     //  删除集合成员
  29.     delete(element) {
  30.         if (this.has(element)) {
  31.             delete this.items[element];
  32.             return true;
  33.         }
  34.         return false;
  35.     }
  37.     // 清空集合成员
  39.     clear() {
  40.         return this.items = {}
  41.     }
  42.     // 返回集合大小
  43.     size() {
  44.         return Object.keys(this.items).length;
  45.     }
  46.     // 返回的集合成员的值
  47.     values() {
  48.         return Object.values(this.items)
  49.     }
  50.     // 集合运算：并集、交集、差集和子集
  51.     union(otherSet) {
  52.         const unionSet = new Set();
  53.         this.values().forEach(value => {
  54.             unionSet.add(value);
  55.         });
  57.         otherSet.values().forEach((value) => {
  58.             unionSet.add(value);
  59.         })
  60.         return unionSet
  61.     }
  63.     // 交集
  64.     intersection(otherSet) {
  65.         const intersectionSet = new Set();
  66.         const values = this.values();
  67.         const otherValues = otherSet.values();
  69.         let biggerSet = values;
  70.         let smallerSet = otherValues;
  72.         if (otherValues.length - values.length > 0) {
  73.             biggerSet = otherValues;
  74.             smallerSet = values;
  75.         }
  77.         smallerSet.forEach((value) => {
  78.             if (biggerSet.includes(value)) {
  79.                 intersectionSet.add(value)
  80.             }
  81.         })
  82.         return intersectionSet;
  83.     }
  85.     // 差集
  86.     difference(otherSet) {
  87.         const differenceSet = new Set();
  88.         this.values().forEach(value => {
  89.             if (!otherSet.has(value)) {
  90.                 differenceSet.add(value);
  91.             }
  92.         });
  94.         return differenceSet;
  95.     }
  97.     // 子集
  98.     isSubsetOf(otherSet) {
  99.         if (this.size() > otherSet.size()) {
  100.             return false
  101.         }
  103.         let isSubset = this.values().every(value => otherSet.has(value));
  105.         return isSubset
  106.     }
  108. }
  111. const set = new Set();
  114. set.add(1)
  115. console.log(set.values()); // [1]
  116. console.log(set.has(2));// false
  118. const setA = new Set();
  119. const setB = new Set();
  121. setA.add(1)
  122. setA.add(2)
  123. setB.add(1)
  124. setB.add(3)
  125. setB.add(2)
  127. const unionAB = setA.union(setB)
  128. console.log(setA)
  129. console.log(setB)
  130. console.log("并集", unionAB)
  132. const intersectionAB = setA.intersection(setB)
  133. console.log("交集", intersectionAB)
  135. const differenceAB = setB.difference(setA);
  136. console.log("差集", differenceAB)
  138. console.log("集合A是集合B的子集", setA.isSubsetOf(setB))
  141. console.log(new  Set([{a:1,a:1,a:2,b:3}]))

ES6集合

  1. /*
  2.  * @Author: yongyuan at <yongyuan253015@gmail.com>
  3.  * @Date: 2021-08-01 23:59:34
  4.  * @LastEditTime: 2021-08-02 23:35:42
  5.  * @LastEditors: yongyuan at <yongyuan253015@gmail.com>
  6.  * @Description: ES6的set结构实现集合
  7.  * @FilePath: \JavaScript\collection\collection-ES6.js
  8.  *  
  9.  * 数据结构set，类似数组，其成员值是唯一的，没有重复值。Set本身是一个构造函数。
  10.  * 
  11.  * add()
  12.  * 
  13.  * size
  14.  * 
  15.  * has()
  16.  * 
  17.  * delete()
  18.  * 
  19.  * clear()
  20.  * 
  21.  * 可以给数组去重，也可以给对象去重，去重相同属性。
  22.  */
  24. const _set = new Set();
  25. _set.add({ name1: "duxin1", name2: "duxin2", name: "duxin3" })
  26. console.log(_set)
  27. console.log(_set.size)
  29. const _setB = new Set([1, 2, 3, 4, 3]);
  31. console.log("A集合", _set)
  32. console.log("B集合", _setB);
  34. //并集
  35. let union = new Set([..._set, ..._setB]);
  36. console.log("并集", union)
  38. // 交集
  39. let intersect = new Set([..._set].filter(value => _setB.has(value)))
  40. console.log("交集", intersect)
  42. // 差集
  43. const difference = new Set([..._set].filter(value => !_setB.has(value)));
  45. console.log("差集", difference)