Следующий код взят из исходного кода Jest:

function _path() {
  const data = _interopRequireDefault(require('path'));

  _path = function _path() {
    return data;
  };

  return data;
}

Почему у нас есть указанное выражение функции посередине? Как и когда можно было использовать этот паттерн?

1
Fellow Stranger 30 Мар 2019 в 12:38

1 ответ

Лучший ответ

Внешняя функция называется _path. Затем внутри него строка _path = function _path() перезаписывает переменную _path (в настоящее время присвоенную функции _path) другой функцией, называемой _path.

Итак, при выполнении функция перезаписывает себя новой функцией, которая будет делать другое. Вот простая иллюстрация этого принципа:

function f() {
  console.log("outer");
  f = function f() {
    console.log("inner");
  }
}

f(); //outer
f(); //inner
f(); //inner

Итак, это то, что он делает. Что касается зачем это делается - кеширование. Ему нужно только один раз найти / вычислить значение, а затем каждое другое выполнение будет кэшировано. Итак, вот пример, в котором lookup является фиктивной заменой сетевой операции.

function lookup() {
  console.log("making a network call");
  return 4;
}

function f() {
  var output = lookup();

  f = function f() {
    return output;
  }
  
  return output;
}

console.log(f()); //network call -> 4
console.log(f()); //4
console.log(f()); //4

То же самое можно сделать с тяжелыми вычислениями, которые не требуют сетевого вызова - вместо того, чтобы повторять вычисления и каждый раз использовать циклы ЦП, результат можно вычислить только один раз.

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

Обычно этот метод называется мемоизацией. Примечание: это правильное написание, нет r . Хотя сомневаюсь, что кто-то запутается, если вы его вставите.

В любом случае мемоизация включает в себя вычисление функции один раз и возврат результата только через раз. Общий подход состоит в том, чтобы иметь функцию memoize, которой вы можете украсить другие функции. Вот пример реализации:

function memoize(func) {
  //keep a cache for all results
  const cache = {};
  
  //make a new function
  const memo = function() {
    //get the arguments from the input
    var key = JSON.stringify(...arguments);

    let result;
    if (cache.hasOwnProperty(key)) {
      //get result from cache
      result = cache[key];
    } else {
      //calculate the result and put it in the cache
      result = func(...arguments);
      cache[key] = result;
    }

    return result;
  }
  
  return memo;
}

function lookup(data) {
  console.log("network call");
  return data + 4;
}

function calculate(data) {
  console.log("heavy operation");
  return data + 2;
}

let memLookup = memoize(lookup);
console.log(memLookup(4)); //network call -> 8
console.log(memLookup(4)); //8
console.log(memLookup(6)); //network call -> 10
console.log(memLookup(6)); //10

let memCalculate = memoize(calculate);
console.log(memCalculate(4)); //heavy operation -> 6
console.log(memCalculate(4)); //6
console.log(memCalculate(6)); //heavy operation -> 8
console.log(memCalculate(6)); //8
6
VLAZ 30 Мар 2019 в 10:10