Utilisation du cache LRU dans Node.js et TypeScript

Lors de la création d'une application Web, nous devons souvent effectuer certaines actions coûteuses. Soit parce qu’ils sont lourds en termes de calcul, soit parce qu’ils prennent beaucoup de temps, soit parce qu’ils nécessitent un appel d’API externe coûteux. Bien sûr, il existe de nombreux exemples, mais ceux-ci sont parmi les plus courants.

Dans de nombreux cas, une solution simple consiste à utiliser la mise en cache. La mise en cache est une technique qui nous permet de stocker les résultats d'une certaine action afin que nous n'ayons pas à réexécuter l'action si les mêmes données sont demandées à nouveau.

Il existe de nombreuses approches différentes en matière de mise en cache, mais dans cet article, je vais vous montrer comment utiliser le package lru-cache pour implémenter un cache LRU dans Node.js avec TypeScript.

Configuration du cache LRU

Pour commencer, nous devrons installer le package lru-cache.

npm install lru-cache

Ensuite, nous mettrons en place un cache LRU pour stocker les données utilisateur. Ce cache aura une taille maximale de 5, ce qui signifie qu'il pourra contenir jusqu'à 5 objets utilisateur à la fois. Voici comment nous l'initialisons :

import { LRUCache } from 'lru-cache';

const userCache = new LRUCache<number, User>({ max: 5 });

Récupérer des données à partir d'une API

Ensuite, nous devons simuler la récupération de données à partir d'une API externe. Nous allons créer une fonction appelée fetchUserFromAPI qui prend un identifiant utilisateur et renvoie un objet utilisateur. Cette fonction inclura un délai pour imiter le temps nécessaire pour récupérer les données sur le réseau.

async function fetchUserFromAPI(userId: number): Promise<User | null> {
    console.log(`Fetching user data for ID: ${userId} from API...`);
    await new Promise(resolve => setTimeout(resolve, 500));

    const users: User[] = [
        { id: 1, name: 'Alice', email: 'alice@example.com' },
        { id: 2, name: 'Bob', email: 'bob@example.com' },
        { id: 3, name: 'Charlie', email: 'charlie@example.com' },
    ];

    const user = users.find((user) => user.id === userId);
    return user || null;
}

Utilisation du cache LRU

Maintenant, créons une fonction appelée getUser qui utilise notre cache LRU. Cette fonction vérifiera d'abord si les données utilisateur sont déjà dans le cache. Si tel est le cas, nous renverrons les données mises en cache. Sinon, nous récupérerons les données de l'API et les ajouterons au cache.

async function getUser(userId: number): Promise<User | null> {
    const cachedUser = userCache.get(userId);

    if (cachedUser) {
        console.log(`User data for ID: ${userId} found in cache.`);
        return cachedUser;
    }

    const user = await fetchUserFromAPI(userId);
    if (user) {
        userCache.set(userId, user);
    }
    return user;
}

Test du cache LRU

Pour voir notre cache LRU en action, nous allons créer une fonction principale qui effectue plusieurs requêtes de données utilisateur. Cela démontrera comment fonctionne le cache et comment il expulse les éléments les moins récemment utilisés lorsqu'il est plein.

async function main() {
    // First request, will fetch from API
    console.log('First Request')
    let user1 = await getUser(1);
    console.log('User 1:', user1);
    console.log('-------------------')

    // Second request for the same user, will be served from cache
    console.log('Second Request')
    user1 = await getUser(1);
    console.log('User 1:', user1);
    console.log('-------------------')

    // Request for a different user, will fetch from API
    console.log('Third Request')
    const user2 = await getUser(2);
    console.log('User 2:', user2);
    console.log('-------------------')

    // Request for a new user, will fetch from API
    console.log('Fourth Request')
    const user3 = await getUser(3);
    console.log('User 3:', user3);
    console.log('-------------------')

    // Request for the first user again, will be served from the cache
    console.log('Fifth Request')
    const user1Again = await getUser(1);
    console.log('User 1 Again:', user1Again);
    console.log('-------------------')

    // Request for a user that was not fetched yet, will fetch from API
    console.log('Sixth Request')
    const user4 = await getUser(4);
    console.log('User 4:', user4);
    console.log('-------------------')

    // Request for the second user again, will be served from the cache
    console.log('Seventh Request')
    const user2Again = await getUser(2);
    console.log('User 2 Again:', user2Again);
    console.log('-------------------')

    // Request for a new user, will fetch from API, and the first user will be evicted from the cache
    console.log('Eighth Request')
    const user5 = await getUser(5);
    console.log('User 5:', user5);
    console.log('-------------------')

    // Request for the first user again, will fetch from API because it was evicted
    console.log('Ninth Request')
    const user1AgainAgain = await getUser(1);
    console.log('User 1 Again Again:', user1AgainAgain);
    console.log('-------------------')
}

main();

Comment fonctionne le cache LRU

Lorsque nous demandons pour la première fois des données utilisateur, elles proviennent de l'API. Mais lorsque nous demandons à nouveau le même utilisateur, les données sont extraites du cache, ce qui rend la requête beaucoup plus rapide. Cela réduit la charge sur l'API et améliore les performances de notre application.

Le Cache LRU a une taille maximale de 5. Lorsque nous demandons un sixième utilisateur, l'élément le moins récemment utilisé (dans ce cas, le premier utilisateur) est supprimé du cache pour laisser de la place aux nouvelles données. Si nous demandons ensuite à nouveau le premier utilisateur, il doit être récupéré depuis l'API car il n'est plus dans le cache.

Avantages de l'utilisation du cache LRU

Comme vous pouvez le voir, lorsque nous demandons plusieurs fois les mêmes données utilisateur, elles sont servies à partir du cache, ce qui rend les requêtes beaucoup plus rapides. Cela réduit la charge sur l'API, améliore les performances des applications et, dans de nombreux cas, peut nous faire économiser beaucoup de ressources et d'argent.

J'espère que vous avez trouvé cet article utile. Si vous avez des questions ou des commentaires, n'hésitez pas à les laisser ci-dessous.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!