Bits of .NET

⚡ Memoization = Performance

Repeated calculations are slow. Memoization caches results. Speed up functions, improve performance.

📝 Memoization Basics

// Simple memoization
function memoize(fn) {
    const cache = {};
    
    return function(...args) {
        const key = JSON.stringify(args);
        if (cache[key] === undefined) {
            cache[key] = fn(...args);
        }
        return cache[key];
    };
}

// Expensive function
function slowFunction(n) {
    // Simulate heavy computation
    let result = 0;
    for (let i = 0; i < n * 1000000; i++) {
        result += i;
    }
    return result;
}

// Memoized version
const memoizedSlow = memoize(slowFunction);

console.time('First call');
memoizedSlow(100);
console.timeEnd('First call');

console.time('Second call (cached)');
memoizedSlow(100);
console.timeEnd('Second call (cached)');

🎯 Advanced Memoization

// Fibonacci with memoization
const fib = memoize(function(n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
});

console.log(fib(40)); // Fast!

// Memoize with custom key
function memoizeWithKey(fn, keyFn) {
    const cache = {};
    
    return function(...args) {
        const key = keyFn ? keyFn(...args) : JSON.stringify(args);
        if (cache[key] === undefined) {
            cache[key] = fn(...args);
        }
        return cache[key];
    };
}

// Memoize with expiration
function memoizeWithExpiry(fn, ttl) {
    const cache = {};
    
    return function(...args) {
        const key = JSON.stringify(args);
        const now = Date.now();
        
        if (cache[key] && cache[key].expiry > now) {
            return cache[key].value;
        }
        
        const value = fn(...args);
        cache[key] = {
            value: value,
            expiry: now + ttl
        };
        return value;
    };
}

// React memoization
import { useMemo } from 'react';

function Component({ data }) {
    const expensiveResult = useMemo(() => {
        return expensiveCalculation(data);
    }, [data]);
    
    return 
{expensiveResult}
;
}

// Lodash memoize
import memoize from 'lodash/memoize';

const memoizedFn = memoize(slowFunction);
const result = memoizedFn(100);

// Clear cache
memoizedFn.cache.clear();

💡 Memoization Use Cases

• Expensive calculations
• API calls (caching)
• Recursive functions
• Data transformation
• React components (useMemo)