JavaScript Event Loop aur Promises samajhna har us developer ke liye zaroori hai jo frontend interviews crack karna chahta ho. Agar tumhe kabhi interview mein poocha gaya — “Event Loop kaise kaam karta hai?” ya “null aur undefined ka difference kya hai?” — aur tumne ghabrake kuch bhi bol diya, toh yeh post specifically tumhare liye hai.
Aaj hum SandeepStudy.com pe JavaScript ke teen sabse important topics cover karenge — Data Types, JavaScript Event Loop aur Promises. Yeh teeno milke JavaScript ki neenv hain. Ek baar yeh samajh gaye toh async code ka koi bhi sawaal tum confidently handle kar sakte ho.
Agar tumne abhi JavaScript ki basics nahi padhi toh pehle hamari JavaScript Basics Guide padho, phir yahan wapas aao.
Yaad raho: Sirf copy karna kaam nahi aata. Concept samjho, khud likhke dekhlo — tab interview mein confidence aayega.
JavaScript Data Types — Sab Kuch Store Kahan Hota Hai?
JavaScript mein jab bhi hum koi value likhte hain — number, text, true/false — JavaScript usse ek type mein categorize karta hai. Types basically JavaScript ko batate hain ki is value ke saath kaise behave karo. Yeh samajhna zaroori hai kyunki JavaScript Event Loop aur Promises ko theek se use karne ke liye pehle types ka strong base hona chahiye.
Types do main categories mein divided hain:
- Primitive Types — Simple, single values
- Non-Primitive (Reference) Types — Complex, multiple values
Primitive Types
Primitive types wo hote hain jo directly ek value store karte hain. Yeh immutable hote hain — matlab ek baar assign karne ke baad directly change nahi hote.
Number
Definition: Integer ya decimal number store karta hai.
Real-life scenario 1: Monthly salary store karna — let salary = 25000;
Real-life scenario 2: Game mein score track karna — let score = 87.5;
let age = 22; // Integer number — poori sankhya
let price = 499.99; // Floating point — decimal wali sankhya
let negative = -10; // Negative number bhi valid hai
console.log(typeof age); // Output: "number"
Common mistake: Beginners sochte hain ki "5" + 5 ka answer 10 hoga, but answer "55" hai kyunki string + number = string concatenation. Yeh type coercion hai — aage detail mein cover karenge.
Real projects mein use: API se price fetch karna, user age validate karna, cart total calculate karna.
String
Definition: Text data store karta hai. Single quotes, double quotes, ya backticks use hote hain.
Real-life scenario 1: User ka naam form mein — let name = "Sandeep";
Real-life scenario 2: Message text — let msg = "Bhai, kahan hai tu?";
let name = "Sandeep"; // Double quotes — standard string
let city = 'Delhi'; // Single quotes — bhi valid hai
let greeting = `Hello, ${name}!`; // Template literal — variable embed kar sakte ho
console.log(greeting); // Output: "Hello, Sandeep!"
console.log(typeof name); // Output: "string"
Common mistake: "5" aur 5 same lagte hain — ek string hai, ek number. Arithmetic operations mein unexpected results aayenge.
Boolean
Definition: Sirf do values — true ya false. Conditions aur decisions ke liye use hota hai.
Real-life scenario 1: User logged in hai ya nahi — let isLoggedIn = true;
Real-life scenario 2: Light switch on ya off — let lightOn = false;
let isLoggedIn = true; // User logged in hai — true
let isAdmin = false; // User admin nahi hai — false
if (isLoggedIn) {
console.log("Dashboard dikhao"); // Yeh line chalegi
} else {
console.log("Login page pe bhejo");
}
Null
Definition: Intentionally “koi value nahi” — developer ne khud assign kiya ki yahan value nahi hai.
Real-life scenario 1: Database se user fetch kiya, mila nahi — let user = null;
Real-life scenario 2: Car ki backseat mein koi passenger nahi — seat exist karti hai, value nahi.
let user = null; // Developer ne khud bola — "abhi koi user nahi"
console.log(user); // Output: null
console.log(typeof null); // Output: "object" — Yeh JavaScript ka ek purana bug hai!
Interview trap: typeof null === "object" returns karta hai — yeh JavaScript ka historical bug hai jo intentionally fix nahi kiya gaya because backward compatibility toot jaati. Interviewers isko specifically poochte hain.
Undefined
Definition: Jab koi variable declare kiya gaya ho but usse koi value assign nahi ki gayi — JavaScript khud default value deta hai.
Real-life scenario 1: Form mein optional field — user ne kuch nahi bhara.
Real-life scenario 2: Naya ghar — room hai, furniture nahi — room undefined state mein hai.
let address; // Declare kiya, value nahi di
console.log(address); // Output: undefined — JavaScript ne khud assign kiya
function greet(name) {
console.log(name); // Agar argument pass nahi kiya
}
greet(); // Output: undefined
Key difference — Null vs Undefined:
- Null: Developer ne intentionally khali chhodha — “yahan kuch nahi”
- Undefined: JavaScript ne khud assign kiya — “isko value mili hi nahi”
Symbol (ES6)
Definition: Har baar ek guaranteed unique value create karta hai. Object property keys ke liye use hota hai jahan collision avoid karni ho.
Real-life scenario: Har aadmi ka Aadhar number unique hota hai — same tarah Symbol bhi.
let id1 = Symbol("id"); // "id" sirf description hai — actual value unique hai
let id2 = Symbol("id");
console.log(id1 === id2); // Output: false — dono alag hain, chahe same label ho
Kahan use hota hai: React ke internals, Redux, aur library development mein.
BigInt (ES2020)
Definition: Bahut bade numbers store karne ke liye jab Number type ki limit cross ho jaaye.
Real-life scenario: Bank transactions mein nanosecond timestamps ya cryptocurrency calculations.
let bigNum = 9007199254740991n; // n suffix — BigInt hai
let normalNum = 9007199254740991; // Normal Number — yahan limit hai
console.log(typeof bigNum); // Output: "bigint"
Non-Primitive (Reference) Types
Non-primitive types memory mein ek reference (address) store karte hain, actual value nahi. Isiliye inhe Reference Types bhi kehte hain.
Object
Definition: Key-value pairs ka collection. Real duniya ki kisi bhi entity ko represent kar sakta hai.
Real-life scenario 1: Student ka data — naam, age, marks sab ek jagah.
Real-life scenario 2: E-commerce product card — name, price, rating, stock.
let student = {
name: "Rahul", // Key: name, Value: "Rahul"
age: 21, // Key: age, Value: 21
isPass: true // Key: isPass, Value: true
};
console.log(student.name); // Dot notation — Output: "Rahul"
console.log(student["age"]); // Bracket notation — Output: 21
console.log(typeof student); // Output: "object"
Array
Definition: Ordered list of values. Index 0 se start hota hai.
Real-life scenario 1: Shopping cart mein items ki list.
Real-life scenario 2: Class mein students ke naam ki list.
let fruits = ["Apple", "Mango", "Banana"]; // Array of strings
console.log(fruits[0]); // Output: "Apple" — 0-indexed
console.log(fruits.length); // Output: 3
console.log(typeof fruits); // Output: "object" — Array bhi object hota hai!
// Sahi tarika Array check karne ka:
console.log(Array.isArray(fruits)); // Output: true
Function
Definition: Reusable code block. JavaScript mein functions first-class citizens hain — variable mein store karo, argument mein pass karo, return karo.
Real-life scenario: ATM machine ka withdraw button — ek action jo bar-bar use hoti hai.
function add(a, b) { // Function declaration
return a + b; // Result return karta hai
}
let multiply = function(a, b) { // Function expression — variable mein store
return a * b;
};
let square = (n) => n * n; // Arrow function — ES6 shorthand
console.log(add(3, 4)); // Output: 7
console.log(typeof add); // Output: "function"
Type Conversion — JavaScript Ka Silently Badlne Wala Behavior
JavaScript mein values automatically ya manually ek type se doosre type mein convert ho sakti hain. Yeh interviews mein confusing output questions ka sabse bada source hai.
Implicit Conversion (Type Coercion)
JavaScript khud silently type convert kar deta hai — bina tumhare maange. Iske baare mein na jaanna bugs ka seedha source hai.
// String + Number = String (concatenation hoti hai addition nahi)
console.log("5" + 3); // Output: "53"
console.log("5" - 3); // Output: 2 — minus pe string number ban jaati hai
// Boolean to Number
console.log(true + 1); // Output: 2 — true internally 1 hai
console.log(false + 1); // Output: 1 — false internally 0 hai
// Special cases
console.log(null + 5); // Output: 5 — null = 0 treat hota hai
console.log(undefined + 5); // Output: NaN — undefined convert nahi hota
Explicit Conversion (Manual Type Casting)
Tum khud decide karte ho conversion kab karni hai — yeh production code ka sahi tarika hai.
// String se Number
let num = Number("42"); // Output: 42
let num2 = parseInt("42px"); // Sirf integer part — Output: 42
let num3 = parseFloat("3.14abc"); // Float part — Output: 3.14
// Number se String
let n = 100;
let s = String(n); // Output: "100"
let s2 = n.toString(); // Output: "100"
// To Boolean — falsy values yaad karo
console.log(Boolean(0)); // false
console.log(Boolean("")); // false — empty string
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN)); // false
console.log(Boolean([])); // true — empty array truthy hai!
console.log(Boolean({})); // true — empty object bhi truthy hai!
Interview mein yaad rakhne wali baat: Sirf 6 falsy values hain — 0, "", null, undefined, NaN, false. Baaki sab truthy. Empty array aur empty object truthy hain — yeh common gotcha hai.
JavaScript Event Loop aur Promises — Core Concept
JavaScript Event Loop aur Promises ko ek saath samajhna bahut zaroori hai. Pehle Event Loop clear karo, phir Promises automatically samajh mein aa jaayenge. Yeh do concepts ek doosre pe depend karte hain.
JavaScript Single-Threaded Kyun Hai?
JavaScript ek time pe sirf ek kaam kar sakta hai — ek hi thread hoti hai. Lekin phir bhi buttons click hote hain, animations chalti hain, API calls hoti hain sab simultaneously. Yeh sab Event Loop ki wajah se possible hai.
Event Loop ko visually samajhne ke liye MDN ka official Event Loop documentation padhna bahut helpful hai.
Real-Life Analogy — Restaurant Waiter
Socho ek restaurant hai. Ek akela waiter hai — yeh JavaScript Engine hai. Customer order deta hai — yeh tumhara code hai. Kuch items jaldi ready hote hain (synchronous code), kuch items kitchen mein time lagate hain (async — setTimeout, API calls). Waiter kitchen ka wait nahi karta — woh doosre customers serve karta rehta hai. Jab kitchen se food ready ho jaata hai tab waiter ko signal milta hai aur woh order deliver karta hai. Is poore system ka naam hai Event Loop.
Event Loop ke 4 Main Parts
Call Stack: Yahan JavaScript ka actual execution hota hai. LIFO (Last In, First Out) structure. Function call hoti hai — stack pe push hoti hai. Complete hoti hai — pop hoti hai. Yeh synchronous code ka ghar hai.
Web APIs: Browser ki extra powers — setTimeout, fetch, DOM events. JavaScript engine ka hissa nahi, browser provide karta hai. Async tasks yahan background mein handle hote hain jab tak Call Stack apna kaam karta rehta hai.
Callback Queue (Macrotask Queue): Jab Web API ka kaam complete ho jaata hai, uska callback yahan line mein lagta hai. setTimeout aur setInterval ke callbacks yahan aate hain.
Microtask Queue: Promise callbacks — .then(), .catch(), async/await — yahan jaate hain. Iska priority Callback Queue se zyada hoti hai. Call Stack khali hone ke baad pehle yeh poori queue khatam hoti hai, tab Callback Queue ka number aata hai.
Event Loop Execution Flow — Step by Step Code
console.log("1 — Start"); // Sync — Call Stack pe jaata hai, turant chalega
setTimeout(() => {
console.log("2 — setTimeout"); // Async — Web API handle karega
// Timer khatam hone ke baad Callback Queue mein jayega
}, 0);
Promise.resolve().then(() => {
console.log("3 — Promise"); // Async — Microtask Queue mein jayega
});
console.log("4 — End"); // Sync — turant chalega
/*
OUTPUT:
1 — Start
4 — End
3 — Promise <- Microtask Queue pehle
2 — setTimeout <- Callback Queue baad mein
*/
Step-by-step breakdown:
console.log("1")— Call Stack pe gaya, execute hua, pop huasetTimeout— Web API ko diya, background mein timer start. Callback Queue mein jayegaPromise.resolve().then(...)— Microtask Queue mein register huaconsole.log("4")— Call Stack pe gaya, execute hua- Call Stack khali — Event Loop ne Microtask Queue check kiya — Promise wala chala
- Microtask Queue bhi khali — Callback Queue check kiya — setTimeout wala chala
Golden Rule jo interview mein kaam aayega: Microtask Queue (Promises) hamesha Macrotask Queue (setTimeout) se pehle execute hoti hai — chahe dono ka delay 0ms ho.
JavaScript Promises — Callback Hell Ka Seedha Ilaaj
Pehle Samjho — Callback Hell Kyun Problem Tha?
JavaScript Event Loop aur Promises ka connection samajhne ke liye pehle yeh dekhna zaroori hai ki Promises kyun laaye gaye. Callbacks se kya problem thi:
// Callback Hell — yeh dekhke hi samajh jaate ho problem kya hai
getData(function(result1) {
processData(result1, function(result2) {
saveData(result2, function(result3) {
sendEmail(result3, function(result4) {
// Aur andar andar jaate raho...
console.log("Done!");
});
});
});
});
// Yeh code padhna, maintain karna, debug karna — sab mushkil
// Isse "Pyramid of Doom" bhi kehte hain
Promise Kya Hota Hai?
Real-life analogy: Zomato pe order dete ho — restaurant ne vaada kiya ki khaana aayega. Yeh ek promise hai. Teen possibilities hain — ya khaana aayega (fulfilled), ya order cancel hoga (rejected), ya abhi ban raha hai (pending).
Promise bhi exactly aisa hi kaam karta hai:
- Pending: Async operation abhi chal rahi hai — result nahi aaya
- Fulfilled: Operation successfully complete hui — data mil gaya
- Rejected: Operation fail ho gayi — error aa gaya
Promise Banao aur Use Karo
// Promise create karna
let myPromise = new Promise((resolve, reject) => {
// Yeh callback SYNCHRONOUSLY execute hota hai — async nahi!
// resolve — success pe call karo
// reject — failure pe call karo
let success = true;
if (success) {
resolve("Data fetch ho gaya!"); // Fulfilled state mein jaayega
} else {
reject("Kuch gadbad ho gayi!"); // Rejected state mein jaayega
}
// Jab tak koi result nahi — Pending state
});
// Promise consume karna
myPromise
.then((result) => {
// .then() — fulfilled hone pe chalta hai
console.log("Success:", result); // "Success: Data fetch ho gaya!"
return result + " — Processed!"; // Yeh value next .then() ko milegi
})
.then((processedResult) => {
// Promise chaining — pehle .then() ka return value yahan aaya
console.log("Processed:", processedResult);
})
.catch((error) => {
// .catch() — koi bhi rejection ya thrown error yahan aata hai
console.log("Error:", error);
})
.finally(() => {
// .finally() — success ho ya failure, hamesha chalega
// Loading spinner hide karo, cleanup karo yahan
console.log("Operation complete — result kuch bhi ho");
});
Real Project Example — fetch() API Call
function getUserData(userId) {
return fetch(`https://api.example.com/users/${userId}`)
// fetch() ek Promise return karta hai
.then((response) => {
if (!response.ok) {
// Error throw karo — .catch() pakd lega
throw new Error("User nahi mila — status: " + response.status);
}
return response.json(); // Yeh bhi ek Promise return karta hai
})
.then((data) => {
// Dono Promises resolve ho gayi — final data yahan hai
console.log("User ka naam:", data.name);
return data;
})
.catch((error) => {
// Network error ya throw kiya hua koi bhi error
console.error("Error aaya:", error.message);
})
.finally(() => {
// Page pe loading indicator band karo
console.log("Loading band karo!");
});
}
getUserData(1);
Promise vs Callback — Comparison Table
| Feature | Callback | Promise |
|---|---|---|
| Readability | Nested callbacks — code messy aur unreadable | Chain karo — flat, clean aur readable |
| Error Handling | Har callback mein alag se handle karo | Single .catch() poori chain handle karta hai |
| Chaining | Deeply nested — maintain karna mushkil | Aasaan — .then().then().then() |
| Multiple Async | Complex aur error-prone | Promise.all(), Promise.race() available |
| Modern Code | Legacy code mein milte hain | Standard — async/await ka base bhi yahi hai |
| State Tracking | Koi state nahi hoti | Pending, Fulfilled, Rejected — clearly defined |
JavaScript Event Loop aur Promises — Interaction Kaise Hoti Hai?
Ab sabse important part — JavaScript Event Loop aur Promises ek saath kaise kaam karte hain. Yeh samajhna interview mein sabse zyada kaam aata hai.
console.log("A"); // Sync — turant
setTimeout(() => {
console.log("B"); // Macrotask — Callback Queue
}, 0);
Promise.resolve()
.then(() => {
console.log("C"); // Microtask — Microtask Queue
})
.then(() => {
console.log("D"); // Microtask — abhi bhi Microtask Queue mein
});
console.log("E"); // Sync — turant
/*
OUTPUT:
A
E
C
D
B
Kyun?
- A, E — Synchronous hai, Call Stack pe direct chalta hai
- C, D — Promise .then() callbacks — Microtask Queue — A aur E ke baad, B se pehle
- B — setTimeout — Macrotask Queue — Microtasks khatam hone ke baad
*/
Practical Example — Output Predict Karo (Common Interview Question)
Yeh exact type ka code interview mein milta hai. Output predict karne ke liye JavaScript Event Loop aur Promises dono ka concept clear hona chahiye.
console.log("Script start");
setTimeout(() => {
console.log("setTimeout 1"); // Macrotask
}, 0);
setTimeout(() => {
console.log("setTimeout 2"); // Macrotask — 100ms baad
}, 100);
Promise.resolve()
.then(() => {
console.log("Promise 1 - then 1"); // Microtask
return "chained_value";
})
.then((val) => {
console.log("Promise 1 - then 2:", val); // Microtask
});
new Promise((resolve) => {
console.log("Promise 2 executor"); // SYNC — constructor ka callback turant chalta hai
resolve();
}).then(() => {
console.log("Promise 2 - then"); // Microtask
});
console.log("Script end");
/*
OUTPUT:
Script start
Promise 2 executor <- new Promise() ka executor SYNC hai!
Script end <- Baaki synchronous code
Promise 1 - then 1 <- Microtasks shuru
Promise 1 - then 2: chained_value
Promise 2 - then <- Microtasks khatam
setTimeout 1 <- Macrotasks shuru
setTimeout 2 <- 100ms ke baad
*/
Sabse important point: new Promise((resolve, reject) => { ... }) ke andar ka code synchronously execute hota hai. Sirf .then() ka callback Microtask Queue mein jaata hai. Yeh point interview mein almost hamesha poochha jaata hai.
Common Mistakes — Jo Beginners Karte Hain
- typeof null === “object” pe confuse hona
Yeh JavaScript ka bug hai. Null check karne ke liye hameshavalue === nulluse karo. - Promise executor ko async samajhna
new Promise() ka callback turant synchronously execute hota hai. Sirf .then() async hai. - Microtask vs Macrotask priority bhoolna
JavaScript Event Loop mein Promises hamesha setTimeout se pehle chalte hain — chahe delay 0ms ho. - “5” + 5 = 10 samajhna
String + Number = String concatenation. Answer “55” hai, 10 nahi. - Array.isArray() na use karna
typeof [] returns “object”. Array check karne ka sahi tarika Array.isArray() hai. - Promise chaining mein return bhoolna
Agar .then() mein return nahi kiya toh next .then() ko undefined milega — bug aa jaayega. - .catch() na lagana
Har Promise chain mein .catch() hona chahiye. Bina iske unhandled rejection error aata hai.
Top 15 Interview Questions — JavaScript Event Loop aur Promises
Yeh questions 90% JavaScript interviews mein milte hain — startups se lekar product companies tak. In sabka answer confidently dena seekho.
Q1. JavaScript mein kitne data types hote hain?
Answer: JavaScript mein 8 data types hote hain. 7 Primitive: Number, String, Boolean, Null, Undefined, Symbol, BigInt. Ek Non-Primitive: Object — jisme Array aur Function bhi include hain. Primitive types stack mein directly store hote hain. Object types heap mein store hote hain aur reference stack mein hota hai.
Q2. null aur undefined mein kya difference hai?
Answer: undefined tab hota hai jab JavaScript khud variable ko default value assign karta hai kyunki developer ne value nahi di. null developer ne intentionally assign kiya — matlab “koi value nahi hai.” Dono falsy hain. typeof null “object” return karta hai — yeh JavaScript ka known historical bug hai.
Q3. == aur === mein kya fark hai?
Answer: == loose equality hai — pehle type conversion karta hai phir compare karta hai, isiliye “5” == 5 true hota hai. === strict equality hai — type aur value dono same hone chahiye, isiliye “5” === 5 false hota hai. Production code mein hamesha === use karo.
Q4. JavaScript ka Event Loop kya hota hai?
Answer: JavaScript single-threaded hai. Event Loop woh mechanism hai jo Call Stack, Web APIs, Microtask Queue aur Macrotask Queue ko coordinate karta hai. Jab Call Stack khali hoti hai, Event Loop pehle Microtask Queue (Promise callbacks) check karta hai — poori khatam karta hai — phir Macrotask Queue (setTimeout) se ek task leta hai. Yeh cycle continuously chalta rehta hai.
Q5. Microtask Queue aur Callback Queue mein kya difference hai?
Answer: Microtask Queue mein Promise callbacks (.then(), .catch(), queueMicrotask) jaate hain. Callback Queue (Macrotask Queue) mein setTimeout, setInterval aur I/O events jaate hain. Priority order: Call Stack empty hone ke baad poori Microtask Queue khatam hoti hai, tab Macrotask Queue se sirf ek task liya jaata hai. Isliye Promise hamesha setTimeout se pehle execute hoti hai.
Q6. Promise kya hota hai?
Answer: Promise ek object hai jo kisi async operation ke future result ko represent karta hai. Teen states hoti hain: Pending (chal raha hai), Fulfilled (successfully complete), Rejected (fail ho gayi). .then() success handle karta hai, .catch() error handle karta hai, .finally() dono cases mein chalta hai.
Q7. Promise chaining kya hoti hai?
Answer: Jab .then() mein koi value return karo aur us pe dobara .then() lagao — yeh Promise chaining hai. Isse sequential async operations flat aur readable rahengi. Zaroori hai ki har .then() mein return likho — nahi toh next .then() ko undefined milega.
Q8. Promise.all() kya karta hai?
Answer: Promise.all([p1, p2, p3]) saari promises parallel mein run karta hai aur tab resolve hota hai jab sab fulfilled ho jaayein. Agar koi ek bhi reject ho gayi toh poora Promise.all() reject ho jaata hai — fail-fast behavior. Jab multiple async operations ke results ek saath chahiye hon tab use karo.
Q9. async/await aur Promises mein kya difference hai?
Answer: async/await Promises ke upar ek syntactic sugar hai. Code synchronous style mein likhte hain par execution async hoti hai. await Promise resolve hone ka wait karta hai. Error handling ke liye try/catch use hota hai instead of .catch(). Internally dono same hain — async/await sirf zyada readable aur maintainable hai.
Q10. typeof null kya return karta hai aur kyun?
Answer: typeof null “object” return karta hai — yeh JavaScript ka original bug hai jo pehle version se chal raha hai. Null asal mein primitive type hai. Fix isliye nahi kiya gaya kyunki bahut saara existing code is behavior pe depend karta hai. Proper null check ke liye value === null use karo.
Q11. Falsy values JavaScript mein kaunsi hain?
Answer: Sirf 6 falsy values hain: 0, “” (empty string), null, undefined, NaN, false. Baaki sab truthy hain — [] (empty array) aur {} (empty object) bhi truthy hain. Yeh interview mein sabse common trap hai.
Q12. Call Stack kya hota hai?
Answer: Call Stack JavaScript engine ka data structure hai jahan function execution track hoti hai. LIFO (Last In, First Out) — function call hoti hai toh push, complete hoti hai toh pop. Agar recursion se stack overflow ho jaaye — “Maximum call stack size exceeded” error aata hai.
Q13. Promise.race() kya karta hai?
Answer: Promise.race([p1, p2, p3]) — jo pehli Promise settle ho uska result return karta hai, baaki ignore. Use case: timeout implement karna — agar 5 seconds mein API response nahi aaya toh timeout promise win kare.
Q14. NaN kya hota hai?
Answer: NaN — “Not a Number” — tab aata hai jab invalid mathematical operation hoti hai jaise “abc” * 2. typeof NaN “number” return karta hai — NaN number type ki value hai. NaN === NaN returns false — NaN khud se bhi equal nahi hota. Check ke liye Number.isNaN(value) use karo.
Q15. Is code ka output kya hoga?
console.log(typeof undefined); // ?
console.log(typeof null); // ?
console.log(null == undefined); // ?
console.log(null === undefined); // ?
Answer:
- typeof undefined — “undefined”
- typeof null — “object” (JavaScript bug)
- null == undefined — true (loose equality — dono “empty” concept hain)
- null === undefined — false (strict equality — alag types hain)
Conclusion — Aaj Kya Seekha?
Aaj tumne JavaScript ke kuch sabse important interview topics cover kiye. Summary yahan hai:
- JavaScript ke 8 data types hain — 7 primitive, 1 non-primitive (Object)
- null vs undefined — ek intentional, ek JavaScript ka default
- Type coercion silently hoti hai — hamesha === use karo
- JavaScript Event Loop = Call Stack + Web APIs + Microtask Queue + Macrotask Queue
- JavaScript Event Loop mein Microtasks (Promises) hamesha Macrotasks (setTimeout) se pehle chalte hain
- new Promise() ka executor synchronous hota hai — sirf .then() async hai
- Promises ne Callback Hell solve kiya — cleaner, chainable, error-safe code milta hai
- async/await Promise ka hi readable syntax hai — internally same kaam karta hai
JavaScript Event Loop aur Promises pe mastery frontend interviews mein directly kaam aati hai — Amazon, Flipkart, Razorpay, Zomato jaise companies mein yeh topic almost guarantee poochha jaata hai. In concepts ko ek baar khud se likhke run karo — tab yeh permanent yaad ho jaayenge.
Har ek line jo aaj tune padhi, woh kal tere interview mein kaam aayegi. Code likhna band mat karo — confusion normal hai, clarity practice se aati hai. Tu kar sakta hai.
Thank you SandeepStudy.com ke saath jude rehne ke liye. Agar yeh post helpful laga toh subscribe karo aur apne doston ke saath share karo. Agle post mein async/await deep dive aur real project examples cover karenge. Koi doubt ho toh comment mein poochho.
