Итак, я только что открыл для себя эту интересную концепцию мемоизации.

Я начал читать статью об этом и остановился, как только уловил суть идеи.

Тогда я решил найти простое решение самостоятельно и так, как я его понимаю.

Если вы никогда об этом не слышали, мемоизация — это процесс сохранения результатов выполнения функции, поэтому вы можете извлечь их из небольшого (или не очень) кеша в следующий раз, когда вы запустите эту функцию с теми же аргументами.

На самом деле это может быть полезно для функции, потребляющей большие ресурсы. Это связано с затратами на использование дополнительного места в качестве кэша. Но это может улучшить скорость вашего кода и удобство для пользователей, которые его используют.

Я немного поигрался с 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). Третий вызов «добавить» будет использовать кеш, так как он аналогичен вызову №2.

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

Вы можете видеть, что «функция выполняется» 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]
  };
}

И все.

Теперь я пойду посмотрю, как это надо делать "правильно". Но если вам это интересно, дайте мне знать. Если что-то неясно или не так в этом подходе (на ваш вкус), просто оставьте комментарий и давайте поговорим об этом.

Спасибо, увидимся!