Small tree-based memoization module that handles any number of arguments (by reference). Slower than _.memoize (especially for multiple args), but with the advantage of computing keys based on all function arguments, not just the first.

memoize.js

const value = Symbol('value')

const retrieve = (node, path) => {
  for (let i = 0; i < path.length; i++) {
    const key = path[i]
    if (node.has(key)) {
      node = node.get(key)
    } else {
      const child = new Map()
      node.set(key, child)
      node = child
    }
  }
  return node
}

const memoize = (fn) => {
  let cache = new Map()
  let size = 0

  function memoized (...args) {
    const node = retrieve(cache, args)
    // if key is in cache, return cached previous result
    if (node.has(value)) return node.get(value)
    // otherwise perform expensive function, cache result and return
    const result = fn.apply(this, args)
    node.set(value, result)
    return result
  }
  // expose cache (e.g. to allow manual clearing)
  Object.defineProperty(memoized, "cache", {
    get: () => cache,
  })
  return memoized
}

export default memoize

https://jsperf.com/memoize-ref-stringify-lodash