What is Memoization?
Memoization is a technique used to store the results of expensive function calls and return the cached result when the same inputs occur again. It's like having a crystal ball that remembers previous calculations and can instantly provide answers.
🪄
Creating the Memoization Decorator
Let's create a TypeScript decorator that can memoize the result of a function. We'll call it @memoize
. 📝
function memoize(target: any, key: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
const cache = new Map();
descriptor.value = function (...args: any[]) {
const key = JSON.stringify(args);
if (cache.has(key)) {
return cache.get(key);
}
const result = originalMethod.apply(this, args);
cache.set(key, result);
return result;
};
return descriptor;
}
Applying Decorator
class Calculator {
@memoize
static fibonacci(n: number): number {
if (n <= 1) return n;
return this.fibonacci(n - 1) + this.fibonacci(n - 2);
}
}
By adding @memoize
to the fibonacci
method, we're telling it to cache the results. As a result, subsequent calls with the same argument won't recalculate the Fibonacci number, making our code much faster! 🚀
Example
console.log(Calculator.fibonacci(40)); // Calculates Fibonacci(40) and caches it
console.log(Calculator.fibonacci(40)); // Returns the cached result instantly
Benefits of Memoization with Decorators
- Performance Boost: Memoization can drastically reduce the execution time of functions with expensive calculations.
- Simplified Code: You don't need to manually implement caching logic in your functions; decorators handle it for you.
- Readability: Code using decorators is more concise and easier to understand.
Considerations
- Be cautious when using memoization for functions with a large number of potential input values, as it can lead to excessive memory usage. Always evaluate your use case.
Top comments (0)