23. Big Tech Machine Coding: Deep Clone with Circular References & LRU Cache • JavaScript & Advanced ES6+ (0-to-Hero Big Tech Standard) • Rishabh Ki Kaksha

Top Big Tech interview rounds (Google L5, Meta E5, Uber, Amazon) me 2 problems 90% puchi jaati hain:
1. **Production-Grade Deep Clone:** Jo circular references, Dates, RegExp, Maps, Sets ko bina crash huye copy kare.
2. **LRU Cache (Least Recently Used):** O(1) time complexity me read aur write karne wala cache memory engine.

---

### 2. Problem 1: Deep Clone with Circular Reference Handling

#### Kyun `JSON.parse(JSON.stringify(obj))` Fail Hota Hai?
*   ❌ **Circular Reference Crash:** `TypeError: Converting circular structure to JSON`
*   ❌ **Data Loss:** `Date` string ban jata hai, `RegExp` khali `{}` ban jata hai, `undefined` aur `Functions` gayab ho jate hain!

#### The Ultimate Production Deep Clone Implementation:
```javascript
function deepClone(target, hash = new WeakMap()) {
    // 1. Primitives aur null return karo
    if (target === null || typeof target !== 'object') {
        return target;
    }

// 2. Special Object Types handle karo
    if (target instanceof Date) return new Date(target.getTime());
    if (target instanceof RegExp) return new RegExp(target.source, target.flags);
    if (target instanceof Set) {
        const copySet = new Set();
        target.forEach(val => copySet.add(deepClone(val, hash)));
        return copySet;
    }
    if (target instanceof Map) {
        const copyMap = new Map();
        target.forEach((val, key) => copyMap.set(key, deepClone(val, hash)));
        return copyMap;
    }

// 3. Circular Reference Check (WeakMap Cache)
    if (hash.has(target)) {
        return hash.get(target); // Already cloned instance return karo!
    }

// 4. Array ya Object initialize karo
    const cloneTarget = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
    hash.set(target, cloneTarget); // Cache immediately before recursion!

// 5. Symbol keys aur regular properties dono clone karo
    const allKeys = [...Object.keys(target), ...Object.getOwnPropertySymbols(target)];
    for (const key of allKeys) {
        cloneTarget[key] = deepClone(target[key], hash);
    }

return cloneTarget;
}

// Verification with Circular Object
const user = { name: "Rishabh", createdAt: new Date() };
user.self = user; // 🌀 Circular reference!

const clonedUser = deepClone(user);
console.log("Cloned successfully:", clonedUser.name); // "Rishabh"
console.log("Circular link intact:", clonedUser.self === clonedUser); // true ✅
console.log("Deep isolation:", clonedUser !== user); // true ✅
```

---

### 3. Problem 2: LRU Cache (Least Recently Used) in O(1) Time

LRU Cache ka matlab: Jab memory full ho jaye, toh **us item ko delete karo jise sabse lambe time se kisi ne use nahi kiya.**

JavaScript me `Map` insertion order maintain karta hai, jisse hum O(1) me LRU Cache bana sakte hain:

```javascript
class LRUCache {
    constructor(capacity) {
        this.capacity = capacity;
        this.cache = new Map();
    }

// O(1) Get Item
    get(key) {
        if (!this.cache.has(key)) return -1;

const value = this.cache.get(key);
        // Refresh position: Delete and re-insert at end (Most Recently Used)
        this.cache.delete(key);
        this.cache.set(key, value);
        return value;
    }

// O(1) Put / Update Item
    put(key, value) {
        if (this.cache.has(key)) {
            this.cache.delete(key);
        } else if (this.cache.size >= this.capacity) {
            // Evict Least Recently Used (First key in Map iterator)
            const oldestKey = this.cache.keys().next().value;
            this.cache.delete(oldestKey);
        }
        this.cache.set(key, value);
    }
}

// Live Demonstration
const cache = new LRUCache(2); // Capacity: 2 items
cache.put("a", 100);
cache.put("b", 200);

console.log(cache.get("a")); // 100 ('a' becomes most recently used)

cache.put("c", 300); // Capacity full! Evicts 'b' (Least Recently Used)

console.log(cache.get("b")); // -1 (Evicted!)
console.log(cache.get("c")); // 300
```

---

### 4. Comparison Table: `structuredClone()` vs Custom Deep Clone

---

### 5. Interview Ke 3 Sawal Is Topic Se

1. **Deep clone me `WeakMap` kyun use hota hai `Map` ke badle?** -> Taaki clone complete hone ke baad garbage collection target objects ki memory ko auto-reclaim kar sake bina memory leak huye.
2. **`Map.prototype.keys().next().value` kya return karta hai?** -> Map me store ki gayi sabse purani (pehle insert hui) key ko return karta hai, jo O(1) eviction ke liye perfect hai.
3. **`Object.assign()` deep copy karta hai ya shallow copy?** -> Sirf top-level properties ko shallow copy karta hai; nested objects ka reference wahi purana rehta hai.

---
**Course Completed:** JavaScript Mastery (All 23 Lessons Completed!) 🎉🚀

Loading lesson content...

🎯 Big Tech Coding & Interview Challenges

Practice these curated problems. Click "Load in Sandbox" to solve live in the Code Studio!

2 Questions

Hard

1. Deep Clone Supporting Circular References & Dates

Implement `deepClone(obj)` handling cyclical references, Arrays, Dates, and regular objects.

💡 View Pro Interview Hint

• Use WeakMap to cache cloned object references.

Hard

2. LRU Cache (Least Recently Used) in O(1) Time

Build a high-performance `LRUCache(capacity)` with O(1) `.get(key)` and `.put(key, value)` using JS Map key insertion order.

💡 View Pro Interview Hint

• Use Map.prototype.keys().next().value for O(1) eviction.

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

🎯 Big Tech Coding & Interview Challenges

1. Deep Clone Supporting Circular References & Dates

2. LRU Cache (Least Recently Used) in O(1) Time

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track