Day 46: Memoization

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.