Why async code doesn't wait in forEach loop

🧠 Mastering Logical Operators in JavaScript Whether you're debugging conditions or building smarter workflows, understanding logical operators is a must for every developer. Here’s a quick breakdown: 🔹 && (AND): All conditions must be true 🔹 || (OR): At least one condition must be true 🔹 ! (NOT): Inverts the boolean value 🔹 ?? (Nullish Coalescing): Returns the right-hand value if the left is null or undefined 💡 Example: const user = null; const name = user ?? "Guest"; // Output: "Guest" These operators are the backbone of decision-making in JavaScript. Whether you're validating forms, controlling access, or setting defaults—logic matters. 👨💻 Tip for beginners: Practice with real-world scenarios like login checks, feature toggles, or fallback values. #JavaScript #WebDevelopment #CodingTips #LogicalOperators #FrontendDev #TechLearning #AsifCodes

🟦 Day 177 of #200DaysOfCode Today, I revisited a key JavaScript concept — checking whether a property exists inside an object. What I practiced: I built a function that: ✅ Takes dynamic user input to create an object ✅ Asks for a property name ✅ Uses hasOwnProperty() to verify its existence 🧠 Why this is important? In real-world development, objects often store huge chunks of data such as: • User details • Configuration data • API responses • App state (React / Redux) Before accessing properties, it’s important to verify they exist — otherwise, we risk runtime errors or unexpected behavior. 📌 Core Takeaways • hasOwnProperty() is the most reliable way to check for direct properties • Helps in safely accessing nested or optional values • Useful for data validation & defensive coding 💡 This was a great reminder that strong fundamentals make us better at handling complex situations later. Logic remains the backbone of clean & safe code. #JavaScript #177DaysOfCode #LearnInPublic #ProblemSolving #WebDevelopment #CodingChallenge #DeveloperMindset #ObjectsInJS #LogicBuilding

When everything else fails in 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁… Try going back to the basics 👇 I spent today revising some core concepts and honestly, it reminded me how small fundamentals make big differences in coding: 𝟭. 𝗢𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 𝗮𝗿𝗲𝗻’𝘁 𝗷𝘂𝘀𝘁 𝘀𝘆𝗺𝗯𝗼𝗹𝘀. They decide how your code thinks and reacts from arithmetic (+, -, %) to logical (&&, ||). 𝟮. 𝗛𝗼𝗶𝘀𝘁𝗶𝗻𝗴 𝗶𝘀𝗻’𝘁 𝗺𝗮𝗴𝗶𝗰, 𝗶𝘁’𝘀 𝗼𝗿𝗱𝗲𝗿. var gets hoisted (declared but undefined), let and const are hoisted too but live in a “temporal dead zone.” 𝟯. 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 𝗹𝗼𝘃𝗲 𝘁𝗵𝗲 𝘀𝗽𝗼𝘁𝗹𝗶𝗴𝗵𝘁. Declarations are hoisted fully. Expressions? Not so much & they wait for their turn! It’s wild how a simple console.log() before a variable can teach you why order matters in JavaScript. Besides... When did debugging become about guessing? 😄 It’s really about understanding how JavaScript reads your code line by line. 𝗣.𝗦. Which JavaScript concept confused you most when you started? #Frontend #Webdevelopment #Javascript #Developer #Cohort2 #Learningjourney #Fundamental

✨Day 6/28 Consistency Challenge ✨ 🚀 Today’s Lesson: Escaping Callback Hell in JavaScript! **Ever found yourself nesting callbacks inside callbacks… until your code starts looking like a staircase to chaos? **Yeah, that’s callback hell — where your code becomes so deeply nested it’s hard to read, debug, or maintain. 💡 What I learned today: Callback hell happens when multiple async functions depend on each other, and everything’s chained inside one another. Callback nesting -> Callback hell. ✅ How to prevent it: ✍️Use Promises to flatten the chain ✍️Switch to async/await for cleaner, more readable code ✍️Keep functions modular and avoid deeply nested logic ✨ Lesson of the day: Clean code isn’t just about making it work — it’s about making it make sense. #JavaScript #CodingJourney #Webdevelopment #EverydayLearning

Day 9 of #30DaysOfJavaScript: Mastering Function Execution Control with Closures! 🔐 Today I solved an interesting problem that pushed me to create a function wrapper called once. This wrapper ensures the original function runs only one time, no matter how many times it’s called afterwards—any further calls simply return undefined. This challenge deepened my understanding of JavaScript closures and how they can be used to preserve state and control function execution flow. Here’s my implementation: javascript function once(fn) { let called = false; let res; return function(...args) { if (!called) { called = true; res = fn(...args); return res; } return undefined; }; } Why this matters: Enables safer function calls by preventing unintended multiple executions. Useful pattern in scenarios like event handling, API calls, or initialization. Showcases how closures can encapsulate state elegantly in JavaScript. Excited to keep building on these foundational concepts and to see what Day 10 has in store! If you're on a similar learning path, let’s connect to share insights and grow together. #JavaScript #Closures #FunctionalProgramming #LeetCode #CodingChallenge #WebDevelopment #SoftwareEngineering #LearningJourney

I ran this JavaScript snippet, and the output completely surprised me 😳. Day 10: How JavaScript actually handles a async operations ⚙️. 🧠 Logic: 🔹 JS execution always starts with synchronous code -> so "start", "First" & "end" log first. 🔹 Inside the loop, setTimeout is added to macrotask queue (it will run later). 🔹 Promise.then() is added to microtask queue (these will run right after sync code), cause of high priority then macrotask queue. 🔹 Inside asyncFn(), when execution hits await it pauses that function exec & waits for promise to get resolve. 🔹 In the mean time, event Loop continue with promise callback in microTask, one it's completed, the promise get resolved in asyncFn() & then it prints ("Second") to console. 🔹 And the last, the setTimeout callback in macroTask queue gets executed. So:  ✅ Promise run first (microTasks). ⏱️ SetTimeout run after (macroTasks). That's why promise 0, promise 1, promise 2, and Second appear before all TimeOut logs. #Javascript #InterviewPrep  #100DaysOfCode #CodingChallenge  #JavaScript #CodingInterview #JSChallenges

🚀 Day 10 of My 30 Days of JavaScript Challenge 🧩 Problem: Allow One Function Call (LeetCode #2666) Given a function fn, return a new function that ensures fn can only be called once. The first call returns the actual result, and every subsequent call returns undefined. 💻 Language: JavaScript 📖 Problem Link: https://lnkd.in/epnrfahZ 💡 Solution: https://lnkd.in/eGQKWkEk 🧠 Concepts Used Closures to store state (whether function is already called) Function Wrapping Higher-Order Functions 📚 Takeaway This problem is a great example of how closures preserve state between function calls — an essential concept for: Memoization API rate-limiting Event listener control #Day10 #JavaScript #30DaysOfCode #LeetCode #WebDevelopment #CodingChallenge #Closures #FrontendDevelopment #100DaysOfCode

JavaScript Gotcha #2: The Vanishing "this" in my callback I was working on a component that fetched user data and updated the UI. Simple stuff — until I noticed that inside one of my callbacks, "this" suddenly became undefined. My code looked something like this: Check Picture. Everything seemed fine… until that console log. Turns out, regular functions don’t retain the class context — this was no longer pointing to my instance. Fix: use an arrow function so this stays lexical. Lesson learned: In JavaScript, this doesn’t mean what you think it means — especially inside callbacks. Arrow functions don’t just look clean; they save your scope. Follow me for more real-world JavaScript gotchas and the lessons they taught me. What’s your most confusing "this" moment?

This small bug taught me more than 10 tutorials ever could. While building a simple counter in JavaScript, I couldn’t figure out why my value wasn’t updating correctly. I checked syntax, re-ran the code, even blamed my browser — everything looked fine. After 2 hours of debugging, I realized the problem wasn’t the logic, it was the order. I was updating the UI before updating the data. It sounds small, but this one bug taught me three big lessons: - Understand how JavaScript executes before fixing symptoms. - Debugging is 80% reasoning, 20% code. - Building > watching tutorials. Mistakes like this are what actually make you better. #JavaScript #WebDevelopment #Frontend #CodingJourney #LearningByDoing

🔄 Day 164 of #200DaysOfCode Today, I revisited another classic JavaScript problem — removing duplicates from an array without using Set() or advanced methods. 💡 While there are modern one-liners that can handle this task in seconds, manually writing the logic helps build a deeper understanding of how arrays, loops, and conditions work together. This small challenge reinforced two key lessons: 1️⃣ Efficiency matters — Writing logic by hand makes you think about time complexity and performance. 2️⃣ Simplicity is strength — The most effective solutions are often the ones built from fundamental principles. 🔁 As developers, it’s not just about knowing shortcuts — it’s about understanding the why behind every concept. Revisiting such basic problems sharpens logical thinking and improves our ability to write cleaner, more optimized code. 🌱 Mastering the basics is not a step backward — it’s the foundation for everything advanced. #JavaScript #CodingChallenge #BackToBasics #164DaysOfCode #LearnInPublic #DeveloperMindset #WebDevelopment #ProblemSolving #CodingJourney