1 集合

什么是集合

集合通常是由一组无序的，不能重复的元素构成。 集合可以看成一种特殊的数组，特殊之处在于里面的元素没有顺序，也不能重复。

• 没有顺序意味着不能通过下标值进行访问。
• 不能重复意味着相同的对象在集合中只会存在一份。

集合的封装

分为两部分，第一部分是集合的增删改查等，第二部分是集合间的交集、并集等操作。因为都比较简单，所以封装在一起。

 class Set {
    constructor() {
        this.items = {};
    }
    // has(value)：如果值在集合中，返回true，否则返回false。
    has(value) {
        return this.items.hasOwnProperty(value);
    }
    //  add(value)：向集合添加一个新的项。
    add(value) {
        if (this.has(value)) {
            return false;
        }
        this.items[value] = value;
        return true;
    }
    // remove(value)：从集合移除一个值。
    remove(value) {
        if (!this.has(value)) {
            return false;
        }
        delete this.items[value];
    }
    // clear()：移除集合中的所有项。
    clear() {
        this.items = {};
    }

    // size()：返回集合所包含元素的数量。与数组的length属性类似。
    size() {
        return Object.keys(this.items).length;
    }
    // values()：返回一个包含集合中所有值的数组。
    values() {
        return Object.keys(this.items);
    }
    //-----------------------------------------------
    // union  并集
    union(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 < values.length; i++) {
            unionSet.add(values[i]);
        }
        return unionSet;
    }
    // intersection交集
    intersection(otherSet) {
        let intersectionSet = new Set();
        let values = this.values();

        for (let i = 0; i < values.length; i++) {
            let item = values[i];
            if (otherSet.has(item)) {
                intersectionSet.add(item);
            }
        }
        return intersectionSet;
    }
    // different 差集
    different(otherSet) {
        let differentSet = new Set();
        let values = this.values();
        for (let i = 0; i < values.length; i++) {
            let item = values[i];
            if (!otherSet.has(item)) {
                differentSet.add(item);
            }
        }
        return differentSet;
    }
    //  subset 子集
    subset(otherSet) {
        let subsetSet = new Set();
        let values = this.values();
        for (let i = 0; i < values.length; i++) {
            let item = values[i];
            if (!this.has(item)) {
                return false;
            }
        }
        return true;
    }
}

//测试代码
let setA = new Set();
setA.add('aaa');
setA.add('bbb');
setA.add('ccc');
// console.log(setA);
// console.log(setA.has('aaa'));
// console.log(setA.size());
// console.log(setA.values());
// setA.remove('aaa');
// console.log(setA);
// setA.clear();
// console.log(setA);
//-------------------
let setB = new Set();
setB.add('aaa');
setB.add('abc');
setB.add('ddd');
let setC = new Set();
setC.add('aaa');
console.log(setA.union(setB));
console.log(setA.intersection(setB));
console.log(setA.different(setB));
console.log(setA.subset(setC));

2 字典

• 在JavaScript中，似乎对象本身就是一种字典，所以在早期的JavaScript中，没有字典这种数据类型，因为你完全可以用对象做字典
• ES6添加了Map（映射关系，相当于字典）