/**
 * 集合的構(gòu)造函數(shù)
 */
function Set方法 {
 /**
  * 集合元素的容器，以對象來表示
  * @type {Object}
  */
 var items = {};
}

/**
 * 檢測集合內(nèi)是否有某個元素
 * @param {Any} value  要檢測的元素
 * @return {Boolean}    如果有，返回true
 */
this.has = function(value) {
 // hasOwnProperty的問題在于
 // 它是一個方法，所以可能會被覆寫
 return items.hasOwnProperty(value)
};

/**
 * 給集合內(nèi)添加某個元素
 * @param {Any} value 要被添加的元素
 * @return {Boolean}    添加成功返回True。
 */
this.add = function(value) {
 //先檢測元素是否存在。
 if (!this.has(value)) {
  items[value] = value;
  return true;
 }
 //如果元素已存在則返回false
 return false;
};

/**
 * 移除集合中某個元素
 * @param {Any} value 要移除的元素
 * @return {Boolean}    移除成功返回True。
 */
this.remove = function(value) {
 //先檢測元素是否存在。
 if (this.has(value)) {
  delete items[value];
  return true;
 }
 //如果元素不存在，則刪除失敗返回false
 return false;
};

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

/**
 * 返回集合長度，只可用于IE9及以上
 * @return {Number} 集合長度
 */
this.size = function() {
 // Object.keys方法能將對象轉(zhuǎn)化為數(shù)組
 // 只可用于IE9及以上，但很方便
 return Object.keys(items).length;
}

/**
 * 返回集合長度，可用于所有瀏覽器
 * @return {Number} 集合長度
 */
this.sizeLegacy = function() {
 var count = 0;
 for (var prop in items) {
  if (items.hasOwnProperty(prop)) {
   ++count;
  }
 }
 return count;
}

/**
 * 返回集合轉(zhuǎn)換的數(shù)組，只可用于IE9及以上
 * @return {Array} 轉(zhuǎn)換后的數(shù)組
 */
this.values = function() {
 return Object.keys(items);
};

/**
 * 返回集合轉(zhuǎn)換的數(shù)組，可用于所有瀏覽器
 * @return {Array} 轉(zhuǎn)換后的數(shù)組
 */
this.valuesLegacy = function() {
 var keys = [];
 for (var key in items) {
  keys.push(key)
 };
 return keys;
};

/**
 * 返回兩個集合的并集
 * @param {Set} otherSet 要進(jìn)行并集操作的集合
 * @return {Set}     兩個集合的并集
 */
this.union = function(otherSet) {
 //初始化一個新集合，用于表示并集。
 var unionSet = new Set();
 //將當(dāng)前集合轉(zhuǎn)換為數(shù)組，并依次添加進(jìn)unionSet
 var values = this.values();
 for (var i = 0; i < values.length; i++) {
  unionSet.add(values[i]);
 }

 //將其它集合轉(zhuǎn)換為數(shù)組，依次添加進(jìn)unionSet。
 //循環(huán)中的add方法保證了不會有重復(fù)元素的出現(xiàn)
 values = otherSet.values();
 for (var i = 0; i < values.length; i++) {
  unionSet.add(values[i]);
 }

 return unionSet;
};

/**
 * 返回兩個集合的交集
 * @param {Set} otherSet 要進(jìn)行交集操作的集合
 * @return {Set}     兩個集合的交集
 */
this.intersection = function(otherSet) {
 //初始化一個新集合，用于表示交集。
 var interSectionSet = new Set();
 //將當(dāng)前集合轉(zhuǎn)換為數(shù)組
 var values = this.values();
 //遍歷數(shù)組，如果另外一個集合也有該元素，則interSectionSet加入該元素。
 for (var i = 0; i < values.length; i++) {

  if (otherSet.has(values[i])) {
   interSectionSet.add(values[i])
  }
 }

 return interSectionSet;
};

/**
 * 返回兩個集合的差集
 * @param {Set} otherSet 要進(jìn)行差集操作的集合
 * @return {Set}     兩個集合的差集
 */
this.difference = function(otherSet) {
 //初始化一個新集合，用于表示差集。
 var differenceSet = new Set();
 //將當(dāng)前集合轉(zhuǎn)換為數(shù)組
 var values = this.values();
 //遍歷數(shù)組，如果另外一個集合沒有該元素，則differenceSet加入該元素。
 for (var i = 0; i < values.length; i++) {

  if (!otherSet.has(values[i])) {
   differenceSet.add(values[i])
  }
 }

 return differenceSet;
};

/**
 * 判斷該集合是否為傳入集合的子集
 * @param {Set} otherSet 傳入的集合
 * @return {Boolean}   是則返回True
 */
this.subset = function(otherSet) {
 // 第一個判定,如果該集合長度大于otherSet的長度
 // 則直接返回false
 if (this.size() > otherSet.size()) {
  return false;
 } else {
  // 將當(dāng)前集合轉(zhuǎn)換為數(shù)組
  var values = this.values();

  for (var i = 0; i < values.length; i++) {

   if (!otherSet.has(values[i])) {
    // 第二個判定。只要有一個元素不在otherSet中
    // 那么則可以直接判定不是子集，返回false
    return false;
   }
  }

  return true;
 }
};