Exercise 2: Memoize (simple)
Problem Statement
Create a function memoize(fn) that returns cached result for same args. Assume args are JSON-serializable.
Sample Output:
const memoizedFn = memoize((a, b) => a + b); memoizedFn(5, 10) => 15 (computed) memoizedFn(5, 10) => 15 (cached)
Solution
const memoize = (fn) => {
const cache = new Map();
return (...args) => {
const key = JSON.stringify(args);
if (cache.has(key)) return cache.get(key);
const val = fn(...args);
cache.set(key, val);
return val;
};
};Explanation
Overall Goal:
- Function calls ko cache karna: same arguments ke liye result store karke reuse karna.
- Performance improvement: expensive calculations ko avoid karna.
Line 1: Function header
const memoize = (fn) => {→ higher-order function jo function lega aur memoized version return karega.
Line 2: Cache creation
const cache = new Map();Map→ key-value store, fast lookup (O(1)).- Cache me
key(arguments) →value(result) store hoga.
Line 3: Return memoized function
return (...args) => {→ function return karta hai jo original function ko wrap karta hai....args→ spread operator: koi bhi arguments accept karega.
Line 4: Create cache key
const key = JSON.stringify(args);argsarray ko string me convert karte hain (cache key banane ke liye).- Example:
[5, 10]→"[5,10]"(string key). - Important: args JSON-serializable hone chahiye (objects, arrays, primitives).
Line 5: Cache hit check
if (cache.has(key)) return cache.get(key);cache.has(key)→ kya ye key cache me hai?- Agar hai → cached value return karo (computation skip).
Line 6-7: Cache miss - compute and store
const val = fn(...args);→ original function ko call karke result compute karo.cache.set(key, val);→ result ko cache me store karo.return val;→ computed value return karo.
Example:
- First call:
memoizedFn(5, 10)→ compute → cache → return result. - Second call:
memoizedFn(5, 10)→ cache hit → return cached result (fast!).
Real world:
- Expensive calculations: Fibonacci, factorial, API calls.
- React useMemo hook internally similar pattern use karta hai.
- GraphQL resolvers me field-level caching.