永远不要调用同一个函数两次（使用记忆化）

我开始阅读关于它的文章，一抓住这个概念的尾巴就停下来了。

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

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

在现实中，这对于消耗大量资源的函数可能很有用。它伴随着使用额外空间作为缓存的成本。但它可以提高您的代码速度和使用它的用户的体验。

我稍微摆弄了一下 JavaScript 代码，得出了这个解决方案：

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("函数运行", x, y);
  return x + y;
}
​
const add = memoize(_add)
​
add(42, 69)
add(10, 15)
add(10, 15)

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

'函数运行' 42 69
'函数运行' 10 15

您可以看到 '函数运行' 10 15 只被调用了一次。这是因为第二次调用它时，使用了缓存。

现在让我们快速分解一下这里发生了什么。

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

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

这使我们能够抛出“fn”参数，它是这个过程的关键，因为这正是我们想要操作的函数，通过作用域并“监听”它的每次执行。

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

这意味着，执行：

add(2, 2)

结果是

// 我们的缓存
{
  'add(2, 2)': 4
}

缓存值。

我知道这可能不是“正确方式”应该做的。但这个练习和文章的重点不是经过良好测试、安全且无边界情况的解决方案。

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

现在，我们首先找出函数调用的键：

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

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

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

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

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

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

就是这样。

现在我要去看看应该如何“正确地”做。但如果您觉得这很有趣，请告诉我。如果这种方法有什么不清楚或不对（根据您的口味），只需留下评论，我们来讨论。