Menggunakan Cache LRU dalam Node.js dan TypeScript

Apabila membina aplikasi web, kita selalunya perlu melakukan tindakan tertentu yang mahal. Sama ada kerana ia berat secara pengiraan, ia mengambil masa yang lama untuk disiapkan atau memerlukan panggilan API luaran yang mahal. Sudah tentu, terdapat banyak contoh perkara ini, tetapi ini adalah beberapa contoh yang paling biasa.

Dalam banyak kes, penyelesaian mudah ialah menggunakan caching. Caching ialah teknik yang membolehkan kami menyimpan hasil tindakan tertentu supaya kami tidak perlu melakukan tindakan itu semula jika data yang sama diminta semula.

Terdapat banyak pendekatan berbeza untuk caching, tetapi dalam siaran ini, saya akan menunjukkan kepada anda cara menggunakan pakej lru-cache untuk melaksanakan Cache LRU dalam Node.js dengan TypeScript.

Menyediakan Cache LRU

Untuk bermula, kita perlu memasang pakej lru-cache.

npm install lru-cache

Kemudian, kami akan menyediakan Cache LRU untuk menyimpan data pengguna. Cache ini akan mempunyai saiz maksimum 5, bermakna ia boleh memuatkan sehingga 5 objek pengguna pada satu masa. Begini cara kami memulakannya:

import { LRUCache } from 'lru-cache';

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

Mengambil Data daripada API

Seterusnya, kita perlu mensimulasikan pengambilan data daripada API luaran. Kami akan mencipta fungsi yang dipanggil fetchUserFromAPI yang mengambil ID pengguna dan mengembalikan objek pengguna. Fungsi ini akan termasuk kelewatan untuk meniru masa yang diambil untuk mengambil data melalui rangkaian.

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;
}

Menggunakan Cache LRU

Sekarang, mari buat fungsi yang dipanggil getUser yang menggunakan Cache LRU kami. Fungsi ini terlebih dahulu akan menyemak sama ada data pengguna sudah berada dalam cache. Jika ya, kami akan mengembalikan data cache. Jika tidak, kami akan mengambil data daripada API dan menambahkannya pada 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;
}

Menguji Cache LRU

Untuk melihat Cache LRU kami dalam tindakan, kami akan mencipta fungsi utama yang membuat beberapa permintaan untuk data pengguna. Ini akan menunjukkan cara cache berfungsi dan cara ia mengusir item yang paling kurang digunakan baru-baru ini apabila ia penuh.

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();

Bagaimana LRU Cache Berfungsi

Apabila kami mula-mula meminta data pengguna, ia datang daripada API. Tetapi apabila kami meminta pengguna yang sama sekali lagi, data ditarik dari cache, menjadikan permintaan itu lebih pantas. Ini mengurangkan beban pada API dan meningkatkan prestasi aplikasi kami.

LRU Cache mempunyai saiz maksimum 5. Apabila kami meminta pengguna keenam, item yang paling kurang digunakan baru-baru ini (dalam kes ini, pengguna pertama) dialih keluar daripada cache untuk memberi ruang kepada data baharu. Jika kami kemudian meminta pengguna pertama sekali lagi, ia perlu diambil daripada API kerana ia tidak lagi dalam cache.

Faedah Menggunakan LRU Cache

Seperti yang anda lihat, apabila kami meminta data pengguna yang sama berbilang kali, data itu disiarkan daripada cache, menjadikan permintaan itu lebih pantas. Ini mengurangkan beban pada API, meningkatkan prestasi aplikasi dan dalam banyak kes, ia boleh menjimatkan banyak sumber dan wang.

Saya harap anda mendapati siaran ini berguna. Jika anda mempunyai sebarang soalan atau komen, sila tinggalkan di bawah.

Atas ialah kandungan terperinci Menggunakan Cache LRU dalam Node.js dan TypeScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!