JavaScript Fundamentals: Understanding undefined, ==, ===, Scope, Hoisting & Closures

🚀Day 3/100 #100DaysOfCode — JavaScript Core Foundations Today, I revised the fundamentals that actually control how JavaScript behaves under the hood. 🔹 Execution Context JavaScript runs in two phases inside the Global Execution Context: 1️⃣ Creation Phase Memory allocated var → initialized as undefined let & const → hoisted but placed in the Temporal Dead Zone (TDZ) 2️⃣ Execution Phase Code executes line by line Variables receive real values 🔹 var vs let vs const var is hoisted with undefined let & const are hoisted but inaccessible before declaration (TDZ) var allows re-declaration let & const do not var & let allow reassignment const does not var is function-scoped let & const are block-scoped 🔹 Arrow Functions Not hoisted like traditional functions No own this (inherits lexically) Cleaner implicit return const sum = (a, b) => a + b; 🔹 Rest & Spread Rest → collects remaining parameters into an array Spread → expands array elements 🔹 Destructuring Cleaner extraction from arrays & objects: let { name: myName, address: { city } } = person; Understanding execution context + scope is the foundation for closures, async JS, and advanced patterns. No shortcuts. Just depth. Day 4 tomorrow. #JavaScript #WebDev #IntermediateJS #CodingChallenge #Frontend #SoftwareEngineering #MERNStack #LearningEveryday

Things I wish someone had drawn out for me when I was starting with JavaScript. A lot of engineers write JS for years without really knowing what happens after they hit run. How does the code actually execute? What's the JS engine doing? Why does async code behave the way it does? Why does setTimeout sometimes feel unpredictable? It all makes sense once you see the full picture. Here's what these notes cover: The JS Runtime Environment — engine, call stack, memory heap, and how execution contexts are created and destroyed. The Event Loop, how it continuously monitors the call stack and decides what runs next. Callback Queue vs Microtask Queue, why Promises behave differently from setTimeout, and why microtasks always go first. JIT Compilation, how V8 interprets and optimises your code on the fly. Web APIs and the Browser, where setTimeout, DOM APIs, fetch, and localStorage actually live. Once this clicked for me, a lot of "weird" JavaScript behaviour stopped feeling weird. If you're learning JS right now, save this. Come back to it when async starts feeling confusing. What part of JavaScript took you the longest to truly understand? #JavaScript #WebDevelopment #Frontend #LearnToCode

🚀 From Confused to Confident in JavaScript Every developer starts with excitement. At first, JavaScript feels easy — let, const, loops, functions… all simple. Then Hoisting appears. Why is the variable undefined even before it’s assigned? Then comes Closure. How does a function remember variables even after it has finished executing? Three days gone. Still confused. And then… Async JavaScript. Nested callbacks. Callback Hell. Frustration. But quitting wasn’t an option. Promises were learned. Async/Await was understood. The console became a best friend. Small projects were built. And one day, the realization happened: JavaScript isn’t hard. Clarity just takes time. Six months later, the same developer confidently explains: Execution Context. Closure. Event Loop. Async/Await. 💡 Moral Every developer struggles. The ones who don’t stop… are the ones who grow. #MERN #JavaScript #WebDevelopment #Frontend #MERNStack #CodingJourney

🚀 Day 947 of #1000DaysOfCode ✨ The Shortest JavaScript Program (You’ll Be Surprised 😮) This is one of those concepts that looks super simple… but completely changes how you see JavaScript. In today’s post, I’ve broken down the shortest possible JavaScript program — and trust me, it’s not just about writing less code. Behind this tiny piece of code lies how JavaScript actually runs your program, creates execution context, and prepares memory before even executing a single line. Sounds crazy? Wait till you see it. This is the kind of concept that once you understand, a lot of “weird JavaScript behavior” suddenly starts making sense. If you’re serious about mastering JavaScript, you don’t want to miss this one. 👉 Swipe through the carousel — this might blow your mind 🤯 👇 Did you already know what the shortest JS program is? #Day947 #learningoftheday #1000daysofcodingchallenge #FrontendDevelopment #WebDevelopment #JavaScript #React #Next #CodingCommunity #JSDeepDive

Today JavaScript humbled me again 😭 I thought I understood async JS… but then the Event Loop said “bro sit down.” We explored the chaotic squad behind the scenes: 🧵 Call Stack – the overworked intern running the code 🌀 Event Loop – the manager deciding who gets attention ⚡ Microtask Queue – the VIP lane (Promises, queueMicrotask, process.nextTick) ⏳ Macrotask Queue – the waiting room (setTimeout, setInterval, setImmediate) Biggest plot twist of the day 👇 You write: setTimeout(fn, 0) and think: “Nice… this will run immediately.” JavaScript: “Haha… no.” Because JS first clears the Call Stack, then executes Microtasks, and only then checks Macrotasks. So the real priority is: Call Stack → Microtasks → Macrotasks Which explains why JavaScript sometimes feels like it's gaslighting you during console.log outputs 💀 Huge thanks to Devendra Dhote Bhaiya for explaining this so clearly. Really fun session and lots of brain upgrades today 🧠⚡ JavaScript is basically: “Single-threaded… but emotionally multi-threaded.” #JavaScript #EventLoop #AsyncJavaScript #WebDevelopment #LearningInPublic

𝐋𝐞𝐭'𝐬 𝐞𝐱𝐩𝐥𝐨𝐫𝐞 𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 𝐚 𝐛𝐢𝐭😉 This question caught my attention with how simple it is, based on inference from my experience with JavaScript, and I thought to explain 𝗜𝘀 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗮 𝗱𝘆𝗻𝗮𝗺𝗶𝗰𝗮𝗹𝗹𝘆 𝘁𝘆𝗽𝗲𝗱 𝗼𝗿 𝘀𝘁𝗮𝘁𝗶𝗰𝗮𝗹𝗹𝘆 𝘁𝘆𝗽𝗲𝗱 𝗹𝗮𝗻𝗴𝘂𝗮𝗴𝗲? 𝐓𝐡𝐞 𝐚𝐧𝐬𝐰𝐞𝐫: JavaScript is dynamically typed. In dynamically typed languages, all type checks are performed at runtime, that is, when the program is executing. So this means you can assign anything to the variable and it will work. This is because types are associated with values, not variables. This flexibility is one of the reasons JavaScript became so popular. It allows developers to move quickly and write readable code. But it also introduces trade-offs. (Nothing really is for free😔) Because types are checked only at execution, certain mistakes only appear when the code runs. Some of which include: ☑ Unexpected type coercion ☑ Runtime errors ☑ Harder-to-maintain large codebases This is one of the reasons TypeScript gained popularity. Unlike JavaScript, TypeScript, a statically typed language, insists on all checks being performed during compile/build run before we execute our program. This allows developers to catch many type-related errors before the code runs. In the end, understanding JavaScript’s dynamic nature helps you: ☑ Write safer code ☑ Avoid subtle bugs ☑ Appreciate when tools like TypeScript are helpful #JavaScript #TypeScript #WebDevelopment #SoftwareEngineering #FrontendDevelopment

✨ 𝗗𝗮𝘆 𝟮𝟮 𝗼𝗳 𝗠𝘆 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗝𝗼𝘂𝗿𝗻𝗲𝘆 🚀 (𝗙𝗶𝗻𝗮𝗹 𝗗𝗮𝘆 𝗼𝗳 𝗝𝗦 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀) Today I learned about the 𝘁𝗵𝗶𝘀 𝗸𝗲𝘆𝘄𝗼𝗿𝗱 and how its value changes in different scenarios in JavaScript. I explored how 𝘁𝗵𝗶𝘀 behaves in: 🔹 Global context 🔹 Regular functions 🔹 Object methods 🔹 Arrow functions 🔹 Constructor functions / classes I also learned how to control 𝘁𝗵𝗶𝘀 using 𝗰𝗮𝗹𝗹(), 𝗮𝗽𝗽𝗹𝘆(), 𝗮𝗻𝗱 𝗯𝗶𝗻𝗱(). Another important concept was understanding 𝗦𝘁𝗿𝗶𝗰𝘁 𝗠𝗼𝗱𝗲 𝘃𝘀 𝗡𝗼𝗻-𝗦𝘁𝗿𝗶𝗰𝘁 𝗠𝗼𝗱𝗲. In strict mode ("𝘂𝘀𝗲 𝘀𝘁𝗿𝗶𝗰𝘁"), JavaScript enforces stricter rules and prevents some common mistakes. For example, inside a regular function this becomes undefined instead of the global object, making behavior more predictable. Finishing these JavaScript fundamentals feels great. Now it’s time to move forward and build more complex projects! 💪 #JavaScript #100DaysOfCode #WebDevelopment #LearningJourney #FrontendDevelopment

Day 7: Higher-Order Functions - Functions that take functions. Today I learned: - What higher-order functions are - Passing functions as parameters - Returning functions from functions - How callbacks work Small wins: - Struggled understanding concept initially → Realized functions are first-class citizens in JavaScript - Forgot to RETURN the result → Fixed it and code worked perfectly - Didn't see the practical use → Now understand it's foundation of map, filter, callbacks Built a function that takes 2 numbers and an operation function, then applies that operation. Key insight: This is where JavaScript's power comes from. Pass different functions, get different behaviors. Code: https://lnkd.in/gtT73HVR 143 days remaining. #JavaScript #BackendDeveloper #HigherOrderFunctions #Callbacks #100DaysOfCode #LearningJourney #NodeJS

"I’m just going to say it: JavaScript Promises are hard. 🙃 I thought I had a handle on asynchronous code, but then came .then(), .catch(), and the logic of resolve vs reject. It’s one of those topics where you think you’ve got it, and then one unhandled rejection reminds you that you don't. Learning to code isn't always 'eureka' moments; sometimes it's just sitting with the frustration until it clicks. To my fellow devs—what was the one JS concept that finally made the lightbulb go off for you? #Javascript #WebDevelopment #CodingLife #LearnToCode"

🚀 Day 949 of #1000DaysOfCode ✨ 15 JavaScript Snippets Every Developer Must Know Sometimes, small snippets can save you hours of effort and make your code much cleaner. In today’s post, I’ve shared 15 powerful JavaScript snippets that every developer should have in their toolkit — from handling arrays and objects to writing cleaner and more efficient logic. These are not just shortcuts, but practical patterns that you’ll find yourself using again and again in real-world projects. Knowing these snippets helps you write code faster, reduce bugs, and improve overall readability. If you’re working with JavaScript daily, mastering these small patterns can make a big difference in your productivity. 👇 Which JavaScript snippet do you use the most in your projects? #Day949 #learningoftheday #1000daysofcodingchallenge #FrontendDevelopment #WebDevelopment #JavaScript #React #Next #CodingCommunity #JSDevelopers