WeakMap

Map vs WeakMap

1. Differences Between Map and WeakMap

• Map strongly references both keys and values, meaning data is retained in memory until it’s explicitly removed.

• WeakMap weakly references keys, allowing them to be garbage-collected if no other references exist. In other words, once an object key is no longer referenced elsewhere, it is automatically removed from the WeakMap.

2. Advantages of WeakMap

• Memory Management: Since WeakMap weakly references keys, keys that are no longer in use can be garbage-collected, helping manage memory more efficiently, especially when you have many object keys in memory-sensitive applications.

3. Drawbacks of WeakMap

• Cannot Use Primitive Keys: In WeakMap, keys must be objects. Primitives like strings and numbers cannot be used as keys.

• Limited Use Cases for Caching: WeakMap isn’t ideal for functions that rely on numeric arguments (like Fibonacci sequences) because numbers cannot be keys in WeakMap.

Memoization Function

function fibonacci(n: number): number {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

function memoize<T extends (...args: any[]) => any>(fn: T): T {
	const cache = new Map<string, ReturnType<T>>();
	return function (...args: Parameters<T>): ReturnType<T> {
		const key = JSON.stringify(args);
		if (cache.has(key)) {
			return cache.get(key) as ReturnType<T>;
		}
		const result = fn(...args);
		cache.set(key, result);
		return result;
	} as T;
}

• Converting function arguments into a string key for storage in cache.

• Checking if the cache contains the value for the given arguments and returning it if it exists.

• If the value doesn’t exist, the function computes it, stores it in the cache, and then returns the result.

const fibonacci = memoize((n: number): number =>  {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
});

console.log(fibonacci(40)); // Slower on first calculation
console.log(fibonacci(40)); // Fast on subsequent calls due to caching

LRU (Least Recently Used) Cache

1. Concept of LRU Caching

• Pagination-heavy web applications.

• Apps loading large amounts of data where only recent data should be cached.

2. Implementing LRU Cache

• Moving the most recently accessed items to the front.

• Easily removing the least recently used items.

class LRUCache<K, V> {
    private capacity: number;
    private cache: Map<K, V>;

    constructor(capacity: number) {
        this.capacity = capacity;
        this.cache = new Map();
    }

    get(key: K): V | undefined {
        if (!this.cache.has(key)) {
            return undefined;
        }
        const value = this.cache.get(key);
        this.cache.delete(key);
        this.cache.set(key, value as V);
        return value;
    }

    put(key: K, value: V): void {
        if (this.cache.has(key)) {
            this.cache.delete(key);
        }
        if (this.cache.size >= this.capacity) {
            const oldestKey = this.cache.keys().next().value;
            this.cache.delete(oldestKey);
        }
        this.cache.set(key, value);
    }
}

// Usage
const lruCache = new LRUCache<string, number>(3);
lruCache.put("a", 1);
lruCache.put("b", 2);
lruCache.put("c", 3);
console.log(lruCache.get("a")); // 1
lruCache.put("d", 4); // "b" is removed as it is the least recently used
console.log(lruCache.get("b")); // undefined

3. Pros and Cons of LRU Caching

• Pros:
• Prioritizes frequently accessed items, improving performance.
• Limits memory usage by removing old items, helping prevent memory leaks.

• Cons:
• Has a limited capacity, so items beyond the limit are not stored.
• Implementing an efficient LRU cache can increase complexity.

4. Other Cache Management Strategies

• LFU (Least Frequently Used): Removes the least frequently accessed items.

• FIFO (First In, First Out): Removes items based on their insertion order.

• TTL (Time-To-Live): Removes items after a set time, useful when only the latest data is needed.

Set vs Map

1. Purpose and Structure

• Set: A collection of unique values. Adding the same value multiple times will result in only one instance.

• Map: A collection of key-value pairs, where keys are unique and each key maps to a single value.

2. Data Storage

• Set: Stores only values. Each value must be unique, and there is no key-value pair structure.

• Map: Stores data as key-value pairs, where each key is unique and maps to a value.

// Set Example
const set = new Set();
set.add("apple");
set.add("banana");
set.add("apple"); // Duplicate ignored
console.log(set); // Set { "apple", "banana" }

// Map Example
const map = new Map();
map.set("name", "Alice");
map.set("age", 30);
map.set("name", "Bob"); // Overrides existing key
console.log(map); // Map { "name" => "Bob", "age" => 30 }

3. Data Access

• Set: No index or key-based access. Accessed through iteration.

• Map: Direct access to values by key, using map.get(key).

// Set iteration
set.forEach(value => console.log(value));

// Map key access
console.log(map.get("name")); // "Bob"
console.log(map.get("age")); // 30

Summary Table