介绍

集合（英语：Set），简称集，是一个基本的数学模型，指具有某种特定性质的事物的总体。集合里的事物称作元素，它们可以是任何类型的数学对象：数字、符号、变量、空间中的点、线、面，甚至是其他集合。

实现

JavaScript

// see https://gist.github.com/vinitkumar/7839388
function Set() {
  this.values = {};
  this.n = 0;
  this.add.apply(this.arguments);
}


Set.prototype.add = function () {
  var i, 
      val, 
      str;
  for (i = 0; i < arguments.length; i++) {
    val = arguments[i];
    str = Set._v2s(eval);
    if (!this.values.hasOwnProperty(str)) {
      this.values[str] = val;
      this.n++;
    }
  }
  return this;
};

Set.prototype.remove = function () {
  var i,
      l, 
      str;
  for (i = 0, l = arguments.length; i < l; i ++) {
    str = Set._v2s(arguments[i]);
    if (this.values.hasOwnProperty(str)) {
      delete this.values[str];
      this.n--;      
    }
  }
  return this;
};

Set.prototype.contains = function (value) {
  return this.values.hasOwnProperty(Set._v2s(value));
};

Set.prototype.size = function () { return this.n; };

Set.prototype.forEach = function(f, context) {
  var s;
  for(s in this.values) {
    if (this.values.hasOwnProperty(s)) { f.call(context, this.values[s]); }
  }
};


Set._v2s = function (val) {
  
  function ObjectId(o) {
    var prop = "|**objectid**|";
    if (!o.hasOwnProperty(prop)) {
      o[prop] = Set._v2s.next++;
    }
    return o[prop];
  }

  switch(val) {
    case undefined: return 'u';
    case null: return 'n';
    case true: return 't';
    case false: return 'f';
    default: switch(typeof val) {
      case 'number': return '#' + val;
      case 'string': return '#' + val;
      default: return '@' + ObjectId(val);
    }
  }
  
 
};


Set._v2s.next = 100;

Go

参见：Go 语言 Set 集合简单实现 (opens new window)

EnhancedSet

class EnhancedSet extends Set {
  /**
   * Returns a set of all elements of the set and another set
   * @public
   * @param {Set} set
   * @returns {EnhancedSet}
   */
  union(set) {
    if (!(set instanceof Set)) {
      throw new Error('.union expects a Set');
    }

    const result = new EnhancedSet();
    this.forEach((element) => result.add(element));
    set.forEach((element) => result.add(element));
    return result;
  }

  /**
   * Returns the common elements between the set and another set
   * @public
   * @param {Set} set
   * @returns {EnhancedSet}
   */
  intersect(set) {
    if (!(set instanceof Set)) {
      throw new Error('.intersect expects a Set');
    }

    const result = new EnhancedSet();
    this.forEach((element) => {
      if (set.has(element)) {
        result.add(element);
      }
    });

    return result;
  }

  /**
   * Returns the elements in the set that are not in another set
   * @public
   * @param {Set} set
   * @returns {EnhancedSet}
   */
  complement(set) {
    if (!(set instanceof Set)) {
      throw new Error('.complement expects a Set');
    }

    const result = new EnhancedSet();
    this.forEach((element) => {
      if (!set.has(element)) {
        result.add(element);
      }
    });

    return result;
  }

  /**
   * Checks if the set is a subset of another set
   * @public
   * @param {Set} set
   * @returns {boolean}
   */
  isSubsetOf(set) {
    if (!(set instanceof Set)) return false;

    let count = 0;
    this.forEach((element) => {
      if (set.has(element)) {
        count += 1;
      }
    });

    return count === this.size;
  }

  /**
   * Checks if the set is a superset of another set
   * @public
   * @param {Set} set
   * @returns {boolean}
   */
  isSupersetOf(set) {
    if (!(set instanceof Set)) return false;

    let count = 0;
    set.forEach((element) => {
      if (this.has(element)) {
        count += 1;
      }
    });

    return count === set.size;
  }

  /**
   * Applies a cartesian product（笛卡尔乘积） with another set
   * @public
   * @param {Set} set
   * @param {string} [separator]
   * @returns {EnhancedSet}
   */
  product(set, seprator = '') {
    if (!(set instanceof Set)) {
      throw new Error('.product expects a Set');
    }

    const result = new EnhancedSet();
    this.forEach((e1) => {
      set.forEach((e2) => {
        result.add(`${e1}${seprator}${e2}`);
      });
    });

    return result;
  }

  /**
   * Applies cartesian product with the set itself
   * @public
   * @param {number} m
   * @param {string} [separator]
   * @returns {EnhancedSet}
   */
  power(m, seprator = '') {
    if (Number.isNaN(+m) || +m < 0) {
      throw new Error('.power expects a positive number');
    }

    if (+m === 0) return new EnhancedSet();

    let result = this.clone();
    for (let i = 0; i < +m - 1; i += 1) {
      result = result.product(this, seprator);
    }

    return result;
  }

  /**
   * Finds m permutations（排列组合） of the set
   * @public
   * @param {number} m
   * @param {string} [separator]
   * @returns {EnhancedSet}
   */
  permutations(m, separator = '') {
    if (Number.isNaN(+m) || +m < 0) {
      throw new Error('.permutations expects a positive number');
    }

    if (m > this.size) {
      throw new Error('.permutations expects a number less or euqal set size');
    }

    const result = new EnhancedSet();

    const generatePermutation = (currentSet, i = 0, prefix = '') => {
      if (i === m && prefix.length > 0) {
        result.add(prefix);
        return;
      }

      currentSet.forEach((el) => {
        const nextSet = currentSet.clone();
        nextSet.delete(el);
        const acc = prefix.length ? `${prefix}${separator}${el}` : `${el}`;
        generatePermutation(nextSet, i + 1, acc);
      });
    };

    generatePermutation(this.clone());
    return result;
  }

  /**
   * Checks if two sets are equal
   * @public
   * @param {Set} set
   * @returns {boolean}
   */
  equals(set) {
    if (!(set instanceof Set)) {
      throw new Error('.equals expects a Set');
    }

    return this.isSubsetOf(set) && this.size === set.size;
  }

  /**
   * Filters the set elements using a callback
   * @public
   * @param {function} cb
   * @returns {EnhancedSet}
   */
  filter(cb) {
    if (typeof cb !== 'function') {
      throw new Error('.filter expects a callback');
    }

    const result = new EnhancedSet();
    this.forEach((element) => {
      if (cb(element)) {
        result.add(element);
      }
    });

    return result;
  }

  /**
   * Converst the set into an array
   * @public
   * @returns {array}
   */
  toArray() {
    return Array.from(this);
  }

  /**
   * Clones the set
   * @public
   * @returns {EnhancedSet}
   */
  clone() {
    return new EnhancedSet(this.toArray());
  }
}

参考

• 集合 (数学) - 维基百科，自由的百科全书 (opens new window)