ES6中对Set、Map两种数据结构的理解

前言

Set是一种叫做集合的数据结构，Map是一种叫做字典的数据结构

什么是集合？什么又是字典？

• 集合
  是由一堆无序的、相关联的，且不重复的内存结构【数学中称为元素】组成的组合

• 字典
  是一些元素的集合。每个元素有一个称作key 的域，不同元素的key 各不相同

区别？

• 共同点：集合、字典都可以存储不重复的值
• 不同点：集合是以[值，值]的形式存储元素，字典是以[键，值]的形式存储

一、Set理解

Set 是 es6 新增的数据结构，类似于数组，但是成员的值都是唯一的，没有重复的值，我们一般称为集合

Set 本身是一个构造函数，用来生成 Set 数据结构

const b = new Set();

增删改查

Set 的实例关于增删改查的方法：

• add()

• delete()

• has()

• clear()

add()

添加某个值，返回 Set 结构本身

当添加实例中已经存在的元素，set 不会进行处理添加

b.add(1).add(2).add(2); // 2只被添加了一次

delete()

删除某个值，返回一个布尔值，表示删除是否成功

b.delete(1)

has()

返回一个布尔值，判断该值是否为Set的成员

b.has(2)

clear()

清除所有成员，没有返回值

b.clear()

遍历

Set 实例遍历的方法有如下：

• keys()：返回键名的遍历器
• values()：返回键值的遍历器
• entries()：返回键值对的遍历器
• forEach()：使用回调函数遍历每个成员

Set 的遍历顺序就是插入顺序

keys方法、values 方法、entries 方法

keys 方法、values 方法、entries 方法返回的都是遍历器对象

let set = new Set(['red', 'green', 'blue']);

for (let item of set.keys()) {
  console.log(item);
}
// red
// green
// blue

let set = new Set(['red', 'green', 'blue']);

for (let item of set.values()) {
  console.log(item);
}
// red
// green
// blue

let set = new Set(['red', 'green', 'blue']);

for (let item of set.entries()) {
  console.log(item);
}
// ["red", "red"]
// ["green", "green"]
// ["blue", "blue"]

forEach() 方法

forEach() 用于对每个成员执行某种操作，没有返回值，键值、键名都相等，同样的forEach方法有第二个参数，用于绑定处理函数的this

let set = new Set([1, 2, 3]);
set.forEach((value, key) => console.log(key + ' : ' + value))
// 1 : 1
// 2 : 2
// 3 : 3

扩展运算符和 Set 结构相结合实现数组或字符串去重

// 数组
let arr = [3, 5, 2, 2, 5, 5, 5, 5];
let unique = [...new Set(arr)]; // [3, 5, 2]

// 字符串
let str = "35225555";
let unique = [...new Set(str)].join(""); // "352"

实现并集、交集、和差集

let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);

// 并集
let union = new Set([...a, ...b]);
// Set {1, 2, 3, 4}

// 交集
let intersect = new Set([...a].filter(x => b.has(x)));
// set {2, 3}

// （a 相对于 b 的）差集
let difference = new Set([...a].filter(x => !b.has(x)));
// Set {1}

二、Map理解

Map 类型是键值对的有序列表，而键和值都可以是任意类型

Map 本身是一个构造函数，用来生成 Map 数据结构

const a = new Map()

增删改查

Map 结构的实例针对增删改查有以下属性和操作方法：

• size 属性
• set()
• get()
• has()
• delete()
• clear()

size

size 属性返回 Map 结构的成员总数。

const map = new Map();
map.set('foo', true);
map.set('bar', false);

map.size // 2

set()

设置键名key对应的键值为value，然后返回整个 Map 结构

如果key已经有值，则键值会被更新，否则就新生成该键，同时返回的是当前Map对象，可采用链式写法

const m = new Map();

m.set('edition', 6)        // 键是字符串
m.set(262, 'standard')     // 键是数值
m.set(undefined, 'nah')    // 键是 undefined
m.set(1, 'a').set(2, 'b').set(3, 'c') // 链式操作

get()

get 方法读取key对应的键值，如果找不到key，返回undefined

const m = new Map();

const hello = function() {console.log('hello');};
m.set(hello, 'Hello ES6!') // 键是函数

m.get(hello)  // Hello ES6!

has()

has 方法返回一个布尔值，表示某个键是否在当前 Map 对象之中

const m = new Map();

m.set('edition', 6);
m.set(262, 'standard');
m.set(undefined, 'nah');

m.has('edition')     // true
m.has('years')       // false
m.has(262)           // true
m.has(undefined)     // true

delete()

delete 方法删除某个键，返回true。如果删除失败，返回false

const m = new Map();
m.set(undefined, 'nah');
m.has(undefined)     // true

m.delete(undefined)
m.has(undefined)       // false

clear()

clear 方法清除所有成员，没有返回值

let map = new Map();
map.set('foo', true);
map.set('bar', false);

map.size // 2
map.clear()
map.size // 0

遍历

Map 结构原生提供三个遍历器生成函数和一个遍历方法：

• keys()：返回键名的遍历器
• values()：返回键值的遍历器
• entries()：返回所有成员的遍历器
• forEach()：遍历 Map 的所有成员

遍历顺序就是插入顺序

const map = new Map([
  ['F', 'no'],
  ['T',  'yes'],
]);

for (let key of map.keys()) {
  console.log(key);
}
// "F"
// "T"

for (let value of map.values()) {
  console.log(value);
}
// "no"
// "yes"

for (let item of map.entries()) {
  console.log(item[0], item[1]);
}
// "F" "no"
// "T" "yes"

// 或者
for (let [key, value] of map.entries()) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"

// 等同于使用map.entries()
for (let [key, value] of map) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"

map.forEach(function(value, key, map) {
  console.log("Key: %s, Value: %s", key, value);
});

三、WeakSet 和 WeakMap

简述

WeakSet 和 WeakMap 是 ES6 引入的两种新的数据结构，它们与 Set 和 Map 相似，但有一些不同之处。

WeakSet:

• WeakSet 对象允许你将弱引用对象存储在一个集合中。在 JavaScript 中，对象是通过引用来存储和传递的，而 WeakSet 保持的是这些对象的弱引用，这意味着如果没有其他变量或属性引用这个对象，那么这个对象将被垃圾回收器从 WeakSet 中移除。
• WeakSet 不是可枚举的，因此没有办法确定 WeakSet 中到底有多少个对象。
• WeakSet 没有迭代方法，因此不能直接获取其中包含的所有元素。

let weakSet = new WeakSet();

let obj1 = {name: 'John'};
let obj2 = {name: 'Jane'};

weakSet.add(obj1);
weakSet.add(obj2);

console.log(weakSet.has(obj1)); // true

obj1 = null; // 解除对obj1的引用

console.log(weakSet.has(obj1)); // false，obj1已被从WeakSet中移除

在上面的例子中，我们创建了一个 WeakSet，并向其添加了两个对象 obj1 和 obj2。当我们解除对 obj1 的引用后，由于没有其他变量或属性引用 obj1，它将被垃圾回收器回收，并自动从 WeakSet 中移除

WeakMap:

• WeakMap 对象是一组键值对的集合，其中的键是弱引用的。类似于 WeakSet，如果没有其他变量或属性引用这个键所关联的对象，那么这个键值对会被垃圾回收器从 WeakMap 中移除。
• WeakMap 的 key 必须是对象，而 value 可以是任意类型的。
• WeakMap 也是不可枚举的，无法获取其中包含的所有键值对。
• WeakMap 也没有迭代方法，因此无法直接获取其中的所有键值对。

let weakMap = new WeakMap();

let key1 = {name: 'John'};
let key2 = {name: 'Jane'};
let value1 = 'Value 1';
let value2 = 'Value 2';

weakMap.set(key1, value1);
weakMap.set(key2, value2);

console.log(weakMap.get(key1)); // Value 1

key1 = null; // 解除对key1的引用

console.log(weakMap.get(key1)); // undefined，key1已被从WeakMap中移除

在这个例子中，我们创建了一个 WeakMap，并使用对象作为键来关联对应的值。当我们解除对 key1 的引用后，由于没有其他变量或属性引用 key1，它将被垃圾回收器回收，并自动从 WeakMap 中移除。

总的来说，WeakSet 和 WeakMap 主要用于存储弱引用的对象，当这些对象不再被其他地方引用时，它们可以被自动移除，这有助于避免内存泄漏问题；需要注意的是，在使用 WeakSet 和 WeakMap 时，键对象不能是原始类型，必须是对象。因为只有对象才能被设置为弱引用，原始类型的值无法被垃圾回收器回收。

四、使用场景

Set 使用场景

1. 去重：由于 Set 存储的值是唯一的，可以方便地用来去除数组中的重复元素。
2. 列表操作：可以方便地对集合进行交集、并集、差集等操作。
3. 验证值的存在：可以快速判断某个值是否存在于集合中。

Map 使用场景

1. 键值对存储：适合存储需要按照特定键访问的数据，例如存储用户信息、配置项等。
2. 缓存管理：可以将计算结果以键值对的形式存储在 Map 中，加快后续访问的速度。
3. 数据转换：可以方便地将一个数据结构转换为另一个数据结构，例如将对象转换为 Map，进行键值对的操作。

应用示例：

Set 的应用示例

// 去重
const arr = [1, 2, 3, 4, 2, 3, 5];
const uniqueValues = [...new Set(arr)];
console.log(uniqueValues); // [1, 2, 3, 4, 5]

// 列表操作
const set1 = new Set([1, 2, 3]);
const set2 = new Set([2, 3, 4]);
const intersect = new Set([...set1].filter(value => set2.has(value)));
console.log(intersect); // Set {2, 3}

// 验证值的存在
const set = new Set([1, 2, 3]);
console.log(set.has(2)); // true
console.log(set.has(4)); // false

Map 的应用示例

// 键值对存储
const userMap = new Map();
userMap.set('John', {age: 30, city: 'New York'});
userMap.set('Jane', {age: 28, city: 'San Francisco'});
console.log(userMap.get('John')); // {age: 30, city: 'New York'}

// 缓存管理
function calculateResult(input) {
  // 假设这里是一个耗时计算的函数
  return input * 2;
}

const cache = new Map();
function getResult(input) {
  if (cache.has(input)) {
    return cache.get(input);
  }
  
  const result = calculateResult(input);
  cache.set(input, result);
  return result;
}

console.log(getResult(5)); // 第一次计算并缓存结果
console.log(getResult(5)); // 直接从缓存中获取结果

// 数据转换
const obj = {key1: 'value1', key2: 'value2'};
const map = new Map(Object.entries(obj));
console.log(map.get('key1')); // 'value1'

通过合理地使用 Set 和 Map，可以简化代码、提高性能，并且更加直观地处理集合和键值对相关的操作。