How to memoize with Map()

Question

I am currently stuck on a problem with the memoize function in JavaScript. The last 2 tests don't pass. I will be more then happy for assistance.

The problem is the following:

Write a memoize function that takes in a required callback function and an optional resolver function. The memoize function returns a memoized version of the callback function, which is defined as follows:
All of the return values of the memoized function are cached. If the memoized callback is called with an existing cache key (defined below), then that cached value is returned without invoking the callback again.
The cache key is defined based on the optional resolver function. If a resolver function is not provided, then the cache key is the result of passing the memoized function arguments to JSON.stringify as an array. If a custom resolver function is provided, then the arguments should be individually passed to that function instead, and its return value will be the cache key (note that this can be of any type).
The memoized function should also have three methods: clear(): Clears out the cache. delete(...args): Deletes the cache entry corresponding to the passed arguments if one exists. has(...args): Returns a boolean of true if the cache has an entry corresponding to the passed arguments, otherwise false. For simplicity, you don't need to worry about binding a this context (i.e., you can assume that the callback doesn't reference this).

The callback function look like this:

const callback = (...args) => args;

And this is the input and the result that should be returned

const memoized = memoize(callback);
memoized(123); // calls callback, returns 123
memoized(123); // returns 123
memoized(123, 'abc'); // calls callback, returns [123, 'abc']

const memoized2 = memoize(callback, args => args[0]);
memoized2(123); // calls callback, returns 123
memoized2(123); // returns 123
memoized2(123, 'abc'); // returns 123
memoized('abc', 123); // calls callback, returns ['abc', 123]
memoized2('abc'); // returns ['abc', 123]

I've stored all arguments in cache and when the same argument is called the result will be returned from cache.

This is my code

function memoize(cb) {
    const memo = new Map();

    return function (...args) {
        const key = JSON.stringify(args);
        if (!memo.has(args)) {
            memo.set(key, cb(...args));
            return memo.get(key);
        }
        return memo.get(key);
    };
}

And this are the tests

const chai = require("chai");
const spies = require("chai-spies");
const { expect } = chai;

chai.use(spies);
const spy = () => chai.spy(() => {});

const { memoize } = require("../memoize.js");

describe("memoize", () => {
    it("callback without parameters is never called twice", () => {
        const callback = spy(() => {});
        const memoized = memoize(callback);
        expect(callback).to.have.been.called.exactly(0);
        memoized();
        expect(callback).to.have.been.called.exactly(1);
        memoized();
        expect(callback).to.have.been.called.exactly(1);
        memoized();
        memoized();
        expect(callback).to.have.been.called.exactly(1);
    });

    it("callback with a single parameter is handled properly", () => {
        const callback = spy((val) => val * 2);
        const memoized = memoize(callback);
        expect(callback).to.have.been.called.exactly(0);
        const val1 = memoized(1);
        expect(callback).to.have.been.called.exactly(1);
        expect(val1).to.equal(2);

        const val2 = memoized(1);
        expect(callback).to.have.been.called.exactly(1);
        expect(val2).to.equal(2);

        const val3 = memoized(2);
        expect(callback).to.have.been.called.exactly(2);
        expect(val3).to.equal(4);

        const val4 = memoized(2);
        expect(callback).to.have.been.called.exactly(2);
        expect(val4).to.equal(4);

        const val5 = memoized(1);
        expect(callback).to.have.been.called.exactly(2);
        expect(val5).to.equal(2);
    });

    it("has function works as expected", () => {
        const callback = spy((...args) => args);
        const memoized = memoize(callback);

        expect(memoized.has()).to.be.false;
        expect(memoized.has(123)).to.be.false;
        expect(memoized.has(123, "abc")).to.be.false;

        memoized();
        expect(memoized.has()).to.be.true;

        memoized(123);
        expect(memoized.has(123)).to.be.true;

        memoized(123, "abc");
        expect(memoized.has(123, "abc")).to.be.true;

        expect(callback).to.have.been.called.exactly(3);
    });
});

How to memoize with Map()

0 Answers