lru-cache vs quick-lru vs node-cache vs memory-cache | Comparaison des packages npm "Mise en cache en mémoire"

Package	Téléchargements	Stars	Taille	Issues	Publication	Licence

lru-cache	239,402,483	5,673	827 kB	12	il y a 2 jours	ISC
quick-lru	25,331,113	721	16.4 kB	4	il y a 16 jours	MIT
node-cache	3,622,949	2,350	-	73	il y a 5 ans	MIT
memory-cache	637,899	1,601	-	32	il y a 8 ans	BSD-2-Clause

Package

Téléchargements

Stars

Taille

Issues

Publication

Licence

lru-cache

239,402,483

5,673

827 kB

il y a 2 jours

ISC

quick-lru

25,331,113

721

16.4 kB

il y a 16 jours

MIT

node-cache

3,622,949

2,350

il y a 5 ans

MIT

memory-cache

637,899

1,601

il y a 8 ans

BSD-2-Clause

Gestion de l'éviction

lru-cache:
lru-cache gère l'éviction des éléments en fonction de leur utilisation. Lorsqu'un élément est ajouté et que la limite de mémoire est atteinte, l'élément le moins récemment utilisé est supprimé pour faire de la place au nouvel élément. Cela garantit que le cache conserve les éléments les plus fréquemment utilisés.
quick-lru:
quick-lru implémente un cache LRU simple et rapide. Lorsqu'un nouvel élément est ajouté et que la limite de taille est atteinte, l'élément le moins récemment utilisé est supprimé. Cela garantit que le cache reste léger et ne consomme pas trop de mémoire.
node-cache:
node-cache permet une éviction des éléments basée sur l'expiration. Vous pouvez définir une durée de vie (TTL) pour chaque clé, après quoi elle sera automatiquement supprimée du cache. Cela aide à gérer l'utilisation de la mémoire tout en conservant les données en cache pendant une période déterminée.
memory-cache:
memory-cache ne dispose pas de mécanisme d'éviction intégré. Les éléments restent en cache jusqu'à ce qu'ils soient explicitement supprimés ou que le processus Node.js soit arrêté. Cela peut entraîner une utilisation excessive de la mémoire si le cache n'est pas géré correctement.

API et Simplicité

lru-cache:
lru-cache offre une API simple et intuitive pour interagir avec le cache. Vous pouvez ajouter, récupérer et supprimer des éléments facilement. La documentation est claire, ce qui facilite son intégration dans les projets.
quick-lru:
quick-lru dispose d'une API minimaliste qui se concentre sur l'essentiel. Elle est facile à comprendre et à utiliser, ce qui en fait un excellent choix pour les développeurs qui ont besoin d'une solution de mise en cache rapide et efficace.
node-cache:
node-cache propose une API bien conçue avec des fonctionnalités supplémentaires telles que la gestion des événements et l'expiration des clés. Bien qu'il soit un peu plus complexe que les autres, il reste facile à utiliser grâce à sa documentation complète.
memory-cache:
memory-cache fournit une API très simple pour le stockage de paires clé-valeur. Sa simplicité en fait un choix rapide pour les applications qui n'ont pas besoin de fonctionnalités complexes.

Utilisation de la Mémoire

lru-cache:
lru-cache utilise la mémoire de manière efficace en évitant de stocker des éléments inutilisés. La gestion LRU garantit que seuls les éléments les plus pertinents sont conservés en mémoire, ce qui réduit l'empreinte mémoire globale du cache.
quick-lru:
quick-lru est conçu pour être léger et rapide, avec une utilisation de la mémoire minimale. L'implémentation LRU garantit que la mémoire est utilisée de manière optimale, en évitant l'accumulation d'éléments inutilisés.
node-cache:
node-cache gère l'utilisation de la mémoire en permettant l'expiration des clés. Cela aide à libérer de la mémoire pour les éléments qui ne sont plus nécessaires. Cependant, l'utilisation de la mémoire dépend également de la façon dont les clés et les valeurs sont gérées par l'application.
memory-cache:
memory-cache peut entraîner une utilisation excessive de la mémoire si les éléments ne sont pas supprimés manuellement. Étant donné qu'il n'y a pas de mécanisme d'éviction, il est important de surveiller l'utilisation de la mémoire lors de son utilisation dans des applications à long terme.

Exemple de Code

lru-cache:

Exemple d'utilisation de lru-cache

const LRU = require('lru-cache');
const options = { max: 500 }; // Taille maximale du cache
const cache = new LRU(options);

// Ajouter des éléments au cache
cache.set('a', 1);
cache.set('b', 2);

// Récupérer un élément
console.log(cache.get('a')); // 1

// L'élément le moins récemment utilisé sera évincé si la limite est atteinte
for (let i = 0; i < 1000; i++) {
  cache.set(`key${i}`, i);
}

console.log(cache.get('b')); // undefined (évincé)

quick-lru:

Exemple d'utilisation de quick-lru

const QuickLRU = require('quick-lru');
const lru = new QuickLRU({ maxSize: 100 }); // Taille maximale du cache

// Ajouter des éléments
lru.set('key1', 'value1');
lru.set('key2', 'value2');

// Récupérer un élément
console.log(lru.get('key1')); // value1

// L'élément le moins récemment utilisé sera évincé si la limite est atteinte
for (let i = 0; i < 100; i++) {
  lru.set(`key${i}`, i);
}

console.log(lru.get('key2')); // undefined (évincé)

node-cache:

Exemple d'utilisation de node-cache

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

// Ajouter des éléments avec une durée d'expiration
myCache.set('key1', 'value1', 100); // expire après 100 secondes
myCache.set('key2', 'value2'); // jamais expire

// Récupérer un élément
console.log(myCache.get('key1')); // value1

// Vérifier si une clé existe
console.log(myCache.has('key2')); // true

// Supprimer un élément
myCache.del('key1');
console.log(myCache.get('key1')); // undefined

memory-cache:

Exemple d'utilisation de memory-cache

const cache = require('memory-cache');

// Ajouter des éléments au cache
cache.put('key1', 'value1');
cache.put('key2', 'value2');

// Récupérer un élément
console.log(cache.get('key1')); // value1

// Supprimer un élément
cache.del('key2');
console.log(cache.get('key2')); // null