Blog

JavaScript Me WeakRef & Finalization Registry Kya Hote Hain – JavaScript Weak Ref & Finalization Registry

1. WeakRef Kya Hota Hai ?

WeakRef ka matlab hota hai weak reference to an object.
Normal JavaScript variables me agar tum ek object assign karte ho, to us object ka ek strong reference create kar deta hai, jo Garbage Collector ko object ko delete karne se rokta hai jab tak reference exist kare.

Lekin, agar tum WeakRef ka use karte ho, to tum object ko refer karte ho without preventing Garbage Collector from cleaning it up.
Matlab tumhara reference weak hota hai – object ka lifetime tumhare reference ke upar depend nahi karta.

Kaise Kaam Karta Hai ?

  1. Tum ek object banate ho.
  2. Tum uska WeakRef bana lete ho.
  3. Agar us object ke strong references khatam ho jaate hain (variables me store nahi), to Garbage Collector us object ko kabhi bhi memory se remove kar sakta hai.
  4. WeakRef ke through tum kabhi-kabhi object ko access kar sakte ho (jab tak GC ne remove nahi kiya).
  5. Agar GC ne object remove kar diya, to WeakRef deref karne par undefined return karega.

Syntax:

let weakRef = new WeakRef(targetObject);
let value = weakRef.deref();

Example:

let obj = { name: "Sandeep" }; // Strong reference
let weak = new WeakRef(obj); // Weak reference

console.log(weak.deref().name); // Output: Sandeep

// Remove strong reference
obj = null;

// Ab GC kabhi bhi clean kar sakta hai
setTimeout(() => {
    let ref = weak.deref();
    if (ref) {
        console.log("Object still alive:", ref.name);
    } else {
        console.log("Object removed by GC");
    }
}, 5000);

Pros:

  • Large objects ke liye memory optimization.
  • Caching systems me use.
  • Unnecessary memory occupation ko avoid karta hai.

Cons:

  • GC ka timing unpredictable hota hai.
  • Agar tum WeakRef ka misuse karo to unexpected undefined values aa sakti hain.

Example:

Socho tum ek mehenga laptop store me gaye ho aur tum laptop ka ek photo lete ho.
Jab tak wo laptop store me hai, tum uska photo dekh ke khush ho sakte ho.
Lekin agar store ne wo laptop bech diya, tumhare paas sirf useless photo bacha (WeakRef deref ka result undefined).

2. FinalizationRegistry Kya Hota Hai ?

FinalizationRegistry ka use tab hota hai jab tum chahte ho ki Garbage Collector kisi object ko remove karne ke baad tumhara ek cleanup function call kare.
Ye cleanup function aapke object ke saath connected resources ko free karne ka kaam karta hai.

Kaise Kaam Karta Hai:

  1. Ek FinalizationRegistry create karo aur usme ek callback function do jo cleanup karega.
  2. register() method ka use karke object ko registry me add karo.
  3. Jab object ke saare strong references khatam ho jaate hain, Garbage Collector us object ko remove karega.
  4. Object remove hote hi registry ka callback function run hoga, jisme tum cleanup kar sakte ho.

Syntax:

const registry = new FinalizationRegistry((heldValue) => {
    // Cleanup code
});

registry.register(targetObject, "Resource Name");

Example:

const registry = new FinalizationRegistry((value) => {
    console.log(`Cleaning up resources for: ${value}`);
});

let user = { name: "Sandeep" };

registry.register(user, "User Object Resource");

// Remove strong reference
user = null;

// Cleanup function will run after GC deletes the object

Pros:

  • GC (Garbage Collection) ke baad automatic resource cleanup hota hai.
  • Ye un resources ko release karne me useful hai jo system-level hote hain, jaise file handles, sockets, ya database connections.

Cons:

  • Callback ka timing unpredictable hai.
  • Deterministic cleanup guarantee nahi karta (matlab exact time pe nahi chalega).

Example:

Socho tum ek library se book lete ho. Tum contract me likh dete ho:
“Jab mai book return karunga, aap meri membership cancel kar dena aur deposit wapas kar dena.”
Jab tum book wapas karte ho (object delete hota hai), library automatically tumhara deposit return kar deti hai (FinalizationRegistry ka cleanup function).

3. WeakRef Aur Finalization Registry

Aksar ye dono features ek saath use kiye jaate hain, especially caching scenarios me.

Example:

class SmartCache {
    constructor() {
        this.cache = new Map();
        this.registry = new FinalizationRegistry((key) => {
            console.log(`Cleaning cache for ${key}`);
            this.cache.delete(key);
        });
    }

    set(key, value) {
        this.cache.set(key, new WeakRef(value));
        this.registry.register(value, key);
    }

    get(key) {
        let ref = this.cache.get(key);
        return ref ? ref.deref() : undefined;
    }
}

let cache = new SmartCache();

let user = { name: "Sandeep" };
cache.set("user1", user);

console.log(cache.get("user1")); // { name: "Sandeep" }

user = null; // Strong reference remove
// GC run hone ke baad cleanup trigger hoga

Advanced Features:

  • Ye low-level memory management ke liye hote hain.
  • Normal JavaScript developers ko rarely inki zarurat hoti hai.
  • Mostly library/framework developers inko use karte hain jaha performance critical hoti hai.

4. Key points :

  • WeakRef: Object ka weak reference banata hai jo GC ke delete karne se nahi rokta.
  • FinalizationRegistry: Object delete hone ke baad cleanup ka chance deta hai.
  • Dono ka timing non-deterministic hai (tum decide nahi kar sakte ki kab chalega).
  • Ye features tabhi use karo jab tumhe deep memory control chahiye.

Quiz: Test Your Knowledge on JavaScript WeakRef & FinalizationRegistry

Bonus: Practical Application!

Aaj hi JavaScript WeakRef & FinalizationRegistry ka use karke apne code ko memory-efficient banayein!

JavaScript WeakRef & FinalizationRegistry ko sahi tareeke se samajhne ke liye WeakRef(), .deref() aur FinalizationRegistry() jaise concepts ka upayog karein. Ye garbage collection ke baad automatic resource cleanup aur memory leak prevention jaise advanced features ko samajhne ke liye bahut important hote hain. Inka use karke aap sensitive data ko safely handle kar sakte hain aur background resources ko efficiently release kar sakte hain.

Leave a Reply