含义：缓存函数是指将上次的计算结果缓存起来，当下次调用时，如果遇到相同的参数，就直接返回缓存中的数据。

下面是一个简单的示例，演示如何使用Memoization来缓存函数的计算结果

function expensiveOperation(n) {
  console.log("Performing expensive operation...");
  // 模拟耗时的计算
  let result = 0;
  for (let i = 0; i < n; i++) {
    result += i;
  }
  return result;
}

function memoize(func) {
  const cache = {};
  return function (n) {
    if (n in cache) {
      return cache[n];
    }
    const result = func(n);
    cache[n] = result;
    return result;
  };
}

const memoizedExpensiveOperation = memoize(expensiveOperation);

console.log(memoizedExpensiveOperation(5)); // 第一次调用，执行计算
console.log(memoizedExpensiveOperation(5)); // 从缓存中直接返回结果
console.log(memoizedExpensiveOperation(10)); // 第一次调用，执行计算
console.log(memoizedExpensiveOperation(10)); // 从缓存中直接返回结果

在上面的示例中，我们定义了一个名为expensiveOperation的函数，它代表一个耗时的计算操作。然后，我们使用memoize函数对expensiveOperation进行包装，返回一个记忆化的版本memoizedExpensiveOperation。

memoize函数接受一个函数作为参数，内部创建了一个缓存cache，用于存储已计算过的结果。返回的函数使用闭包，可以访问外部的cache变量。

每次调用memoizedExpensiveOperation时，它会首先检查n是否存在于缓存中。如果存在，则直接返回缓存的结果；如果不存在，则调用原始函数expensiveOperation进行计算，并将结果存入缓存中。

通过使用Memoization，第一次调用memoizedExpensiveOperation时会执行耗时的计算操作，并将结果存入缓存。之后相同的参数调用时，函数会直接从缓存中获取结果，避免重复计算。

这样可以大大提高函数的执行效率，特别是对于计算密集型的操作或者需要频繁调用的函数，Memoization可以显著减少计算时间。

案例：求斐波那且数列

// 不用memoize的情况下，会执行453次
var count = 0var fibonacci = function(n) {
  count++
  return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2)}
  for (var i = 0; i <= 10; i++) {
  fibonacci(i) //453}
  console.log(count)
  // 用memoize的情况下，会执行12次
  var memoize = function(func, hasher) {
  var memoize = function(key) {
    var cache = memoize.cache    
    var address = '' + (hasher ? hasher.apply(this, arguments) : key)
    //创建了一个address变量，用于存储缓存的键值。如果提供了hasher函数，则调用hasher函数生成键值；
    //否则，直接使用key作为键值。
    if (!cache[address] || (typeof cache[key] === 'number' && !!cache[key])) {
      cache[address] = func.apply(this, arguments)
    }
    return cache[address]
  }
  memoize.cache = {}
  return memoize
  }
  fibonacci = memoize(fibonacci)
  for (var i = 0; i <= 10; i++) {
      fibonacci(i) //453 12
  }//缓存函数能应付大量重复计算，或者大量依赖之前的结果的运算场景
  console.log(count) //12