所以我刚刚发现了这个有趣的记忆化小概念。

我已经开始阅读有关它的文章，当我抓住这个想法的尾巴时就停止了。

然后我决定以我自己的方式并以我理解的方式找出简单的解决方案。

如果您从未听说过，记忆是存储函数执行结果的过程，因此您可以在下次使用相同参数运行该函数时从一个小（或不那么大）缓存中提取它。

实际上，这对于高资源消耗的功能很有用。它伴随着使用额外空间作为缓存的成本。但它可以提高代码的速度以及使用它的用户的体验。

我玩了一下 JS 代码并提出了这个解决方案：

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
    if(!cache[fnKey]) {
      cache[fnKey] = fn(...args);
    }

    return cache[fnKey]
  };
}

然后你可以像这样运行它：

function _add(x, y) {
  console.log("function runs", x, y);
  return x   y;
}

const add = memoize(_add)

add(42, 69)
add(10, 15)
add(10, 15)

这会导致函数执行两次（#1 和 #2 'add' 调用）。第三个“添加”调用将使用缓存，因为它与#2 调用相同。

'function runs' 42 69
'function runs' 10 15

可以看到'function running' 10 15只被调用了一次。这是因为我们第二次调用它时，缓存正在被使用。

现在让我们快速分解一下这里发生的事情。

在这个例子中我们利用闭包机制来存储缓存。

const memoize = fn => {
  const cache = {}
  return () => {

  };
}

这允许我们抛出“fn”参数，这是最重要的，因为这正是我们想要操作的函数，向下作用域并“监听”它的每个执行。

我确实是用最简单、最天真的方式写的。因此，我们将使用带有参数的函数名称作为缓存的键，并将其执行结果作为值。

这意味着，执行：

add(2, 2)

结果为

// Our cache
{
  'add(2, 2)': 4
}

缓存值。

我知道这可能不完全是“正确的方式”。但这个练习和这篇文章的想法并不是关于经过充分测试的安全和无边缘情况的解决方案。

这是关于学习和简单的实施。关于概念。所以我现在不关注实施细节。

现在，我们首先弄清楚函数调用的关键：

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
  };
}

我们将使用它来将函数执行的结果存储在缓存中。

然后我们检查这个键（fnKey）是否已经存在。如果没有，我们将键及其值设置为传递的函数执行的结果。

最后我们总是从缓存中返回结果。因此，传递给 memoize 方法的函数的执行实际上总是以闭包结束（在“缓存”对象中）。

我们现在只操作这个对象：

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
    if(!cache[fnKey]) {
      cache[fnKey] = fn(...args);
    }

    return cache[fnKey]
  };
}

就是这样。

现在我要去看看应该如何“正确”地完成它。但如果您觉得这很有趣，请告诉我。如果这种方法有任何不清楚或错误的地方（根据您的口味），请删除评论，让我们讨论一下。

谢谢，再见！