6.6 Set

ECMAScript 6新增的Set是一种新集合类型，为这门语言带来集合数据结构。Set在很多方面都像是加强的Map，这是因为它们的大多数API和行为都是共有的。

6.6.1 基本API

使用new关键字和Set构造函数可以创建一个空集合：

    const m = new Set();

如果想在创建的同时初始化实例，则可以给Set构造函数传入一个可迭代对象，其中需要包含插入到新集合实例中的元素：

    // 使用数组初始化集合
    const s1 = new Set(["val1", "val2", "val3"]);
    alert(s1.size); // 3
    // 使用自定义迭代器初始化集合
    const s2 = new Set({
      [Symbol.iterator]: function＊() {
        yield "val1";
        yield "val2";
        yield "val3";
      }
    });
    alert(s2.size); // 3

初始化之后，可以使用add()增加值，使用has()查询，通过size取得元素数量，以及使用delete()和clear()删除元素：

    const s = new Set();
    alert(s.has("Matt"));     // false
    alert(s.size);              // 0
    s.add("Matt")
      .add("Frisbie");
    alert(s.has("Matt"));     // true
    alert(s.size);              // 2
    s.delete("Matt");
    alert(s.has("Matt"));     // false
    alert(s.has("Frisbie")); // true
    alert(s.size);              // 1
    s.clear(); // 销毁集合实例中的所有值
    alert(s.has("Matt"));     // false
    alert(s.has("Frisbie")); // false
    alert(s.size);              // 0

add()返回集合的实例，所以可以将多个添加操作连缀起来，包括初始化：

    const s = new Set().add("val1");
    s.add("val2")
      .add("val3");
    alert(s.size); // 3

与Map类似，Set可以包含任何JavaScript数据类型作为值。集合也使用SameValueZero操作（ECMAScript内部定义，无法在语言中使用），基本上相当于使用严格对象相等的标准来检查值的匹配性。

    const s = new Set();
    const functionVal = function() {};
    const symbolVal = Symbol();
    const objectVal = new Object();
    s.add(functionVal);
    s.add(symbolVal);
    s.add(objectVal);
    alert(s.has(functionVal));    // true
    alert(s.has(symbolVal));      // true
    alert(s.has(objectVal));      // true
    // SameValueZero检查意味着独立的实例不会冲突
    alert(s.has(function() {})); // false

与严格相等一样，用作值的对象和其他“集合”类型在自己的内容或属性被修改时也不会改变：

    const s = new Set();
    const objVal = {},
          arrVal = [];
    s.add(objVal);
    s.add(arrVal);
    objVal.bar = "bar";
    arrVal.push("bar");
    alert(s.has(objVal)); // true
    alert(s.has(arrVal)); // true

add()和delete()操作是幂等的。delete()返回一个布尔值，表示集合中是否存在要删除的值：

    const s = new Set();
    s.add('foo');
    alert(s.size); // 1
    s.add('foo');
    alert(s.size); // 1
    // 集合里有这个值
    alert(s.delete('foo')); // true
    // 集合里没有这个值
    alert(s.delete('foo')); // false

6.6.2 顺序与迭代

Set会维护值插入时的顺序，因此支持按顺序迭代。

集合实例可以提供一个迭代器（Iterator），能以插入顺序生成集合内容。可以通过values()方法及其别名方法keys()（或者Symbol.iterator属性，它引用values()）取得这个迭代器：

    const s = new Set(["val1", "val2", "val3"]);
    alert(s.values === s[Symbol.iterator]); // true
    alert(s.keys === s[Symbol.iterator]);    // true
    for (let value of s.values()) {
      alert(value);
    }
    // val1
    // val2
    // val3
    for (let value of s[Symbol.iterator]()) {
      alert(value);
    }
    // val1
    // val2
    // val3

因为values()是默认迭代器，所以可以直接对集合实例使用扩展操作，把集合转换为数组：

    const s = new Set(["val1", "val2", "val3"]);
    console.log([...s]); // ["val1", "val2", "val3"]

集合的entries()方法返回一个迭代器，可以按照插入顺序产生包含两个元素的数组，这两个元素是集合中每个值的重复出现：

    const s = new Set(["val1", "val2", "val3"]);
    for (letpairofs.entries()) {
      console.log(pair);
    }
    // ["val1", "val1"]
    // ["val2", "val2"]
    // ["val3", "val3"]

如果不使用迭代器，而是使用回调方式，则可以调用集合的forEach()方法并传入回调，依次迭代每个键/值对。传入的回调接收可选的第二个参数，这个参数用于重写回调内部this的值：

    const s = new Set(["val1", "val2", "val3"]);
    s.forEach((val, dupVal) => alert(`${val} -> ${dupVal}`));
    // val1-> val1
    // val2-> val2
    // val3-> val3

修改集合中值的属性不会影响其作为集合值的身份：

    const s1 = new Set(["val1"]);
    // 字符串原始值作为值不会被修改
    for (let value of s1.values()) {
      value = "newVal";
      alert(value);             // newVal
      alert(s1.has("val1")); // true
    }
    const valObj = {id: 1};
    const s2 = new Set([valObj]);
    // 修改值对象的属性，但对象仍然存在于集合中
    for (let value of s2.values()) {
      value.id = "newVal";
      alert(value);              // {id: "newVal"}
      alert(s2.has(valObj));   // true
    }
    alert(valObj);               // {id: "newVal"}

6.6.3 定义正式集合操作

从各方面来看，Set跟Map都很相似，只是API稍有调整。唯一需要强调的就是集合的API对自身的简单操作。很多开发者都喜欢使用Set操作，但需要手动实现：或者是子类化Set，或者是定义一个实用函数库。要把两种方式合二为一，可以在子类上实现静态方法，然后在实例方法中使用这些静态方法。在实现这些操作时，需要考虑几个地方。

❑ 某些Set操作是有关联性的，因此最好让实现的方法能支持处理任意多个集合实例。

❑ Set保留插入顺序，所有方法返回的集合必须保证顺序。

❑ 尽可能高效地使用内存。扩展操作符的语法很简洁，但尽可能避免集合和数组间的相互转换能够节省对象初始化成本。

❑ 不要修改已有的集合实例。union(a, b)或a.union(b)应该返回包含结果的新集合实例。

    class XSet extends Set {
      union(...sets) {
        return XSet.union(this, ...sets)
      }
      intersection(...sets) {
        return XSet.intersection(this, ...sets);
      }
      difference(set) {
        return XSet.difference(this, set);
      }
      symmetricDifference(set) {
        return XSet.symmetricDifference(this, set);
      }
      cartesianProduct(set) {
        return XSet.cartesianProduct(this, set);
      }
      powerSet() {
        return XSet.powerSet(this);
      }
    // 返回两个或更多集合的并集
    static union(a, ...bSets) {
      const unionSet = new XSet(a);
      for (const b of bSets) {
        for (const bValue of b) {
          unionSet.add(bValue);
        }
      }
      return unionSet;
    }
    // 返回两个或更多集合的交集
    static intersection(a, ...bSets) {
      const intersectionSet = new XSet(a);
      for (const aValue of intersectionSet) {
        for (const b of bSets) {
          if (! b.has(aValue)) {
            intersectionSet.delete(aValue);
          }
        }
      }
      return intersectionSet;
    }
    // 返回两个集合的差集
    static difference(a, b) {
      const differenceSet = new XSet(a);
      for (const bValue of b) {
        if (a.has(bValue)) {
          differenceSet.delete(bValue);
        }
      }
      return differenceSet;
    }
    // 返回两个集合的对称差集
    static symmetricDifference(a, b) {
      // 按照定义，对称差集可以表达为
      return a.union(b).difference(a.intersection(b));
    }
    // 返回两个集合（数组对形式）的笛卡儿积
    // 必须返回数组集合，因为笛卡儿积可能包含相同值的对
    static cartesianProduct(a, b) {
      const cartesianProductSet = new XSet();
      for (const aValue of a) {
        for (const bValue of b) {
          cartesianProductSet.add([aValue, bValue]);
        }
      }
      return cartesianProductSet;
    }
    // 返回一个集合的幂集
    static powerSet(a) {
      const powerSet = new XSet().add(new XSet());
      for (const aValue of a) {
          for (const set of new XSet(powerSet)) {
            powerSet.add(new XSet(set).add(aValue));
          }
        }
        return powerSet;
      }
    }