Mastering JavaScript Switch Cases & Loops Fundamentals

🚀 JavaScript Learning Update – Day 19 Today, I wrote a detailed blog on Inheritance in JavaScript. While studying inheritance, I explored: • How the extends keyword connects parent and child classes   • How super() works inside constructors   • How method overriding functions   • How inheritance improves code reusability and structure   • What actually happens behind the scenes when a class inherits another  Writing this blog helped me not only understand the concept deeply but also explain it clearly in simple terms. Inheritance is a powerful concept in OOP, and mastering it makes building scalable and maintainable applications much easier. Learning deeply. Writing clearly. Growing consistently. #JavaScript #OOP #WebDevelopment #LearningInPublic #FrontendDeveloper #DeveloperJourney

Today’s learning took me deeper into how JavaScript actually makes decisions. When I first started coding, I used operators and conditionals just to “make things work.” But today, I paused and really understood what’s happening under the hood. I explored JavaScript operators: 1. Arithmetic operators — for calculations like addition, subtraction, division, modulus, exponent, increment and decrement 2. Assignment operators — shortcuts like +=, -=, *=, %= 3. Comparison operators — comparing values using ==, ===, != 4. Logical operators — combining conditions using && and || Then I moved into conditional statements, which are what allow programs to make decisions: 👉 if, else if, else 👉 ternary operators for shorter decisions 👉 nested conditions for more complex logic 👉 switch statements for handling multiple possible cases And it clicked… Writing code isn’t just about syntax. It’s about teaching the computer how to think and decide. Strengthening my JavaScript foundations has been one of the best decisions I’ve made on my frontend journey. Every small concept I revisit makes me a more confident and intentional developer #JavaScript #FrontendDevelopment #LearningInPublic #TechJourney #100DaysOfCode

🚀 Day 21: of Learning in Public: JavaScript Edition 💻✨ Peeking into the JavaScript Engine! Today was all about understanding the "Magic" behind how JavaScript code runs. It’s one thing to write code, but understanding the Execution Context changes how you debug forever. Here’s a simple breakdown of what I learned today: 1️⃣ The Global Execution Context (GEC) Everything in JS happens inside an Execution Context. Think of it as a big container with two components: Memory Component (Variable Environment): Where variables and functions are stored as key-value pairs (e.g., x: undefined). Code Component (Thread of Execution): Where the code is executed line by line. 2️⃣ Hoisting 🚩 Ever wondered why you can use a variable before it’s declared? That’s Hoisting! During the memory creation phase, JS allocates memory for variables and functions. Variables declared with var are initialized as undefined. Function declarations are stored with their entire body. 3️⃣ Temporal Dead Zone (TDZ) ⏳ This is the "danger zone" for let and const. Unlike var, you cannot access let or const variables before their declaration. The time between the start of the execution and the actual line where the variable is initialized is the Temporal Dead Zone. Accessing it here will throw a ReferenceError! 4️⃣ The Call Stack 📚 The Call Stack manages the "order" of execution. The Global Execution Context sits at the bottom. Every time a function is invoked, a new Execution Context (EC) is pushed to the top. Once the function finishes, it is "popped out," and control goes back down the stack. Key Takeaway: Understanding the internal lifecycle of variables helps in writing cleaner, error-free code and mastering concepts like closures and scope later on. Slowly but surely, the "weird" parts of JS are starting to make perfect sense! 💡 #JavaScript #LearningInPublic #SoftwareTesting #CodingJourney #JSBasics #Programming #SDET

📚 This Week’s Learning: Asynchronous JavaScript (Callbacks → Promises → Async/Await) This week I deep-dived into one of the most important concepts in JavaScript — Asynchronous Programming. Initially, I was confused about how JavaScript handles async tasks like API calls and timers, but now things are much clearer. Here’s my learning path: ➡️ Started with Callbacks (and understood callback hell) ➡️ Moved to Promises and learned .then() & .catch() ➡️ Finally understood Async/Await and how it simplifies async code One thing that really clicked for me: Async/Await is just syntactic sugar over Promises, but it makes code much more readable and easier to debug. I also practiced: ✔️ Fetch API ✔️ response.json() ✔️ Error handling in async functions Next Target: Solving LeetCode problems using JavaScript and mastering DSA patterns 🚀 #JavaScript #AsyncAwait #Promises #CodingJourney #LeetCode #FrontendDevelopment #LearningDaily

🚀 JavaScript Learning Update - Day 20 Today, I focused on revising the core concepts I’ve learned so far in JavaScript. I revised: • Objects and object methods   • Shallow copy vs Deep copy   • Array methods and their polyfills (map, filter, forEach)   • Classes and Constructors   • Encapsulation and Abstraction   • Inheritance in JavaScript  Instead of learning something new, I strengthened my fundamentals by reviewing concepts and clearing small doubts. Revision helps turn information into understanding. Strong fundamentals > Fast learning. Consistent practice. Continuous improvement. #JavaScript #WebDevelopment #OOP #LearningInPublic #DeveloperJourney #FrontendDeveloper

🚀 JavaScript Learning Update – Day 15 Today, I studied Classes and Objects in JavaScript and wrote a blog on: “Why JavaScript Really Needs the class Keyword” While learning this topic, I explored: • How objects were created before ES6 (constructor functions & prototypes)   • Why the class keyword was introduced   • How class improves readability and structure   • The difference between constructor functions and class syntax   • How OOP concepts work in JavaScript  Writing this blog helped me understand not just how to use classes, but why they exist in JavaScript. Instead of memorizing syntax, I focused on understanding the reasoning behind the language design. Building strong fundamentals, one concept at a time. #JavaScript #OOP #WebDevelopment #LearningInPublic #FrontendDeveloper #CodingJourney

Day 70 — JavaScript Learning 🚀 Today I revisited one of the most misunderstood topics in JavaScript — Hoisting. ❌ Myth: “JavaScript moves declarations to the top.” ✅ Reality: JavaScript doesn’t move your code. It creates memory for variables and functions during the creation phase. --- 🔹 Example 1 — var console.log(a); var a = 10; 👉 Output: undefined Why? During memory creation: a = undefined So it exists… but has no value yet. --- 🔹 Example 2 — let & const console.log(b); let b = 20; 👉 Output: ReferenceError This is because of the Temporal Dead Zone (TDZ). let and const are hoisted too — but they are not initialized. --- 🔹 Example 3 — Function Hoisting greet(); function greet() { console.log("Hello"); } 👉 Works perfectly. But: greet(); const greet = function() { console.log("Hello"); } 👉 Error ❌ Because function expressions follow variable rules. --- 📌 What I understood today: Hoisting is not about “moving code.” It’s about how JavaScript creates memory before execution. Understanding this removes so many beginner-level bugs. #Day70 #JavaScript #Hoisting #WebDevelopment #DeepLearning

💻 Day 68 — JavaScript Learning 🚀 Today I learned about Destructuring in JavaScript. Destructuring allows us to extract values from arrays or objects and assign them to variables in a cleaner way. --- 🔹 Array Destructuring const numbers = [10, 20, 30]; const [a, b, c] = numbers; console.log(a); // 10 console.log(b); // 20 Instead of writing: const a = numbers[0]; const b = numbers[1]; --- 🔹 Object Destructuring const user = { name: "Tejal", age: 21 }; const { name, age } = user; console.log(name); // Tejal --- 📌 Why destructuring is powerful: Cleaner and shorter code Improves readability Very common in React & APIs Small syntax improvement, big difference in writing professional code. #Day68 #JavaScript #WebDevelopment #Destructuring #LearningInPublic

📘 JavaScript Learning Update – Day 12 Today I explored an important JavaScript concept: Shallow Copy vs Deep Copy. I learned: What a shallow copy is and how it copies references of nested objects. What a deep copy is and how it creates a completely independent clone. Different ways to create shallow copies (spread operator, Object.assign). Ways to create deep copies (structuredClone, JSON methods). I also wrote a blog explaining the difference with examples to strengthen my understanding. Understanding copying behavior is very important when working with objects and arrays in real-world applications. Step by step, I am improving my JavaScript fundamentals. #JavaScript #WebDevelopment #LearningJourney #Coding

🚀 Day 22 of Learning in Public: JavaScript Edition 💻✨ The Secret Sauce of JavaScript — Closures & Scope Chains! After yesterday’s look at the JS Engine, I dove deeper into how JavaScript actually "finds" variables. If you’ve ever wondered how a nested function remembers data from its parent, today’s notes are for you! 🧠 Here’s the breakdown of what I learned: 1️⃣ Lexical Scope & Environment 🌐 Lexical scope is all about hierarchy. A function's "Lexical Environment" consists of: Its own local memory. A reference to the Lexical Environment of its parent. 2️⃣ The Scope Chain ⛓️ When you try to access a variable, JS doesn't just give up if it's not in the local function. It searches: The Local Scope. The Parent's Scope. ...and so on, until it hits the Global Execution Context. This "search path" is what we call the Scope Chain. 3️⃣ Closures: The "Persistent Memory" 💾 A Closure is created when a function is bundled together with its lexical environment. The Power: It allows an inner function to access variables from an outer function even after the outer function has finished executing! 4️⃣ Hoisting Refined: Functions vs. Variables 🚩 I also cleared up some common confusion: Function Declarations: Fully hoisted (you can call them before they are defined!). Function Expressions (Arrow/Anonymous): Treated like variables—if declared with var, they are undefined; if let/const, they are in the Temporal Dead Zone. Slowly but surely, the "inner workings" of JS are becoming second nature. 💻 Question for the community: What was the first real-world use case where you realized you needed a closure? Let’s discuss below! 👇 #JavaScript #LearningInPublic #WebDevelopment #CodingJourney #JSBasics #Closures #ScopeChain #SoftwareEngineering #TechGrowth