Memoization Patterns & Pure Function Optimization

01The Prerequisite of Pure Functions

Memoization is an optimization technique that speeds up computer programs by caching the results of expensive function calls and returning the cached result when the exact same inputs occur again. However, you cannot memoize arbitrary functions. Memoization is mathematically valid only for pure functions.

A pure function satisfies two axioms: deterministic output (given the exact same arguments, it always returns the exact same result) and zero side effects (it does not mutate external variables, perform network I/O, write to disk, or rely on hidden state like Date.now() or Math.random()). If a function relies on changing external data, memoizing it will return stale, incorrect results.

02Implementing a Robust Memoize Utility

A memoize function is a higher-order function that wraps a target function in a closure containing a private cache dictionary (a Map or plain Object). When the decorated function is called, it computes a cache key from its arguments.

If the cache key exists in the Map, the function immediately returns the stored value, bypassing the computation completely (O(1) lookup). If the key is absent, it executes the target function, stores the result in the cache, and returns it.

The linchpin of any memoization algorithm is cache key serialization. If a pure function accepts simple primitive numbers or strings, generating a cache key is trivial (e.g. JSON.stringify(args) or a template string).

However, if the function accepts complex object references, serializing large objects with JSON.stringify creates massive CPU overhead that can easily dwarf the execution time of the function itself! For object arguments, advanced memoizers utilize nested WeakMaps, using object identity directly as keys to achieve true O(1) cache lookups with zero string serialization costs.

03The Unbounded Cache Trap and LRU Eviction

In production environments, naive memoization is a notorious vector for memory leaks. If your application serves millions of distinct requests and memoizes every result in an unbounded Map, the cache will grow indefinitely until the Node.js process exhausts its heap and crashes with an Out-Of-Memory (OOM) error.

To safeguard production systems, professional memoizers enforce a maximum capacity using Least Recently Used (LRU) cache eviction. When the cache reaches its threshold, the oldest, least-recently accessed entry is evicted, capping memory consumption at a predictable, fixed upper bound.

04Why This Matters in Production

Memoization powers state selector engines like Reselect in Redux, memo() in React, and expensive recursive algorithms in graph analysis. Knowing when to memoize is just as important as knowing how: memoizing trivial operations like a + b actually degrades performance due to the overhead of stringifying arguments and performing Map lookups.

Reserve memoization for computationally expensive mathematical routines, complex array transformations over large datasets, or repeated regex compilation where the savings vastly outweigh the cache management overhead.