2622. Cache With Time Limit

Implementing a Time-Limited Cache in JavaScript

In the world of web development, managing cache effectively can significantly improve the performance of your applications. Recently, I worked on a simple yet powerful Time-Limited Cache in JavaScript, which allows you to store key-value pairs that automatically expire after a specified duration. Let's dive into the implementation and explore how it works!

What is a Time-Limited Cache?

A time-limited cache is a data structure that stores items for a specific period of time. After this time elapses, the items are automatically removed from the cache. This is particularly useful for scenarios where you need temporary storage and want to ensure that stale data doesn't persist.

Key Features

  1. Dynamic Expiry: Each cache entry can have its own expiry time.

  2. Automatic Cleanup: Entries are automatically removed after their duration.

  3. Efficient Management: Utilizes JavaScript's Map and setTimeout for efficient data handling.

The Implementation

Here's a step-by-step breakdown of the TimeLimitedCache class implementation:

  1. Constructor: Initializes the cache using a Map.

  2. set Method: Adds or updates an entry with a specified duration.

  3. get Method: Retrieves the value associated with a key.

  4. count Method: Returns the number of active entries in the cache.

Code :

var TimeLimitedCache = function() { //constucter
    this.myCache = new Map();
};

TimeLimitedCache.prototype.set = function(key, value, duration) {
    //create a value to check data exist or not
    const hasData = this.myCache.get(key);
    //check by if statement
    if(hasData) {
        clearTimeout(hasData.timeLimit);
    }
    //set the value for certaion time
    const timeLimit = setTimeout(() => {
        this.myCache.delete(key);
    }, duration);
    //set the value
    this.myCache.set(key, {value, timeLimit});
    return Boolean(hasData);
};
TimeLimitedCache.prototype.get = function(key) {
    //geting the value using the Map has() method
    return this.myCache.has(key) ? this.myCache.get(key).value
 : -1
 };

TimeLimitedCache.prototype.count = function() {
    // returning the length
    return this.myCache.size;
};


 

Usage Example

To illustrate how to use the TimeLimitedCache, let's consider a simple example:

javascript
const timeLimitedCache = new TimeLimitedCache();

console.log(timeLimitedCache.set(1, 42, 1000)); // Output: false (new entry)
console.log(timeLimitedCache.get(1)); // Output: 42 (retrieved value)
console.log(timeLimitedCache.count()); // Output: 1 (one entry in the cache)
setTimeout(() => {
    console.log(timeLimitedCache.get(1)); // Output: -1 (entry expired)
    console.log(timeLimitedCache.count()); // Output: 0 (no active entries)
}, 1100);
    console.log(timeLimitedCache.get(1)); // Output: -1 (entry expired)
    console.log(timeLimitedCache.count()); // Output: 0 (no active entries)
}, 1100);

In this example:

  • We set a key-value pair with a 1-second expiry.

  • Retrieve the value before it expires.

  • After 1.1 seconds, the entry expires, and the cache is empty.

Conclusion

Implementing a time-limited cache in JavaScript is a great way to manage temporary data efficiently. This TimeLimitedCache class provides a simple yet powerful tool to handle dynamic expiry and automatic cleanup, ensuring your applications remain performant and responsive.

I hope you find this implementation useful. Feel free to share your thoughts and enhancements!

Comments

Post a Comment

Popular posts from this blog

3Sum Closest: O(n²) Two-Pointer Magic šŸš€ leetcode: 16

Three Sum Closest - LeetCode Solution In this blog post, we'll dive into the Three Sum Closest problem, a popular coding challenge on LeetCode. We'll explore the intuition behind the solution, discuss the approach, analyze the complexity, and provide a detailed explanation of the code. Additionally, I'll share my LeetCode solution link for further reference. Problem Statement Given an integer array nums of length n and an integer target , find three integers in nums such that the sum is closest to target . Return the sum of the three integers. You may assume that each input would have exactly one solution. Intuition The problem requires finding three numbers in the array whose sum is as close as possible to the target. To efficiently find such a triplet, we can use a combination of sorting and the two-pointer technique . Sorting : First, sort the array. This allows us to use the two-po...
Read more

Kadane's Algorithm: Maximum Subarray Problem - LeetCode(53) Solution

Maximum Subarray Problem - LeetCode Solution Maximum Subarray Problem - LeetCode Solution Problem Statement Given an integer array nums , find the contiguous subarray (containing at least one number) that has the largest sum and return its sum. Intuition The problem requires finding the contiguous subarray with the maximum sum. A brute force approach would involve checking all subarrays, but this would be inefficient. Instead, we use Kadane's Algorithm , which efficiently finds the maximum sum subarray in O(n) time. Approach Initialize two variables: total (running sum) and maxi (maximum sum encountered so far). Iterate through the array: Add the current element to total . Update maxi with the maximum of maxi and total . If total becomes negative, reset it to zero. Return maxi as the maximum sub...
Read more

LeetCode Problem: Implement pow(x, n) leetcode:- 50

Understanding the Fast Exponentiation Algorithm: Exponentiation by Squaring In this blog post, we will explore the implementation of the myPow function, a common problem found on LeetCode. The goal of this problem is to compute \(x^n\) efficiently, even when \(n\) is a very large number. Instead of using a naive approach, we employ a method called Exponentiation by Squaring to significantly reduce the number of multiplications required. Problem Overview Given a floating-point number x and an integer n , our task is to implement a function that computes \(x^n\). A straightforward solution might involve multiplying x by itself n times, but this approach is too slow when n is large. Intuition Behind Exponentiation by Squaring The main idea is to reduce the problem size by halving the exponent at each recursive step. Consider the following: If n is even, then: \(x^n = x^{...
Read more