Memoization and Caching: Are they the same in JavaScript?

At first glance, Memoization and Caching might seen like the same thing. After all, both techniques involve saving results to avoid doing the same work again. But while they are related, they're not exactly the same and understanding the difference between them will make you have a strong fundamentals. In this post, we'll break down what memoization and caching really are, compare them side by side and walk through practical examples so you'll never confuse them again. What is Memoization? Memoization is a specific form of caching that's focused on functions. It stores the result of a function based on its inputs arguments. If the function is called again with the same arguments, the stores result is returned instead of running the function again. It's typically used for: Pure Functions (functions that always return the same output for the same input); Expensive calculations that are repeated often; Variables in outer functions that are preserved through closures (e.g., for storing cached values); It usually stores values in memory, like in a plain object or closure. What is Caching? Caching is a broader concept. It referes to storing any kind of data so it can be accessed faster in the future, not just functions results. It's used everywhere API responses; Database query results; Images, files, computed reports; Session data, user info, etc; And it can be stored anywhere: In memory; In a Redis store; In the browser (localStorage, indexedDB); On disk Key differences Feature Memoization Caching Scope Function-level Global / application-level Purpose Store function results Store any reusable data Based On Function arguments Keys like URL, ID, custom cache key Typical Storage In-memory (object or closure) Memory, Redis, disk, browser Use Cases Recursive calculations, pure logic API calls, DB queries, static files Invalidation Rare (input-based) TTL, manual purge, cache strategy needed Example factorial(n), fibonacci(n) Cached API response by user ID Memoization in code Let's look at a simple example using the factorial function, which is a great case for memoization because each result depends on the previous one. Without Memoization: function factorial(n) { if (n

Apr 1, 2025 - 03:17

Memoization and Caching: Are they the same in JavaScript?

At first glance, Memoization and Caching might seen like the same thing. After all, both techniques involve saving results to avoid doing the same work again. But while they are related, they're not exactly the same and understanding the difference between them will make you have a strong fundamentals.

In this post, we'll break down what memoization and caching really are, compare them side by side and walk through practical examples so you'll never confuse them again.

What is Memoization?

Memoization is a specific form of caching that's focused on functions. It stores the result of a function based on its inputs arguments.

If the function is called again with the same arguments, the stores result is returned instead of running the function again.
It's typically used for:

Pure Functions (functions that always return the same output for the same input);
Expensive calculations that are repeated often;
Variables in outer functions that are preserved through closures (e.g., for storing cached values);

It usually stores values in memory, like in a plain object or closure.

What is Caching?

Caching is a broader concept. It referes to storing any kind of data so it can be accessed faster in the future, not just functions results.

It's used everywhere

API responses;
Database query results;
Images, files, computed reports;
Session data, user info, etc;

And it can be stored anywhere:

In memory;
In a Redis store;
In the browser (localStorage, indexedDB);
On disk

Key differences

Feature	Memoization	Caching
Scope	Function-level	Global / application-level
Purpose	Store function results	Store any reusable data
Based On	Function arguments	Keys like URL, ID, custom cache key
Typical Storage	In-memory (object or closure)	Memory, Redis, disk, browser
Use Cases	Recursive calculations, pure logic	API calls, DB queries, static files
Invalidation	Rare (input-based)	TTL, manual purge, cache strategy needed
Example	`factorial(n)`, `fibonacci(n)`	Cached API response by user ID

Memoization in code

Let's look at a simple example using the factorial function, which is a great case for memoization because each result depends on the previous one.

Without Memoization:

function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}

console.log(factorial(5)); // 120
console.log(factorial(5)); // Recalculates everything again

With Memoization:

function memoizedFactorial() {
  const cache = {};

  return function factorial(n) {
    if (n in cache) {
      console.log('From cache:', n);
      return cache[n];
    }

    if (n <= 1) return 1;

    const result = n * factorial(n - 1);
    cache[n] = result;
    return result;
  };
}

const factorial = memoizedFactorial();

console.log(factorial(5)); // Calculated
console.log(factorial(5)); // Cached!
console.log(factorial(6)); // Uses cached factorial(5)

This shows how we avoid redundant work by reusing previous results.

Caching in code (Example with Redis)

Now let's say we have a function that fetches user data, possibly expensive if it hits a DB or API.
Instead of recalculating or re-fetching it every time we cache it using Redis.

async function getUser(userId) {
  const key = `user:${userId}`;
  const cached = await redis.get(key);

  if (cached) {
    console.log('Returned from Redis cache');
    return JSON.parse(cached);
  }

  const user = await fetchUserFromDB(userId);
  await redis.set(key, JSON.stringify(user), 'EX', 60); // Cache for 60s
  return user;
}

This is not memoization, but it is caching. It's not tied directly to a function's input/output relationship in memory. It's stored in an external cache layer and used across multiple calls.

When to Use Each

Use memoization when:

You're working with pure functions;
You want to optimize repeated calculations;
You don't want to introduce external storage (just use in-memory);

Use caching when:

You want to store data fetched or computed from external sources;
You need to share results between processes or requests;
You need expiration, invalidation or disk/network-level persistence;

Final thoughts

Memoization and caching are related but they solve different problems.

Memoization is about functions calls: if I call this again with the same input, don't recompute it.
Caching is about data reuse: if I already fetched this, let's avoid doing it again.

Quick recap:

Memoization is a type of caching;
All memoization is caching, but not all caching is memoization;
Both can drastically improve performance if used in the right context;

Console You Later!