lodash _.memoize cache retains entries indefinitely without eviction

Answer

No. lodash 4.x _.memoize does not provide any built‑in option to limit cache size or expire entries. The cache is a Map‑like object exposed as fn.cache that retains results until fn.cache.clear() is called or the Node process ends.

Confirmed facts

• The default cache key is the first argument; with a custom resolver the key is resolver(...args).
• fn.cache implements has, get, set, delete and clear. No size, TTL or LRU properties are exposed.
• Entries remain in the map indefinitely; growth is proportional to the variety of keys seen.

Likely explanation for unbounded growth

Because _.memoize stores only the result per key and does not track age, access order or cost, a long‑running service that sees many distinct arguments (especially user‑controlled or high‑cardinality values) will accumulate entries without bound, potentially exhausting memory.

Manual eviction pattern that preserves correct memoization

1. Determine the key exactly as _.memoize does: default = first argument; custom resolver = resolver(...args).
2. To remove a single entry call fn.cache.delete(key). To clear the whole cache call fn.cache.clear().
3. Perform the deletion outside the memoized function, triggered by an invalidation event or a time boundary, so the next invocation recomputes and repopulates the cache correctly.

// Example with a custom resolver
const resolver = (a, b) => `${a}:${b}`;
const memo = _.memoize(fn, resolver);

// Evict one combination
memo.cache.delete(resolver('user123', 'actionX'));

When unbounded retention may be acceptable

Unbounded _.memoize is acceptable only if the argument space is low‑cardinality and stable (e.g., a fixed set of configuration values) and the keys are not supplied by external users. For high‑cardinality or user‑controlled inputs, an external size‑limited cache or a wrapper that enforces a max size/TTL is recommended.

Verification steps

• Check lodash version: require('lodash/package.json').version should start with "4.".
• Inspect _.memoize(() => {}).cache for has, get, set, delete, clear and confirm absence of size/TTL options.
• Call the memoized function twice with the same argument to confirm a single execution, then fn.cache.delete(arg) and call again to confirm a second execution.

To decide whether manual eviction suffices for your low‑traffic service, please confirm whether the memoized function receives high‑cardinality or user‑controlled arguments.