LRU (Least Recently Used) eviction removes the item whose recorded access is oldest when a cache exceeds its capacity. It keeps frequently accessed data available and is commonly applied in memory-bound systems. section 6.4
An interview-ready implementation combines:
- A hash map for constant-time key lookup. section 6.4
- A Map whose insertion order records recency; every access or insertion moves the key to the end. section 6.4
- Eviction of the first Map key when capacity is exceeded. section 6.4
TypeScript cache
A generic LRUCache validates positive capacity, implements get and put, refreshes recency by deleting and reinserting accessed keys, and returns -1 for misses. section 6.4
Listing 6.6 LRU cache implementation in TypeScript
class LRUCache<K, V> {
private cache: Map<K, V>;
private capacity: number;
constructor(capacity: number) {
if (capacity <= 0) {
throw new Error('Capacity must be greater than 0');
}
this.capacity = capacity; #A
this.cache = new Map(); #B
}
get(key: K): V | -1 { #C
if (!this.cache.has(key)) { #D
return -1;
}
const value = this.cache.get(key)!; #E
this.cache.delete(key);
this.cache.set(key, value);
return value;
}
put(key: K, value: V): void { #F
if (this.cache.has(key)) {
this.cache.delete(key); #G
}
this.cache.set(key, value); #H
if (this.cache.size > this.capacity) {
const lruKey = this.cache.keys().next().value!; #I
this.cache.delete(lruKey); #J
}
}
entries(): [K, V][] { #K
return Array.from(this.cache.entries());
}
}
Inspect the complete TypeScript implementation, including capacity validation, lookup, recency updates, insertion, eviction, and entry inspection. section 6.4




