在JavaScript中，map和set是两种常用的数据结构，它们可以帮助我们存储和操作键值对和唯一值。本文将介绍一些map和set的应用技巧，让你更好地利用这两种数据结构。
1. 使用map来缓存函数的结果
有时候，我们需要对一些复杂或耗时的函数进行缓存，以提高性能和避免重复计算。这时候，我们可以使用map来存储函数的输入和输出，实现一个简单的缓存机制。例如，下面的代码定义了一个斐波那契数列的函数，并使用一个map来缓存已经计算过的结果：
// 定义一个斐波那契数列的函数
function fib(n) {
// 如果n小于等于1，直接返回n
if (n <= 1) return n;
// 否则，返回前两项之和
return fib(n - 1) + fib(n - 2);
}
// 创建一个map来缓存结果
const cache = new Map();
// 定义一个缓存版的斐波那契数列函数
function fibCached(n) {
// 如果map中已经有n对应的结果，直接返回
if (cache.has(n)) return cache.get(n);
// 否则，调用原始函数计算结果，并存入map中
const result = fib(n);
cache.set(n, result);
return result;
}
// 测试缓存版的函数
console.log(fibCached(10)); // 55
console.log(fibCached(20)); // 6765
console.log(fibCached(30)); // 832040
通过使用map来缓存结果，我们可以避免重复计算相同的输入，提高了函数的效率。
2. 使用set来去重数组
有时候，我们需要对一个数组进行去重操作，即删除数组中重复出现的元素。这时候，我们可以使用set来实现一个简单的去重方法。例如，下面的代码定义了一个去重函数，并使用一个set来存储已经出现过的元素：
// 定义一个去重函数
function unique(arr) {
// 创建一个set来存储已经出现过的元素
const seen = new Set();
// 创建一个空数组来存储去重后的结果
const result = [];
// 遍历原始数组中的每个元素
for (const item of arr) {
// 如果set中没有该元素，说明是第一次出现，将其加入set和结果数组中
if (!seen.has(item)) {
seen.add(item);
result.push(item);
}
// 否则，说明已经出现过，忽略该元素
}
// 返回结果数组
return result;
}
// 测试去重函数
console.log(unique([1, 2, 3, 3, 4, 4, 5]));
// [1, 2, 3, 4, 5]
console.log(unique(['a', 'b', 'c', 'c', 'd', 'd', 'e']));
// ['a', 'b', 'c', 'd', 'e']
通过使用set来去重数组，我们可以简化代码并提高效率。
3. 使用map和set来实现交集、并集和差集
有时候，我们需要对两个集合进行交集、并集和差集等运算。这时候，我们可以使用map和set来实现这些运算。
1、交集
// 创建两个 Set 对象
const setA = new Set([1, 2, 3, 4]);
const setB = new Set([3, 4, 5, 6]);
// 创建一个空的 Set 对象，用来存储交集
const intersection = new Set();
// 遍历 setA 中的元素
for (let element of setA) {
// 如果 setB 中也有该元素，则将其添加到交集中
if (setB.has(element)) {
intersection.add(element);
}
}
// 打印交集
console.log(intersection); // Set {3, 4}
2、并集
// 创建两个数组
const arr1 = [1, 2, 3, 4, 5];
const arr2 = [3, 4, 5, 6, 7];
// 创建一个空的 set 对象
const union = new Set();
// 遍历两个数组，把它们的元素都添加到 set 中
arr1.forEach(item => union.add(item));
arr2.forEach(item => union.add(item));
// 使用 Array.from () 方法或者扩展运算符 (...) 来把 set 转换成数组
const result = Array.from(union); // 或者 const result = [...union];
// 打印结果
console.log(result); // [1, 2, 3, 4, 5, 6, 7]
3、差集
// 创建两个set对象
let A = new Set([1, 2, 3, 4]);
let B = new Set([2, 4, 6]);
// 定义一个函数来计算差集
function difference(set1, set2) {
// 创建一个新的set对象
let result = new Set();
// 遍历set1
for (let item of set1) {
// 判断item是否在set2中存在
if (!set2.has(item)) {
// 如果不存在，则将其添加到result中
result.add(item);
}
}
// 返回result
return result;
}
// 调用函数并打印结果
console.log(difference(A, B)); // Set {1, 3}
console.log(difference(B, A)); // Set {6}
4、使用Map来统计数组中每个元素出现的次数
const arr = [1, 2, 3, 4, 5, 1, 2, 3, 4, 1];
const countMap = new Map();
arr.forEach(item => {
countMap.set(item, countMap.has(item) ? countMap.get(item) + 1 : 1);
});
console.log(countMap);
// Map(5) {1 => 3, 2 => 2, 3 => 2, 4 => 2, 5 => 1}
5、使用Set来判断两个数组是否有重复元素
const arr3 = [1, 2, 3, 4, 5];
const arr4 = [6, 7, 8, 9, 10, 1];
const set3 = new Set(arr3);
const set4 = new Set(arr4);
const hasDuplicate = arr4.some(item => set3.has(item));
console.log(hasDuplicate); // true
6、使用Map来实现缓存
const cacheMap = new Map();
function getData(key) {
if (cacheMap.has(key)) {
console.log('get data from cache');
return cacheMap.get(key);
} else {
console.log('get data from server');
const data = 'some data from server';
cacheMap.set(key, data);
return data;
}
}
console.log(getData('key1'));
// get data from server, some data from server
console.log(getData('key1'));
// get data from cache, some data from server
7、使用Map来实现对象的深拷贝
function deepClone(obj) {
const map = new Map();
function clone(obj) {
if (typeof obj !== 'object' || obj === null) {
return obj;
}
if (map.has(obj)) {
return map.get(obj);
}
const newObj = Array.isArray(obj) ? [] : {};
map.set(obj, newObj);
for (let key in obj) {
newObj[key] = clone(obj[key]);
}
return newObj;
}
return clone(obj);
}
const obj = {a: 1, b: {c: 2}};
const newObj = deepClone(obj);
console.log(newObj); // {a: 1, b: {c: 2}}
console.log(newObj.b === obj.b); // false
8、使用Set来进行数组去重并排序
const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5];
const uniqueSortedArr = [...new Set(arr)].sort((a, b) => a - b);
console.log(uniqueSortedArr);
// [1, 2, 3, 4, 5, 6, 9]
9、使用Map来进行数组去重并排序
const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5];
const uniqueSortedArr = [...new Map(arr.map(item => [item, item])).keys()].sort((a, b) => a - b);
console.log(uniqueSortedArr);
// [1, 2, 3, 4, 5, 6, 9]
评论区