JavaScript Lexical Scoping Explained

Day 3/200🚀 Understanding JavaScript Closures, Scope & setTimeout Today I explored a tricky but important JavaScript concept while experimenting with setTimeout, var, and let. 🔹 What I Learned: JavaScript executes synchronous code first, then asynchronous callbacks setTimeout does NOT store values, it stores a function (closure) Closures capture variables by reference, not by value var uses a single shared variable let creates a new variable for each iteration 🔹 The Problem I Faced: I expected this code to print 0 1 2, but it printed 3 3 3 🔹 Why It Happened: Loop finished execution first i became 3 All callbacks accessed the same variable reference 🔹 Solution: Using let instead of var creates a new binding for each iteration, giving the expected output. 💡 Key Takeaway: “Closures capture variables by reference. var shares one binding, while let creates a new binding per iteration.” #JavaScript #WebDevelopment #Frontend #NodeJS #LearningInPublic #Coding

I ran a small JavaScript experiment today, and it was a good reminder that performance often hides inside simple concepts. I used the same function twice with the same inputs. The first call took noticeable time. The second call returned almost instantly. Nothing changed in the inputs. Nothing changed in the output. The only difference was that the second time, JavaScript didn’t need to do the work again. That’s the beauty of memoization. Instead of recalculating, it remembers the previous result and returns it from cache. What looks like a small optimization in code can make a big difference in how efficiently an application behaves. The deeper I go into JavaScript, the more I realize: the real power is not just in writing code — it’s in understanding how to make code smarter. #JavaScript #WebDevelopment #FrontendDevelopment #Memoization #Closures

What will happen if you call a variable before initialization? 🤔 That is called Hoisting 👉 "JavaScript moves declarations to the top of their scope before execution" Sounds confusing? Let’s break it down 👇 When you create variables or functions, JavaScript runs your code in 2 phases: 1️⃣ Memory Creation Phase Before execution, JavaScript scans your code and allocates memory Example (mentally): var a → undefined let b → uninitialized (Temporal Dead Zone) 2️⃣ Execution Phase Now JavaScript runs your code line by line 👉 If you access variables before initialization: var → returns undefined let / const → ReferenceError Why does this happen? Because: var is initialized with undefined in memory let and const are hoisted but stay in the Temporal Dead Zone (TDZ) until the line where they are declared Simple way to remember: var => “exist, but don’t have a value yet” let / const => “Don’t touch before declaration” ⚡ Bonus: Function declarations are fully hoisted, so you can call them before defining them Curious how functions behave in hoisting? 🤔 Go Google function vs function expression in JavaScript — it’ll surprise you 👀 That’s hoisting in JavaScript 🚀 #javascript #webdevelopment #coding #frontend #learninpublic #hoisting

🚀 Understanding Template Literals in JavaScript 📖 Read full guide: https://lnkd.in/ghJ6jZRm While working with JavaScript, I explored how Template Literals simplify string handling and improve code readability. 🔍 Old way (messy): "Hello " + name + "!" ✨ New way (clean): Hello ${name}! 💡 Key Benefits: ✔ Easy variable embedding ✔ Multi-line strings ✔ Cleaner, more readable code Small feature, but a big impact in modern JavaScript 🚀 #JavaScript #WebDevelopment #Coding #FrontendDevelopment #LearningJourney #CleanCode

💻 JavaScript Array Methods – Hands-on Practice Completed Worked on some fundamental Array methods in JavaScript and practiced how they actually behave 👇 ✔️ Used push() and pop() to add/remove elements from the end ✔️ Used unshift() and shift() to work with elements at the beginning ✔️ Explored length to track array size ✔️ Understood the difference between slice() and splice() through practice 💡 Key takeaway: slice() does not modify the original array, while splice() directly changes it — this difference is really important while working with data. Practicing these basics is helping me build a strong foundation in JavaScript 🚀 #JavaScript #WebDevelopment #Frontend #CodingJourney #LearningByDoing

Day 4 — Making Tech Simple. JavaScript looks simple… But here’s something most beginners don’t understand How does JavaScript handle multiple tasks at once if it’s single-threaded? The answer = Event Loop Here’s what actually happens: • Call Stack → Executes code one by one • Web APIs → Handle async tasks (setTimeout, fetch, events) • Callback Queue → Stores completed tasks • Event Loop → Pushes tasks back to stack when it’s free That’s how JavaScript handles async behavior without breaking. If you don’t understand this… 👉 Async code will always confuse you 👉 Debugging will feel hard But once you get it… Everything starts making sense 💡 📌 Day 4 of breaking down complex tech into simple visuals. Follow me if you want to actually understand JavaScript deeply. Comment “DAY 5” if you’re ready — Syed Shaaz Akhtar #JavaScript #WebDevelopment #Frontend #Programming #SoftwareEngineering

Most developers use JavaScript every day… But very few truly understand how it actually executes code behind the scenes. That’s where the Event Loop comes in — the heart of JavaScript’s asynchronous behavior. At a high level: JavaScript is single-threaded. But it behaves like it can handle multiple things at once. How? Because of this powerful architecture 👇 • Call Stack → Executes synchronous code line by line • Microtask Queue → Handles Promises, async/await (high priority) • Macrotask Queue → Handles setTimeout, setInterval, I/O operations • Event Loop → Constantly checks and decides what runs next Here’s the game-changing concept: 👉 Microtasks ALWAYS run before Macrotasks That’s why: Promise resolves → runs immediately after current execution setTimeout → waits even if delay is 0 This small detail is the reason behind: • Unexpected output order • Async bugs • Performance differences • UI responsiveness If you’ve ever wondered: “Why is my code running in a different order than I expected?” The answer is almost always → Event Loop behavior Understanding this doesn’t just make you a better developer — It changes how you think about writing code. You stop guessing. You start predicting. And that’s where real engineering begins. 🚀 #JavaScript #EventLoop #AsyncJavaScript #WebDevelopment #FullStackDevelopment #Programming #SoftwareEngineering #TechDeepDive #CodingJourney JavaScript Mastery w3schools.com

🚀 JavaScript Event Loop — Finally Made Simple! If you’ve ever wondered how JavaScript handles multiple tasks at once, this is the core concept you need to understand 👇 🔹 JavaScript is single-threaded But thanks to the Event Loop, it can handle async operations like a pro. Here’s the flow in simple terms: 1️⃣ Code runs in the Call Stack (LIFO — last in, first out) 2️⃣ Async tasks (like setTimeout, fetch, DOM events) go to Web APIs 3️⃣ Completed tasks move to queues: 🟣 Microtask Queue (Promises → highest priority) 🟠 Callback Queue (setTimeout, etc.) ⚡ Important Rule: 👉 Microtasks run BEFORE macrotasks 👉 setTimeout(fn, 0) is NOT instant! 4️⃣ The Event Loop keeps checking: Is the Call Stack empty? If yes → push tasks from queues (priority first) 💡 Why this matters: Understanding this helps you: ✔ Avoid bugs in async code ✔ Write better APIs ✔ Crack interviews confidently 📌 Pro Tip: Mastering the event loop = leveling up your JavaScript game #JavaScript #WebDevelopment #Frontend #Coding #AsyncProgramming #Developers #LearnToCode

🚀 Day 7 — Understanding JavaScript Objects & Prototypes Continuing my journey of strengthening core JavaScript fundamentals, today I explored one of the most important building blocks — Objects & Prototypes 👇 At first, objects feel simple… but when you dive into prototypes, you truly understand how JavaScript works behind the scenes. 🔹 Covered topics: - What are JavaScript Objects? - Key-Value Pairs & Properties - Dot vs Bracket Notation - Add / Modify / Delete Properties - Object Methods - "this" inside objects (quick revision 🔁) - Constructor Functions - What happens when we use "new" - Why Prototype is needed (memory optimization 🔥) - Prototype & Shared Methods - Prototype Chain (🔥 very important) - Getter & Setter 💡 Key Learning: JavaScript is not class-based — it’s prototype-based. Objects can share properties and methods using prototypes, which makes code more efficient and scalable. 👉 Always remember: - JS first looks inside the object - If not found → it checks the prototype (This is called the Prototype Chain) Understanding this concept is a game changer for interviews and helps in writing better, optimized code. 📌 Day 7 of consistent preparation — going deeper into JavaScript fundamentals 🔥 #JavaScript #WebDevelopment #FullStackDeveloper #CodingJourney #MERNStack #InterviewPreparation #Frontend #Backend #LearnInPublic #Developers #Consistency #100DaysOfCode #LinkedIn #Connections

Just published a new blog on Template Literals in JavaScript! If you're still using old string concatenation, you're missing out on cleaner and more powerful ways to write code. In this blog, I’ve explained how template literals make your JavaScript more readable and dynamic with real examples. 💡 Learn how to: Embed expressions easily Write multi-line strings effortlessly Improve code readability Check it out here 👇 https://lnkd.in/dXZMq4RW #JavaScript #WebDevelopment #Coding #Frontend #100DaysOfCode