五、集合

1、名词解释：

　　集合是由一组无序且唯一（即不能重复）的项组成的。

2、功能实现：

1. 整体的框架：

   function Set() {
       let items = {}
   }

2. add(value)：向集合添加一个新的项。

    this.add = function (value) {
           if(!this.has(value)){
               items[value]=value;
               return true;
           }
           return false;
       }

    

3. remove(value)：从集合移除一个值。

   this.remove = function (value) {
           if(!this.has(value)){
               delete items[value]
               return true;
           }
           return false;
       }

    

4. has(value)：判断集合是否存在值，在返回true，否则返回false。

   this.has = function (value) {
           // return value in items;
           return items.hasOwnProperty(value)
       }

    

5. clear()：移除集合中的所有项。

   this.clear = function () {
           items = {}
       }

    

6. size()、sizeLegacy()：返回集合所包含元素的数量。

   this.size = function () {
           return Object.keys(items).length;
       }
   this.sizeLegacy = function () {
           let count = 0
           for (const key in items) {
               if (object.hasOwnProperty(key)) {
                   ++count
               }
           }
           return count
       }

    

7. values()：返回集合所有的值。

   this.values = function () {
           let values = []
           for (let i = 0, keys=Object.keys(items); i < keys.length; i++) {
               values.push(items[keys[i]])
           }
           return values
       }

    

3、集合操作

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

   this.union = function (otherSet) {  
           let unionSet  = new Set();
           let values = this.values()
           for (let i = 0; i < values.length; i++) {
               unionSet.add(values[i])
           }
           values = otherSet.values()
           for (let i = 0; i < array.length; i++) {
               unionSet.add(values[i])
           }
           return unionSet;
       }

2. 交集：对于给定的两个集合，返回一个包含两个集合中共有元素的新集合。

   this.intersection = function (otherSet) {
           let intersectionSet = new Set();
           let values = this.values()
           for (let i = 0; i < values.length; i++) {
               if (otherSet.has(values[i])) {
                   intersectionSet.add(values[i])
               }
           }
           return intersectionSet;
       }

    

3. 差集：对于给定的两个集合，返回一个包含所有存在于第一个集合且不存在于第二个集合的元素的新集合。

   this.difference = function (otherSet) {
           let differenceSet = new Set()
           let values = this.values()
           for (let i = 0; i < values.length; i++) {
               if(!otherSet.has(values[i])){
                   differenceSet.add(values[i])
               }
           }
           return differenceSet
       }

    

4. 子集：验证一个给定集合是否是另一集合的子集。　

   this.subset = function (otherSet) {
           if (this.size() > otherSet.size()) {
               return false
           }else{
               let values = this.values()
               for(let i=0; i<values.length;i++){
                   if(!otherSet.has(values[i])){
                       return false
                   }
               }
               return true;
           }
       }
   

5. 　

4、ES6新的类型

1. 新建集合：let set = new Set()
2. 添加元素：set.add(value)
3. 输出元素：set.values()
4. 判断元素是否存在：set.has(value)
5. 输出集合中元素的个数：set.size
6. 删除元素：set.delete(value)
7. 清空集合：set.clear()
8. 并集：

   let setA = new Set()
   setA.add(1)
   setA.add(2)
   setA.add(3)
   
   let setB = new Set()
   setB.add(2)
   setB.add(3)
   setB.add(4)
   
   let unionAb = new Set()
   for (const x of setA) {
       unionAb.add(x)
   }
   for (const x of setB) {
       unionAb.add(x)
   }

    

9. 交集

   let intersection = function (setA,setB) {
       let intersectionSet = new Set()
       for (let x of setA){
           if(setB.has(x)){
               intersectionSet.add(X)
           }
       }
       return intersectionSet;
   }

    

10. 差集

    let difference = function (setA,setB) {
        let differenceSet = new Set()
        for(let x of setA){
            if(!setB.has(x)){
                differenceSet.add(x)
            }
        }
        return differenceSet
    }

     

11. 子集

    let subset = function (setA,setB) {
        if (setA.size > setB.size) {
            return false
        }else{
            let values = Array.from(setA.values())
            for(let i=0; i<values.length;i++){
                if(!setB.has(values[i])){
                    return false
                }
            }
            return true;
        }
    }