Using JavaScript In-Memory Caching

In-memory caching is a powerful tool that optimizes the speed and performance of applications by storing data in memory. This article will explain how to implement this using JavaScript. It is assumed that you already have a basic understanding of JavaScript. If not, I would recommend taking a JavaScript course before proceeding.

What is In-Memory Caching?

In-memory caching is a way to store data that needs to be frequently accessed in memory (RAM) instead of a disk-based storage system. This method significantly reduces the time it takes for a program to access this data because memory access is faster than disk access. Examples of common use-cases for in-memory caching include: repeated database queries, repetitive computations, or heavy configuration files.

Advertisement

In JavaScript, in-memory caching can be implemented by storing data in a variable or data structure. However, this basic form of caching only persists as long as the program is running. For a more robust and persistent caching solution, we may need to use an external service like Redis.

How to Implement In-Memory Caching in JavaScript

Consider a function that calculates the factorial of a number. The factorial function performs many calculations, especially for large numbers. By implementing caching, we can reduce the number of calculations by storing previously computed results.

Here is the function without caching:

function factorial(n) {
  if (n === 0 || n === 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

Every time this function is called, it calculates the factorial of a number. Let’s introduce in-memory caching.

let cache = {};

function factorial(n) {
  if (n === 0 || n === 1) {
    return 1;
  } else if (cache[n]) {
    return cache[n];
  } else {
    let result = n * factorial(n - 1);
    cache[n] = result;
    return result;
  }
}

In the second example, we first check if the result is already in the cache. If it is, we return it directly, avoiding the calculation. If the result isn’t in the cache, we calculate it, store it in the cache, and return it.

This simple example illustrates how in-memory caching can save processing time for repeated function calls.

Advanced Caching with Node.js and Redis

Node.js applications are perfect candidates for in-memory caching due to their event-driven, non-blocking nature. Redis is a popular in-memory data structure store used as a database, cache, and message broker. Here’s how to set up a basic cache system using Redis and Node.js.

First, install Redis on your system. The installation process depends on your operating system. After Redis is installed, you can interact with it in your Node.js application using the redis NPM package.

npm install redis

Here’s a simple example of how to cache API responses using Redis:

const express = require('express');
const redis = require('redis');

const app = express();
const client = redis.createClient();

client.on('error', (err) => {
  console.log("Error " + err)
});

app.get('/data', (req, res) => {
  const dataId = req.query.id;

  // Try fetching the result from Redis first in case we have it cached
  client.get(dataId, async (err, result) => {
    // If that key exists in Redis store
    if (result) {
      return res.json({ source: 'cache', data: JSON.parse(result) })
    } else { // Key does not exist in Redis store
      // Fetch directly from API
      const data = await fetchApi(dataId);
      // Save the API response in Redis store, data expire time in 3600 seconds, i.e. one hour
      client.setex(dataId, 3600, JSON.stringify(data));
      // Send API response in JSON format
      return res.json({ source: 'api', data: data });
    }
  });
});

const PORT = process.env.PORT || 5000;
app.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`);
});

async function fetchApi(dataId) {
  // Fetching data logic here
}

In this example, when a GET request is made to the /data route with an id as a query parameter, we first try to retrieve the corresponding data from the Redis store. If the data is found, it is returned to the client along with a message indicating that the data came from the cache. If the data is not found in the Redis store, it is fetched from the API, stored in Redis for future access, and then returned to the client.

Conclusion

In-memory caching is a powerful technique that can significantly improve the performance of your JavaScript applications. It reduces the need for expensive operations like database queries or API calls by storing data in memory for quick access. As we have seen, caching can be implemented in pure JavaScript for individual function calls, or it can be used in larger applications with the help of external services like Redis.

Remember, caching is not a silver bullet. It comes with its own set of trade-offs, such as increased memory usage and complexity. However, used correctly, caching can provide significant benefits to many applications.