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

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

  • 前言
    • 什么是集合?什么又是字典?
    • 区别?
  • 一、Set理解
    • 增删改查
      • add()
      • delete()
      • has()
      • clear()
    • 遍历
      • keys方法、values 方法、entries 方法
      • forEach() 方法
      • 扩展运算符和 Set 结构相结合实现数组或字符串去重
      • 实现并集、交集、和差集
  • 二、Map理解
    • 增删改查
      • size
      • set()
      • get()
      • has()
      • delete()
      • clear()
    • 遍历
  • 三、WeakSet 和 WeakMap
    • 简述
      • WeakSet:
      • WeakMap:
  • 四、使用场景
    • Set 使用场景
    • Map 使用场景
    • 应用示例:
      • Set 的应用示例
      • Map 的应用示例

ES6中对Set、Map两种数据结构的理解_第1张图片

前言

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

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

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

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

区别?

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

一、Set理解

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

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

简述

WeakSetWeakMap 是 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 中移除。

总的来说,WeakSetWeakMap 主要用于存储弱引用的对象,当这些对象不再被其他地方引用时,它们可以被自动移除,这有助于避免内存泄漏问题;需要注意的是,在使用 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,可以简化代码、提高性能,并且更加直观地处理集合和键值对相关的操作。

你可能感兴趣的:(JS,学习,ES6,前端,es6,javascript)