Aman Raj’s Post

Day-3 Event Loop JavaScript Event Loop — The Real Reason Async Code Works JavaScript is single-threaded, yet it handles timeouts, promises, APIs, and user actions without blocking. How? 👉 The Event Loop .Let’s break it down simply 👇 🧠 JavaScript has: Call Stack – Executes synchronous code Web APIs – Handles async tasks (setTimeout, fetch, DOM events) Callback / Task Queue – setTimeout, setInterval Microtask Queue – Promises, MutationObserver Event Loop – The coordinator 🔁 🔄 How it actually works: 1️⃣ JS executes sync code in the Call Stack 2️⃣ Async code moves to Web APIs 3️⃣ When ready: Promises → Microtask Queue setTimeout → Callback Queue(Macrotasks Queue) 4️⃣ Event Loop checks: Is Call Stack empty? Run ALL microtasks first Then pick one task from callback queue ⚠️ Important Interview Rule: 👉 Microtasks always run before Macrotasks console.log("start"); setTimeout(() => console.log("timeout"), 0); Promise.resolve().then(() => console.log("promise")); console.log("end"); ✅ Output: start end promise timeout 💡 Because Promise → Microtask Queue and Microtasks have higher priority #JavaScript #EventLoop #AsyncJS #Frontend #WebDevelopment #JSInterview

Ever wondered how JavaScript remembers variables even after a function has finished execution? It's The magic of Closure.  A closure gives a function access to its outer scope. In JavaScript, closures are created every time a function is created, at function creation time. Example: function outer() {  let count = 0;  return function inner() {   count++;   console.log(count);  }; } const counter = outer(); counter(); Result => 1 counter(); Result => 2 counter(); Result => 3 Explanation: Inner function remembers count from outer. Every time you call counter(), it retains the previous value. Usefulness of Closure: => Data encapsulation (private variables) => Memoization / caching => Event handlers & async callbacks Do you use closures in your projects? Share your use case below! #JavaScript #WebDevelopment #Closures #ReactJS #NexjJS #MERNStack #CodingTips

Understanding why `Promise.all()` needs an array in JavaScript Many developers try this and get confused 👇 ❌ Wrong way Promise.all(p1, p2); ✅ Correct way Promise.all([p1, p2]); 🤔 Why does this happen? Promise.all() accepts only ONE argument, and that argument must be an iterable (most commonly an array). 👉 An array allows JavaScript to loop through multiple promises and wait for all of them to resolve.  ✅ Working example let p1 = new Promise((resolve) => {   resolve(1); }); let p2 = new Promise((resolve) => {   resolve(2); }); Promise.all([p1, p2]) .then((data) => {   console.log(data); // [1, 2] }); ❌ Why `Promise.all(p1, p2)` throws an error? When you write: Promise.all(p1, p2); JavaScript treats it as: Promise.all(p1); But p1 is a "Promise object", not an iterable like an array. So JS throws: TypeError: object is not iterable  🧠 Easy way to remember > Promise.all waits for a collection of promises, not individual ones Always wrap promises inside an array.  ⚠️ One more important thing If any promise rejects, Promise.all() immediately rejects. Promise.all([Promise.resolve(1), Promise.reject("Error")]) .catch(console.error); // Error 💡 Hope this helps someone avoid a common JavaScript pitfall! . . . . . #SRYTAL #JavaScript #Promises #WebDevelopment #Frontend #Learning #Promise.all #Growtogether

🚀 JavaScript Event Loop – The Real Game Changer Behind Async Code Most developers use setTimeout, Promises, or async/await daily… But very few truly understand what’s happening behind the scenes. Let’s break down the JavaScript Event Loop 👇 🧠 First, Understand This: JavaScript is single-threaded. It has: • Call Stack • Web APIs (Browser / Node environment) • Microtask Queue • Macrotask Queue • Event Loop 📌 How It Works: 1️⃣ Code runs line by line in the Call Stack. 2️⃣ Async operations move to Web APIs. 3️⃣ When completed, they move to: • Microtask Queue → Promise.then, catch, finally • Macrotask Queue → setTimeout, setInterval 4️⃣ Event Loop checks: • Is Call Stack empty? • If yes → Run ALL Microtasks first • Then run ONE Macrotask • Repeat 💡 Example: console.log("Start"); setTimeout(() => { console.log("Timeout"); }, 0); Promise.resolve().then(() => { console.log("Promise"); }); console.log("End"); 👉 Output: Start End Promise Timeout Why? Because Microtasks (Promises) always execute before Macrotasks (setTimeout). 🎯 Why This Matters: Understanding the Event Loop helps you: • Debug async issues • Improve performance • Build real-time applications • Crack senior-level JavaScript interviews 🔥 Advanced Insight: In engines like V8 (used in Chrome and Node.js): • Call Stack uses stack memory • Objects are stored in heap memory • Garbage Collector cleans unused memory • Event Loop coordinates task execution JavaScript feels multi-threaded… But it's actually an illusion created by the Event Loop. If you had to explain it in one sentence: “The Event Loop is the traffic controller of asynchronous JavaScript.” #javascript #webdevelopment #nodejs #reactjs #async #eventloop #programming #softwareengineering

JavaScript Event Loop – Simple Explanation JavaScript is single-threaded. It can do only one task at a time. So how does it handle async tasks like: setTimeout fetch Promises 👉 Answer: Event Loop 🧠 Step by Step: 1️⃣ Synchronous code runs in the Call Stack 2️⃣ Async tasks go to Web APIs 3️⃣ When completed: Promises → Microtask Queue (High Priority) setTimeout → Callback Queue (Low Priority) 4️⃣ Event Loop checks: If Call Stack is empty → First runs Microtasks → Then runs Callback tasks Example: console.log("Start"); setTimeout(() => console.log("Timeout"), 0); Promise.resolve().then(() => console.log("Promise")); console.log("End"); ✅ Output: Start End Promise Timeout Because Promises run before setTimeout 🔥 Understanding Event Loop = Strong JavaScript foundation 💪 #JavaScript #Frontend #ReactJS #WebDevelopment #CodingInterview

Understanding why Promise.all() needs an array in JavaScript Many developers try this and get confused 👇 ❌ Wrong way Promise.all(p1, p2); ✅ Correct way Promise.all([p1, p2]); 🤔 Why does this happen? Promise.all() accepts only ONE argument, and that argument must be an iterable (most commonly an array). 👉 An array allows JavaScript to loop through multiple promises and wait for all of them to resolve.  ✅ Working example let p1 = new Promise((resolve) => {   resolve(1); }); let p2 = new Promise((resolve) => {   resolve(2); }); Promise.all([p1, p2]) .then((data) => {   console.log(data); // [1, 2] }); ❌ Why `Promise.all(p1, p2)` throws an error? When you write: Promise.all(p1, p2); JavaScript treats it as: Promise.all(p1); But p1 is a "Promise object", not an iterable like an array. So JS throws: TypeError: object is not iterable  🧠 Easy way to remember > Promise.all waits for a collection of promises, not individual ones Always wrap promises inside an array.  ⚠️ One more important thing If any promise rejects, Promise.all() immediately rejects. Promise.all([Promise.resolve(1), Promise.reject("Error")]) .catch(console.error); // Error 💡 Hope this helps someone avoid a common JavaScript pitfall! . . . . . #SRYTAL #JavaScript #Promises #WebDevelopment #Frontend #Learning #Promise.all #Growtogether

🚀 Event Loop Deep Dive — How JavaScript Really Executes Your Code Most developers use async JavaScript every day… but very few truly understand how it actually works under the hood. JavaScript is single threaded, yet it handles: • API calls • timers • promises • user interactions So what’s the secret? 👉 The Event Loop I just published a deep-dive article where I break this down step by step: ✔ How JavaScript executes synchronous code ✔ What really happens inside the Call Stack ✔ Global Execution Context explained visually ✔ Microtasks vs Macrotasks (Promises vs setTimeout) ✔ Why execution order surprises even experienced devs No shortcuts. No magic. Just how JavaScript really works. If you’ve ever been confused by execution order or faced weird async bugs this one’s for you. 📖 Read the full article here: 🔗 https://lnkd.in/dbUCv6N5 #JavaScript #EventLoop #WebDevelopment #Frontend #SoftwareEngineering #AsyncJS #React #NodeJS

𝗪𝗲𝗹𝗰𝗼𝗺𝗲 𝘁𝗼 𝗗𝗮𝘆 𝟴 Have you ever seen JavaScript behave correctly… but still give the wrong output? 🤔 𝘉𝘦𝘧𝘰𝘳𝘦 𝘴𝘤𝘳𝘰𝘭𝘭𝘪𝘯𝘨, 𝘨𝘶𝘦𝘴𝘴 𝘵𝘩𝘦 𝘰𝘶𝘵𝘱𝘶𝘵 𝘰𝘧 𝘵𝘩𝘪𝘴 𝘴𝘪𝘮𝘱𝘭𝘦 𝘤𝘰𝘥𝘦 𝚏𝚘𝚛 (𝚟𝚊𝚛 𝚒 = 𝟷; 𝚒 <= 𝟹; 𝚒++) {  𝚜𝚎𝚝𝚃𝚒𝚖𝚎𝚘𝚞𝚝(() => {   𝚌𝚘𝚗𝚜𝚘𝚕𝚎．𝚕𝚘𝚐(𝚒);  }, 𝟷𝟶𝟶𝟶); } 𝗘𝘅𝗽𝗹𝗲𝗰𝘁𝗲𝗱 1, 2, 3 𝗔𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗿𝗲𝘀𝘂𝗹𝘁 4,4,4 𝗧𝗵𝗶𝘀 𝗶𝘀 𝗮 𝗰𝗹𝗼𝘀𝘂𝗿𝗲 𝗯𝘂𝗴 — 𝗼𝗻𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗰𝗼𝗺𝗺𝗼𝗻 (𝗮𝗻𝗱 𝗰𝗼𝗻𝗳𝘂𝘀𝗶𝗻𝗴) 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗽𝗶𝘁𝗳𝗮𝗹𝗹𝘀. 𝗪𝗵𝘆 𝗧𝗵𝗶𝘀 𝗛𝗮𝗽𝗽𝗲𝗻𝘀 • var is function-scoped • setTimeout creates a closure • All callbacks reference the same variable i • When they execute, the loop has already finished Closures don’t capture values — they capture references. 𝗧𝗵𝗲 𝗙𝗶𝘅 𝚏𝚘𝚛 (𝚕𝚎𝚝 𝚒 = 𝟷; 𝚒 <= 𝟹; 𝚒++) {  𝚜𝚎𝚝𝚃𝚒𝚖𝚎𝚘𝚞𝚝(() => {   𝚌𝚘𝚗𝚜𝚘𝚕𝚎．𝚕𝚘𝚐(𝚒);  }, 𝟷𝟶𝟶𝟶); } 𝗪𝗵𝘆 𝘁𝗵𝗶𝘀 𝘄𝗼𝗿𝗸𝘀: • let is block-scoped • Each iteration gets its own binding • Each closure remembers a different i 𝗬𝗼𝘂’𝗹𝗹 𝘀𝗲𝗲 𝘁𝗵𝗶𝘀 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 𝗶𝗻: • Event handlers • Async loops • API callbacks • Timers • React effects If you don’t understand closures, You don’t see the bug — you just debug longer. #JavaScript #JSFundamentals #Closures #FrontendDevelopment #WebDevelopment #BugFixing #ReactJS #LearningInPublic

🤔 Quick question: When JavaScript runs async code, where does everything actually go? After learning about the Call Stack and Event Loop, I realized something important: JavaScript doesn’t work alone — it collaborates with Web APIs and queues 👇 --------------------------- console.log("Start"); setTimeout(() => {  console.log("Timeout"); }, 0); console.log("End"); ---------------------------- Output: - Start - End - Timeout 💡 What happens behind the scenes? - console.log("Start") → pushed to the Call Stack - setTimeout → handed off to Web APIs - console.log("End") → runs immediately Once the Call Stack is empty: - Event Loop checks the Task Queue - setTimeout callback is pushed back to the stack - Callback executes How the pieces fit together Call Stack → executes JavaScript Web APIs → handle timers, DOM events, network calls Queues → hold callbacks waiting to run Event Loop → coordinates everything Takeaway JavaScript executes code using the Call Stack, offloads async work to Web APIs, and uses the Event Loop to decide when callbacks can run. #JavaScript #WebDevelopment #FullStack #LearningInPublic