1. 定義

集合是一組無序且唯一(即不能重複)的項組成。

2. Set例項

Es6中，已經有了Set型別。這裡我們自己實現Set類。

• Set類中資料儲存，不再是使用陣列，而是使用物件
• add(value): 新增項
• remove(value): 移除集合中的一個值
• has(value): 集合中是否存在該值，true存在，false不存在
• clear(): 清除所有項
• size(): 集合包含元素個數
• values(): 返回一個包含集合中所有值的陣列
  

function Set() {
    // 使用物件儲存資料
    let items = {};
    let size = 0;
    this.has = (item) => ( item in items); // items.hasOwnProperty(item)

    //  新增成功返回true,已存在不進行新增直接返回false
    this.add = (item) => {
        if (!this.has(item)) {
            items[item] = item;
            size++;
            return true;
        }
        return false;
    };

    // 移除成功返回true
    this.remove = (item) => {
        if (this.has(item)) {
            delete items[item];
            size--;
            return true;
        }
        return false;
    };

    // 清空集合
    this.clear = () => (items = {});

    // 返回集合長度
    this.size = () => (size);
    
    // 獲取所有的value值，作為一個陣列返回，這裡的key和value是相同的
    this.values = () => {
        let ret = [];
        for (let key in items) {
            ret.push(key);
        }
        return ret;
    }
}

var set = new Set();
set.add(1);
console.log(set.values()); //輸出["1"]
console.log(set.has(1)); //輸出true
console.log(set.size()); //輸出1
set.add(2);
console.log(set.values()); //輸出["1", "2"]
console.log(set.has(2)); //true
console.log(set.size()); //2
set.remove(1);
console.log(set.values()); //輸出["2"]
set.remove(2);
console.log(set.values()); //輸出[]
複製程式碼

3. 集合操作

對集合進行如下操作：

• 並集：給定兩個集合，返回一個包含兩個集合中的所有元素的新集合
  

• 交集：給定兩個結合，返回一個包含兩個集合中的共有元素的新集合
  

(./assets/15.png)

• 差集：給定兩個集合，返回一個包含所有存在於第一個集合且不存在於第二個集合的元素的新集合。
  

• 子集：驗證一個給定集合是否是另一個集合的子集
  

function Set() {
    // .....: 上面的實現

    // 並集
    this.union = (otherSet) => {
        let unionSet = new Set();
        let values = this.values();
        values.map((value) => {unionSet.add(value)});
        values = otherSet.values();
        values.map((value) => {unionSet.add(value)});
        return unionSet;
    };

    // 交集
    this.intersection = (otherSet) => {
        let intersectionSet = [];
        otherSet.values().map((item) => {
            console.log(this.has(item), '0---', item)
            if (this.has(item)) {
                intersectionSet.push(item);
            };
        });
        return intersectionSet;
    };

    // 差集
    this.difference = (otherSet) => {
        let diffSet = [];
        this.values().map((item) => {
            if (otherSet.has(item)) {
                return;
            }
            diffSet.push(item);
        });
        return diffSet;
    };

    //  子集合
    this.subSet = (otherSet) => {
        if (this.size() > otherSet.size()){
            return false;
        } else {
        var values = this.values();
        for (var i=0; i<values.length; i++){
            if (!otherSet.has(values[i])){
                return false;
                }
        }
        return true;
        }
    }
}
複製程式碼