What Is Memoization and Why Does It Matter?


Memoization is a programming approach that accelerates efficiency by caching the return values of costly operate calls. A “memoized” operate will instantly output a pre-computed worth if it’s given inputs that it’s seen earlier than.

Memoization is a particular type of caching that lends itself to situations the place a expensive operate is executed repeatedly, typically with the identical arguments. Provided that the operate is pure in order that it at all times produces the identical worth from a selected set of inputs, memoizing it could possibly enhance effectivity and cut back wasted CPU cycles.

You’ll most frequently encounter memoization in practical programming languages. The approach has broad utility, although. It’s an summary idea that you could incorporate into any recursive code. We’re utilizing JavaScript for this text, however you may rewrite the examples into your working language.

Table of Contents

A Simple Example

Here’s a easy operate that generates the factorial of a given integer:

const factorial = n => {
    if (n === 0) return 1;
    else return (factorial(n - 1) * n);

The factorial calculation is recursive, as factorial() calls itself throughout the else situation. The calculation can also be pure, as any given worth of n will at all times return the identical worth. factorial(5) is 120, regardless of the state of this system.

Because of the recursive nature of the operate, computing the factorial of a number of giant numbers incurs wasted operations:

const x = factorial(100);
const y = factorial(50);

All the calculations wanted to compute y have been already carried out as a part of the computation of x. If factorial() have been to cache its inputs and their corresponding outputs, the calculation of y could possibly be considerably sped up.

Memoizing the Factorial Function

Here’s a primary method that memoizes the factorial() operate:

const cache = {};
const factorial = n => {
    if (cache[n]) {
        return cache[n];
    let worth;
    if (n === 0) worth = 1;
    else worth = (factorial(n - 1) * n);
    cache[n] = worth;
    return worth;

Now, there’s a cache object that factorial() makes use of to report its output values. Each time the operate is named, it first checks whether or not it’s beforehand seen the enter n. If it has, it could possibly brief circuit instantly and return the cached worth. Otherwise, the recursive calculation proceeds as regular, however subsequent runs utilizing the identical quantity shall be sped up.

Now, computing factorial(50) after factorial(100) shall be vastly extra environment friendly. The factorial of 50 can be calculated as a part of the factorial of 100, so the operate might return the worth virtually instantaneously.

A More General Solution

While the above code works, it’s particular to the factorial() operate. If you have been utilizing different comparable features, you’d have to manually add the caching code to every one.

A extra basic resolution would allow you to wrap any operate with a higher-order operate that gives the memoizing functionality:

const memoize = fn => {
    const cache = {};
    return (...args) => {
        const argsString = JSON.stringify(args);
        if (!cache[argsString]) {
            cache[argsString] = fn(...args);
        return cache[argsString];

Now, you may modify the unique factorial() operate:

const factorial = memoize(n => {
    if (n === 0) return 1;
    else return (factorial(n - 1) * n);

By wrapping factorial() with memoize(), it good points computerized memoization capabilities. The wrapper operate returns a new operate that intercepts all calls to factorial(), stringifies their arguments, and checks whether or not they’ve been seen earlier than. If they’ve, the earlier return worth is reused with out calling the actual operate in any respect. When new arguments are seen, the operate will get invoked, and its output is added to the cache.

The wrapper makes use of the JavaScript rest parameters syntax to simply accept a variadic variety of arguments. This means that it’ll work with any JavaScript operate. This method is utilizing JSON.stringify() to create the string illustration of the arguments, so care must be taken in case you’re calling a operate with advanced objects, which may’t be totally represented as JSON.

When Not to Use Memoization?

Memoization can ship important efficiency enhancements, notably to mathematically heavy operations. It isn’t a method to make use of in every single place, although. Not all features must be memoized, as you may find yourself harming efficiency in some circumstances.

By wrapping a operate with memoize(), you’re forcing a comparability of the enter arguments every time that operate is named. This in itself will eat some CPU time. The instance wrapper above runs JSON.stringify() each time that the operate is named, including a brand new overhead.

Memoization is suitable for features the place there’s a excessive likelihood that the identical enter values shall be seen usually. If you’ll not often name a operate with the identical arguments, cache hits shall be rare, and you would possibly lose efficiency to argument serialization and comparability. Maintaining the cache additionally will increase reminiscence use, as all earlier inputs and outputs have to be retained.

You ought to, subsequently, totally assess every operate’s function in your program earlier than deciding to memoize. Compare efficiency with and with out memoization. Sometimes, it could possibly show extra helpful to depend on the browser’s personal optimizations.

Finally, keep in mind that some features can’t be memoized. The approach solely works with pure features—in case your operate reaches out to international variables or another software state, it shouldn’t be memoized!

const functionUsingGlobalState = n => {
    if (n === window.scrollY) return true;
    else return functionUsingGlobalState(n - 1);

Memoizing the operate above might yield sudden outcomes after the primary run. Values of n shall be cached utilizing the unique window.scrollY model. The memoization wrapper will return the cached output, even when window.scrollY has modified.


Memoization is a type of caching that accelerates the efficiency of repetitive recursive operations. It’s a practical programming approach that may be applied as a generic wrapper for any pure operate.

You’ll most frequently encounter memoization in steadily referred to as features that carry out computationally heavy operations. It helps keep away from waste by eradicating the necessity to recalculate values which have already been produced as a part of a earlier name.

The advantages of memoization shall be much less obvious in features which are easy to start with or sometimes referred to as. In some circumstances, improper use of memoization can really hurt efficiency, so don’t blindly memoize each operate in your software.

Source link

This Web site is affiliated with Amazon associates, Clickbank, JVZoo, Sovrn //Commerce, Warrior Plus etc.

Related Posts

Leave a Reply

Your email address will not be published. Required fields are marked *