目 录CONTENT

文章目录

【必看】前端JavaScript中Map和Set的应用技巧大揭秘!

萧瑟
2023-05-12 / 0 评论 / 13 点赞 / 354 阅读 / 3,932 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2023-07-03,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

image-1683882683492

在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]

weixin

13

评论区