lru-cache vs quick-lru vs lru vs lru-memoize | Comparación de paquetes npm de "Manejo de Caché en JavaScript"

Paquete	Descargas	Stars	Tamaño	Issues	Publicación	Licencia

lru-cache	216,008,975	5,589	820 kB	11	hace 3 meses	ISC
quick-lru	27,417,457	706	15.2 kB	4	hace 2 meses	MIT
lru	62,806	136	-	12	hace 9 años	MIT
lru-memoize	57,470	318	-	30	hace 6 años	MIT

Paquete

Descargas

Stars

Tamaño

Issues

Publicación

Licencia

lru-cache

216,008,975

5,589

820 kB

hace 3 meses

ISC

quick-lru

27,417,457

706

15.2 kB

hace 2 meses

MIT

lru

62,806

136

hace 9 años

MIT

lru-memoize

57,470

318

hace 6 años

MIT

Tamaño y Rendimiento

lru-cache:
lru-cache es más grande que lru, pero ofrece una gama de características que justifican el tamaño adicional. Su rendimiento es excelente para la mayoría de las aplicaciones, especialmente aquellas que se benefician de su manejo eficiente de la memoria y la eliminación de entradas.
quick-lru:
quick-lru se centra en la velocidad y la eficiencia, ofreciendo una implementación LRU rápida con un uso de memoria mínimo. Es ideal para aplicaciones que necesitan una caché ligera y de alto rendimiento sin características innecesarias.
lru:
lru es una biblioteca muy pequeña (menos de 1 KB) que proporciona una implementación básica de LRU sin ninguna sobrecarga significativa. Su simplicidad la convierte en una opción rápida para proyectos donde el rendimiento es crítico.
lru-memoize:
lru-memoize tiene un tamaño moderado y está diseñado para optimizar funciones, lo que lo hace eficiente en términos de tiempo para llamadas de funciones repetidas. Su enfoque en la memorización lo hace ideal para aplicaciones donde ciertas funciones son costosas de calcular.

Manejo de Memoria

lru-cache:
lru-cache incluye manejo de memoria incorporado, con límites configurables para el tamaño de la caché y la cantidad de memoria utilizada. Esto ayuda a prevenir el uso excesivo de memoria y garantiza que la caché se mantenga dentro de límites razonables.
quick-lru:
quick-lru proporciona un manejo de memoria simple y eficiente, eliminando automáticamente las entradas menos utilizadas cuando se alcanza el límite de tamaño. Esto ayuda a mantener el uso de memoria bajo control sin complicaciones adicionales.
lru:
lru no tiene características avanzadas de manejo de memoria, ya que es una implementación simple de LRU. No maneja automáticamente la memoria, por lo que depende del desarrollador asegurarse de que se utilice de manera eficiente.
lru-memoize:
lru-memoize gestiona la memoria al almacenar en caché los resultados de las funciones basados en sus argumentos. Sin embargo, el manejo de memoria depende de la implementación de la función y de cómo se gestionan los argumentos en caché.

API y Facilidad de Uso

lru-cache:
lru-cache proporciona una API rica y bien documentada que permite un control detallado sobre la caché. Incluye características como eventos de eliminación, lo que la hace más versátil pero también un poco más compleja de usar.
quick-lru:
quick-lru ofrece una API minimalista que es fácil de entender y usar. Su diseño simple la hace ideal para desarrolladores que necesitan una solución rápida sin complicaciones.
lru:
lru ofrece una API simple y directa para agregar y recuperar elementos de la caché. Su simplicidad la hace fácil de usar e integrar en proyectos sin una curva de aprendizaje significativa.
lru-memoize:
lru-memoize tiene una API sencilla para memorizar funciones, lo que la hace fácil de usar para desarrolladores que necesitan optimizar funciones rápidamente. Su documentación es clara, lo que facilita su integración.

Ejemplo de Código

lru-cache:

Ejemplo de uso de lru-cache

import LRUCache from 'lru-cache';
const cache = new LRUCache({ max: 3 }); // Capacidad de 3 elementos
cache.set('a', 1);
cache.set('b', 2);
cache.set('c', 3);
console.log(cache.get('a')); // 1
cache.set('d', 4); // 'b' se elimina automáticamente
console.log(cache.get('b')); // undefined

quick-lru:

Ejemplo de uso de quick-lru

import QuickLRU from 'quick-lru';
const cache = new QuickLRU({ maxSize: 3 }); // Capacidad de 3 elementos
cache.set('a', 1);
cache.set('b', 2);
cache.set('c', 3);
console.log(cache.get('a')); // 1
cache.set('d', 4); // 'b' se elimina
console.log(cache.get('b')); // undefined

lru:

Ejemplo de uso de lru

import LRU from 'lru';
const cache = new LRU(3); // Capacidad de 3 elementos
cache.set('a', 1);
cache.set('b', 2);
cache.set('c', 3);
console.log(cache.get('a')); // 1
cache.set('d', 4); // 'b' se elimina
console.log(cache.get('b')); // undefined

lru-memoize:

Ejemplo de uso de lru-memoize

import memoize from 'lru-memoize';
const slowFunction = (num) => {
  // Simula una función costosa
  for (let i = 0; i < 1e6; i++); // Espera
  return num;
};
const memoizedFunction = memoize(3)(slowFunction); // Memorización con límite de 3
console.log(memoizedFunction(1)); // Calcula y almacena
console.log(memoizedFunction(1)); // Devuelve el resultado de la caché