学习《JavaScript高级程序设计》----day05

---

一、数组

点击前往查看

二、Map和WeakMap

1.Map：

• 创建Map实例：
  使用new Map()创Map实例。

  // 创建一个空map实例
  const m1 = new Map();
  
  //创建一个带有键值对的实例, new Map([[key1, value1], ...,[keyn, valuen]])
  const m2 = new Map([
          ['k1', 23],
          ["k2", 5]
  ]);
  

• Map属性和方法：
  size：键值对的数量。

  console.log(m1.size); // 0
  console.log(m2.size); // 2
  

  has(key)：判断Map实例中是否存在键key，有则返回true；否则返回false。

  console.log(m1.has("k1")); // false
  console.log(m2.has("k1")); // true
  

  get(key)：获取Map实例中键key对应的值，没有则返回undefined。

  console.log(m1.get("k1")); // undefined
  console.log(m2.get("k2")); // 23
  

  set(key, val)：设置键值对。

  m1.set("k1", 34);
  

  delete(key)：返回值为boolean类型，删除key对应的键值对，删除成功则返回true；否则false。

  m2.delete("k1");
  

  clear()：清除Map实例中所有的键值对。

  m2.clear();
  console.log(m2.size); // 0
  

• Map的迭代：
  与数组的迭代相似，使用entries(), keys(), values()。

  const map = new Map([
  	['k1', 23],
  	['k2', 34],
  	['k3', 45]
  ]);
  
  // entries()
  for	(const [key, val] of map.entries()){
  	console.log(`${key} : ${val}`);
  }
  
  // keys()
  for	(const key of map.keys()){
  	console.log(key);
  }
  // values()
  for	(const val of map.values()){
  	console.log(val);
  }
  

• Object与Map比较：
  1.内存占用：给定固定大小的内存Map大约可比Object多存储50%的键值对。
  2.插入性能：平均来说，Map性能更加。
  3.查找性能：代码涉及大量查找操作，Map性能更佳。
  4.删除性能：Map的删除性能更佳。

2.WeakMap：

与Map类似,只不过WeakMap更利于垃圾回收机制回收且不可迭代，适合保存DOM节点元数据。

三、Set和WeakSet

1.Set

• 创建Set实例：
  使用new Set()创建Set实例。

  // 创建一个空Set实例
  const set1 = new Set();
  
  // 创建一个带有元素的Set实例
  const set2 = new Set([1, 2, 3, 4, 5, 6]);
  

• 基本API:
  has(e)：查找集合中是否有指定的元素e，有则返回true；否则返回false。

  console.log(set2.has(4)); // true
  console.log(set2.has(10)); // false
  

  add(e)：向集合中添加元素。

  set2.add(23);
  console.log(set2.has(23)); // true;
  

  size：获取集合中的元素数量。

  console.log(set2.size); // 7
  

  delete(e)：删除指定元素。

  set2.delete(23);
  console.log(set2.has(23)); // false
  

  clear()：清除集合中的所有元素。

  set2.delete();
  console.log(set2.size); // 0
  

  Set有点类似数组但是Set不允许重复出现相同的元素。

  // 使用Set的特性过滤数组的重复元素
  let arr = [1, 2, 3, 2, 3, 4, 1, 4, 23, 1, 34, 23];
  arr = Array.of(...new Set(arr));
  console.log(arr); // [1, 2, 3, 4, 23, 34]
  

• 迭代:
  values()：返回集合中所有元素的迭代器。

  const set = new Set([1, 2, 3, 4, 5]);
  for	(const val of set.values()){
  	console.log(val);
  }
  

• 集合运算:
  union(a, ...Sets)：返回两个或多个集合的并集。
  intersection(a, ...Sets):返回两个或多个集合的交集。
  difference(a, b)：返回两个集合的差集。
  symmetricDifference(a, b)：返回两个集合的对称差集。
  cartesianProduct(a, b)：返回两个集合的笛卡尔积。
  powerSet(a)：返回一个集合的幂集。

  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, ...sets) {
  		const unionSet = new XSet();
  		for (const set of sets) {
  			for (const e of set) {
  				unionSet.add(e);
  			}
  		}
  		return unionSet;
  	}
  	static intersection(a, ...sets) {
  		const intersectionSet = new XSet(a);
  		for (const e of intersectionSet) {
  			for (const set of sets) {
  				if (!set.has(e)) {
  					intersectionSet.delete(e);
  				}
  			}
  		}
  		return intersectionSet;
  	}
  	static difference(a, b) {
  		const differenceSet = new XSet(a);
  		for (const e of b) {
  			if (differenceSet.has(e)) {
  				differenceSet.delete(e);
  			}
  		}
  		return differenceSet;
  	}
  	static symmetricDifference(a, b) {
  		return a.union(b).difference(a.intersection(b));
  	}
  	static cartesianProduct(a, b) {
  		const cartesianProductSet = new XSet();
  		for (const e1 of a) {
  			for (const e2 of b) {
  				cartesianProductSet.add([e1, e2]);
  			}
  		}
  		return cartesianProductSet;
  	}
  	static powerSet(a) {
  		const powerSet = new XSet().add(new XSet());
  		for (const e of a) {
  			for (const set of new XSet(powerSet)) {
  				powerSet.add(new XSet(set).add(e));
  			}
  		}
  		return powerSet;
  	}
  }
  

WeakSet:
与Set类似,但是WeakSet更利于垃圾回收机制回收且不可迭代。