¿Cómo acceder a los datos de caché en Node.js?

Caché: el almacenamiento en caché es una técnica utilizada para mejorar el rendimiento de los servidores y muchos dispositivos utilizados en el día a día.
En el almacenamiento en caché, el resultado de cierto cálculo o tarea se almacena en algún lugar, y si se requiere el mismo cálculo nuevamente, se sirve desde esa ubicación en lugar de realizar el cálculo nuevamente. Esto reduce el cálculo y mejora el rendimiento, proporcionando así una mejor experiencia de usuario.
Muchas aplicaciones almacenan datos en caché la primera vez que se activan, por lo que pueden proporcionar respuestas de manera eficiente. De manera similar, la mayoría de los servidores tienen mecanismos avanzados de almacenamiento en caché para puntos finales que brindan la misma respuesta la mayor parte del tiempo.

El caché se puede almacenar utilizando varias técnicas, como caché en memoria, caché de archivos o una base de datos de caché separada.
Este artículo demuestra el uso del almacenamiento en caché en Node.js mediante el paquete node-cache, que es un módulo de almacenamiento en caché en memoria.

Implementando una demostración de caché usando node-cache.

Crear un servidor js de Node básico. Construyendo API REST de nodejs simple usando express

Asegúrese de que el Node esté instalado mediante el siguiente comando:

node -v

Navegue al directorio del proyecto deseado e instale express (para crear un servidor) y paquetes npm de caché de Node usando el siguiente comando:

npm i express node-cache

Estructura del proyecto:

Ejemplo: Cree un archivo server.js en el directorio con el siguiente código:

// Importing express module
const express = require('express')
    
// Creating an express object
const app = express()
    
// Starting server using listen function on port 8000
app.listen(8000, err => { 
   if(err) 
        console.log("Error while starting server")
   else
        console.log("Server has been started at port 8000")
})
  
app.get('/', (req, res)=>{
    res.send('Home page !')
})

Ejecute el siguiente comando:

node server.js

Salida: Abra el enlace: http://localhost:8000/ en el navegador deseado para verificar

Página de inicio

Cree una API simple que realice una operación costosa para brindar una respuesta (para simular una consulta externa de API/base de datos).

Agregue el siguiente código al final de server.js

function heavyComputation(){
     let temp = 0;
     for(let i=0; i<100000; i++)
          temp = (Math.random()*5342)%i;
     return 123;
}
  
app.get('/api', (req, res)=>{
     let result =  heavyComputation();
     res.send("Result: "+result);
})

Detenga el servidor con Ctrl+C y comience de nuevo con node server.js . 
En el navegador, abra la pestaña Red en Chrome Dev Tools y verifique el tiempo requerido para obtener una respuesta.

Implementar node-cache: importar el módulo npm de Node-cache y crear un nuevo objeto NodeCache

const NodeCache = require( "node-cache" );
const myCache = new NodeCache();

Node-cache tiene las siguientes funciones principales:

• .set(key, val, [ttl]): Se usa para establecer algún valor correspondiente a una clave en particular en el caché. Esta misma clave debe usarse para recuperar este valor.
• .get(clave): Se usa para obtener el valor establecido en la clave especificada. Devuelve indefinido, si la clave aún no está presente.
• has(key): se usa para verificar si el caché ya tiene algún valor establecido para la clave especificada. Devuelve verdadero si está presente, de lo contrario, es falso.

Implemente el almacenamiento en caché con el siguiente enfoque:

• En la solicitud de API, verifique si el caché ya tiene una clave configurada usando la función tiene (clave)
• Si el caché tiene la clave, recupere el valor almacenado en caché mediante la función get (clave) y utilícelo en lugar de realizar la operación nuevamente. (Esto ahorra tiempo)
• Si la memoria caché no tiene una clave, realice las operaciones requeridas y, antes de enviar la respuesta, establezca el valor de esa clave para que se pueda responder a otras requests directamente a través de los datos almacenados en la memoria caché.

Código final en server.js:

// Importing express module
const express = require('express')
  
// Importing NodeCache and creating a 
// new object called myCache
const NodeCache = require('node-cache')
const myCache = new NodeCache()
    
// Creating an express object
const app = express()
    
// Starting server using listen
// function on port 8000
app.listen(8000, err => { 
   if(err) 
        console.log("Error while starting server")
   else
        console.log(
        "Server has been started at port 8000")
})
  
app.get('/', (req, res)=>{
    res.send('Home page !')
})
  
// Function to demonstrate heavy computation
// like API requests, database queries, etc.
function heavyComputation(){
     let temp = 0;
     for(let i=0; i<100000; i++)
          temp = (Math.random()*5342)%i;
     return 123;
}
  
app.get('/api', (req, res)=>{
      
     // If cache has key, retrieve value
     // from cache itself
     if(myCache.has('uniqueKey')){
          console.log('Retrieved value from cache !!')
            
          // Serve response from cache using
          // myCache.get(key)
          res.send("Result: " + myCache.get('uniqueKey'))
     }else{
  
          // Perform operation, since cache 
          // doesn't have key
          let result =  heavyComputation()
            
          // Set value for same key, in order to 
          // serve future requests efficiently
          myCache.set('uniqueKey', result)
            
          console.log('Value not present in cache,'
                + ' performing computation')
          res.send("Result: " + result)
     }
})

• Detenga el servidor con Ctrl+C y comience de nuevo con node server.js.
• Vuelva a cargar la página web una vez. Este cálculo de tiempo se realiza. Se puede ver en la consola también
• Vuelva a cargar la página web. Esta vez, los datos se sirven desde la caché como se ve en la consola.
• Más recargas servirán datos de la memoria caché, lo que ahorrará cálculos.

Nota: La diferencia entre el tiempo de respuesta no es significativa aquí, ya que el cómputo es muy inferior, sin embargo, para proyectos grandes y escalados, proporciona un aumento de rendimiento masivo. 
Por ejemplo, GeeksforGeeks también utiliza mecanismos de almacenamiento en caché avanzados para diversos fines para lograr la eficiencia.