javascript闭包如何构建记忆函数

闭包构建记忆函数的核心是利用闭包特性缓存已计算结果以提升性能。1. 通过 memoize 函数封装原函数，内部使用 cache 对象存储结果，参数序列化为键（如 json.stringify(args)），若缓存存在则直接返回，否则计算并缓存结果；2. 缓存键生成策略需根据参数类型选择：简单类型可拼接字符串，对象可基于唯一标识属性（如 id）生成，或使用自定义序列化函数或哈希库避免 json.stringify 在循环引用或顺序敏感时的问题；3. 闭包还可用于封装私有变量（如计数器）、实现模块化（封装私有成员）、保存函数状态（如带上下文的问候函数）；4. 记忆函数不适用于计算成本低、参数空间大、有副作用、可变参数顺序影响结果或缺乏缓存失效策略的场景；因此，记忆函数适用于高计算成本、小参数空间、无副作用的函数，使用前需权衡缓存开销与收益，并选择合适的键生成与缓存管理策略，以确保性能优化效果。

闭包构建记忆函数，简单来说，就是利用闭包记住已经计算过的结果，下次再算同样的值时，直接返回，不用重新计算，提高效率。

解决方案：

function memoize(func) {
  const cache = {}; // 缓存结果的地方

  return function(...args) {
    const key = JSON.stringify(args); // 将参数序列化成字符串作为key
    if (cache[key]) {
      return cache[key]; // 如果缓存中有，直接返回
    } else {
      const result = func.apply(this, args); // 否则，计算结果
      cache[key] = result; // 缓存结果
      return result; // 返回结果
    }
  };
}

// 例子：一个耗时的计算函数
function slowFibonacci(n) {
  if (n <= 1) {
    return n;
  }
  return slowFibonacci(n - 1) + slowFibonacci(n - 2);
}

// 使用记忆函数
const memoizedFibonacci = memoize(slowFibonacci);

console.time("First call");
console.log(memoizedFibonacci(10)); // 第一次调用，会计算
console.timeEnd("First call");

console.time("Second call");
console.log(memoizedFibonacci(10)); // 第二次调用，直接从缓存取
console.timeEnd("Second call");

这里

memoize

func

cache

cache

func

cache

立即学习“Java免费学习笔记（深入）”；

如何选择合适的缓存键值生成策略？

缓存键值生成策略直接影响记忆函数的效果。

JSON.stringify

JSON.stringify

JSON.stringify

可以考虑以下策略：

1. 简单类型参数： 如果参数都是数字、字符串等简单类型，可以直接拼接成字符串作为键值。

2. 对象类型参数： 如果参数是对象，可以根据对象的特定属性生成键值。确保这些属性能够唯一标识对象的逻辑状态。例如，如果对象有

   id

   登录后复制

   登录后复制
   属性，可以使用

   id

   登录后复制

   登录后复制
   作为键值。

3. 自定义序列化函数： 如果需要更复杂的序列化逻辑，可以自定义序列化函数，将参数转换为字符串或其他类型的键值。

4. 使用库： 可以使用现有的库来生成键值，例如

   hash-object

   登录后复制
   可以将对象转换为哈希值。

选择合适的策略需要根据实际情况进行权衡。

JSON.stringify

闭包除了缓存结果，还能做什么？

闭包的用途远不止缓存结果。 它还可以用于：

1. 封装私有变量： 闭包可以创建私有变量，防止外部直接访问和修改。 例如：

   function createCounter() {
     let count = 0; // 私有变量
   
     return {
       increment: function() {
         count++;
       },
       getCount: function() {
         return count;
       }
     };
   }
   
   const counter = createCounter();
   counter.increment();
   console.log(counter.getCount()); // 输出 1
   // counter.count // 无法直接访问 count

   登录后复制

2. 实现模块化： 闭包可以用于创建模块，将相关的变量和函数封装在一起。 例如：

   const myModule = (function() {
     let privateVar = "Hello";
   
     function privateFunction() {
       console.log(privateVar);
     }
   
     return {
       publicFunction: function() {
         privateFunction();
       }
     };
   })();
   
   myModule.publicFunction(); // 输出 "Hello"
   // myModule.privateVar // 无法直接访问 privateVar

   登录后复制

3. 保存状态： 闭包可以保存函数的状态，即使函数执行完毕，状态仍然存在。 例如：

   function createGreeter(greeting) {
     return function(name) {
       console.log(greeting + ", " + name + "!");
     };
   }
   
   const greetHello = createGreeter("Hello");
   greetHello("World"); // 输出 "Hello, World!"
   const greetHi = createGreeter("Hi");
   greetHi("There"); // 输出 "Hi, There!"

   登录后复制

记忆函数在哪些场景下不适用？

记忆函数虽然可以提高效率，但也并非适用于所有场景。以下是一些不适用的情况：

1. 计算成本低： 如果原始函数的计算成本很低，例如简单的加减运算，那么使用记忆函数带来的收益可能小于开销。因为缓存键值的生成、查找和存储也需要时间。

2. 参数空间大： 如果函数的参数空间非常大，例如参数是任意字符串，那么缓存可能会占用大量的内存。 此外，缓存命中率也会降低，导致效率提升不明显。

3. 副作用： 如果原始函数有副作用，例如修改全局变量或执行 I/O 操作，那么使用记忆函数可能会导致意外的结果。 因为记忆函数会缓存结果，导致副作用只执行一次，而不是每次调用都执行。

4. 可变参数： 如果函数接受可变参数，并且参数的顺序会影响结果，那么需要特别注意缓存键值的生成。

   JSON.stringify

   登录后复制

   登录后复制

   登录后复制

   登录后复制

   登录后复制
   可能无法正确处理这种情况。

5. 缓存失效策略： 如果没有合适的缓存失效策略，缓存可能会过期或占用过多的内存。 需要根据实际情况选择合适的缓存失效策略，例如 LRU (Least Recently Used) 或 LFU (Least Frequently Used)。

简而言之，记忆函数适用于计算成本高、参数空间小、没有副作用的函数。 在使用记忆函数之前，需要仔细评估其适用性，并选择合适的缓存策略。

以上就是javascript闭包如何构建记忆函数的详细内容，更多请关注php中文网其它相关文章！