How to memoize function so same arguments returns from cache

Question

I have a slow function

function f(a, b, c) {
}

I call this function with same arguments sometimes, it will return the same result. I want to cache this function call with arguments, so second call with same arguments returns from cache.

I tried this but it doesn't work.

export function memoize(fn) {
  let cache;
  let res;
  return function(...args) {
    if (!cache) {
      cache = args;
      res = fn(...args);                                                                                                                      return res;
    }
    if (objectCompare(args, cache)) {
      return res;                                                                                                                           }
    return res = fn(...args);
  };
}

How exactly does it not work? Use a [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) or object, serialize the arguments as JSON, use the arguments as keys and the outputs as values, then look up the keys. — Sebastian Simon, Aug 04 '19 at 17:58
had you have a look to this question: https://stackoverflow.com/questions/54077182/memoize-a-currified-function — Nina Scholz, Aug 04 '19 at 18:02
you could curry the function first and then take the memorizing function. — Nina Scholz, Aug 04 '19 at 18:07
@eguneys _“that works for single arguments”_ — you could just use `JSON.stringify([a, b, c])` as a key, if `a`, `b` and `c` are JSON-serializable. — Sebastian Simon, Aug 04 '19 at 18:09
It looks like an ugly hack but i will do it. @SebastianSimon — eguneys, Aug 04 '19 at 18:20
Please tell us *how* your code does not work. What function did you memoise, how did you call it, what happened that you were not expecting? — Bergi, Aug 04 '19 at 19:56

Nir Alfasi · Accepted Answer · 2019-08-05T03:34:15.457

In order to use a cache we need to map the arguments to the result. Since you have multiple parameters, you'll need to generate a unique key for these parameters. For example, in case you have 3 parameters: a, b, c - you can create a key: \${a}-${b}-${c}`` (this is just an example, the only important thing is that this key will be unique!).

Demo (see code-comments for additional explanations):

function f(a, b, c) {
    return a + b + c; // for example
}

const memoized = (function(fn) {    // we'll wrap the original function
    const cache = {}; // init a cache
    return (a, b, c) => {
        const key = `${a}-${b}-${c}`; // create a key
        if (cache.hasOwnProperty(key)) { // search if it's already saved in the cache
            console.log('in memory');
            return cache[key];
        }
        console.log('calculating...');
        const res = fn.apply(this, [a, b, c]); // since it's not in the cash - calculate the result
        cache[key] = res; // now before we'll return the result - save it in the cache for next calls
        return res;
    };
})(f); // apply the memoization to the original function

memoized(1, 2, 3); // will print "calculating..." and return the result
memoized(1, 2, 3); // will print "in memory" and return the result

You should use `if (cache.hasOwnProperty(key))` instead of `if (cache[key])`. Your current code never memoizes falsely values (false, undefined, null, 0, "", etc). — Nate, Aug 05 '19 at 03:31

How to memoize function so same arguments returns from cache

1 Answers1