JavaScript this Keyword Behavior Depends on Function Invocation

Understanding the "this" keyword in JavaScript 🔍 The value of "this" depends on how a function is called — not where it is defined. Here are the key cases: • Global scope → "this" refers to the global object (window in browser) • Object method → "this" refers to the object calling the method • Constructor function → "this" refers to the new instance created • Event handler → "this" refers to the element that triggered the event Mastering "this" helps in writing better object-oriented and reusable code. Still practicing with different examples to understand it deeply 💻 #javascript #webdevelopment #frontend #learninginpublic #mern

🚀 JavaScript Output Challenge #4 (Trap Level) If you think you understand JavaScript deeply… this one will test you 👇 🧠 Question: (Check the code in the images) ⚠️ Rules: Don’t run the code Think step by step Focus on execution order 🤔 Try to answer: What will be the exact output? Why does it happen? What changes if we replace var with let? 💬 Drop your answers in the comments Let’s see how many get this right 👀 🔥 Concepts involved: Event Loop Microtask vs Macrotask Closures Scope (var vs let) 📌 I’ll share the detailed explanation soon #javascript #webdevelopment #frontend #codingchallenge #reactjs #nodejs

🧠 Day 11 of 21days challenge Shallow vs Deep Copy in JavaScript ⚠️ const copy = { ...obj }; Looks like a copy… but not always safe. Shallow copy duplicates only top-level properties. Deep copy creates a completely independent object. For easy understanding :- Shallow copy = shared nested reference Deep copy = fully independent copy Shallow changes affect original 👉 That’s why bugs happen in state updates This changed how I handle object mutations 🚀 #JavaScript #Frontend #InterviewPrep

Stop using || for your Boolean defaults! 🛑 Ever passed false to a function, only to have your code treat it as true? This is a classic JavaScript "falsy" trap. Because false is a falsy value, the logical OR operator (||) skips right over it and grabs your default value instead. The Fix: Use the Nullish Coalescing operator (??). It’s specifically designed to respect false and 0 while still providing a fallback for null or undefined. Check out the snippet below to see the difference! 👇 Have you made the switch to ?? yet, or do you still find yourself reaching for || ? Follow Wisdom Lamodot for more on #JavaScript #WebDevelopment #CodingTips #ReactJS

🧠 Day 20 of 21days challenge JavaScript "this" – Arrow vs Normal Function 🤯 Not all functions handle "this" the same way. Normal functions get "this" from how they are called. Arrow functions inherit "this" from their surrounding scope. For easy understanding :- Normal function → dynamic this Arrow function → lexical this Arrow does NOT have its own this 👉 That’s why arrow functions behave differently This changed how I use functions 🚀 #JavaScript #ThisKeyword #InterviewPrep #Frontend

What is a closure in JavaScript? A closure is a function that remembers variables from its outer scope even after that scope has finished executing. Why does this work? - `createCounter` runs once - It creates a variable `count` - The inner function “closes over” that variable - Even after `createCounter` finishes, `count` is still accessible Each time `counter()` runs: → it uses the same preserved state 💡 Closures are everywhere: - React hooks - Event handlers - Memoization - Encapsulation patterns They’re not just a concept — they’re part of how JavaScript manages state. #Frontend #JavaScript #React #WebDevelopment #SoftwareEngineering

Most people don’t understand the JavaScript Event Loop. So let me explain it in the simplest way possible: JavaScript is single-threaded. It can only do ONE thing at a time. It uses something called a call stack → basically a queue of things to execute. Now here’s where it gets interesting: When async code appears (like promises or setTimeout), JavaScript does NOT execute it right away. It sends it away to the Event Loop and then keeps running what’s in the call stack. Only when the call stack is EMPTY… the Event Loop starts pushing async tasks back to be executed. Now look at the code in the image. What do you think runs first? Actual output: A D C B Why? Because not all async is equal: Promises (microtasks) → HIGH priority setTimeout (macrotasks) → LOW priority So the Event Loop basically says: “Call stack is empty? cool… let me run all promises first… then I handle setTimeout” If you get this, async JavaScript stops feeling random. #javascript #webdevelopment #frontend #reactjs #softwareengineering

Six characters that completely changed how we write JavaScript. 👇 If your code is still cluttered with the function keyword, it’s time for an upgrade. Arrow functions () => {} aren't just syntactic sugar; they are the backbone of clean, modern JS. Swipe through the carousel to see: - Why developers prefer them - How they fix the classic this headache - Where they shine the most How often are you using arrow functions in your current projects? #JavaScript #WebDev #CleanCode #Frontend #Coding

🚀 Why Does null Show as an Object in JavaScript? 🤯 While practicing JavaScript, I came across something interesting: let myVar = null; console.log(typeof myVar); // Output: object At first, it feels confusing… why is null an object? 🤔 💡 Here’s the simple explanation: null is actually a primitive value that represents "no value" or "empty". But when JavaScript was first created, there was a bug in the typeof operator. Due to this bug, typeof null returns "object" instead of "null". ⚠️ This behavior has been kept for backward compatibility, so changing it now would break existing code. 🔍 Key Takeaways: null → means "nothing" (intentional empty value) typeof null → returns "object" (this is a historical bug) Objects (like {}) also return "object" 💻 Example: let myObj = { name: "John" }; console.log(typeof null); // object ❌ (bug) console.log(typeof myObj); // object ✅ (correct) 📌 Conclusion: Even though both return "object", they are completely different in meaning. 👉 JavaScript is powerful, but it has some quirky behaviors—this is one of them! #JavaScript #WebDevelopment #CodingJourney #100DaysOfCode #FrontendDevelopment

🔍 JavaScript Quirk: Hoisting (var vs let vs const) JavaScript be like: 👉 “I know your variables… before you even write them” 😅 Let’s see the magic 👇 console.log(a); var a = 10; 💥 Output: undefined Wait… no error? 🤯 Why? Because `var` is **hoisted** 📌 What is Hoisting? Hoisting is JavaScript’s behavior of **moving variable and function declarations to the top of their scope before execution**. 👉 JS internally does this: var a; console.log(a); // undefined a = 10; So the variable exists… but has no value yet. Now try with `let` 👇 console.log(b); let b = 20; 💥 Output: ReferenceError ❌ Same with `const` 👇 console.log(c); const c = 30; 💥 Error again ❌ Why? Because `let` & `const` are also hoisted… BUT they live in something called: 👉 “Temporal Dead Zone” (TDZ) Translation: 🧠 “You can’t touch it before it’s declared” --- 💡 Simple Breakdown: ✔ `var` → hoisted + initialized as `undefined` ✔ `let` → hoisted but NOT initialized ✔ `const` → same as let (but must assign value) 💀 Real dev pain: Using `var`: 👉 “Why is this undefined?” Using `let`: 👉 “Why is this error?” JavaScript: 👉 “Figure it out yourself” 😎 💡 Takeaway: ✔ Avoid `var` (legacy behavior) ✔ Prefer `let` & `const` ✔ Understand hoisting = fewer bugs 👉 JS is not weird… You just need to know its secrets 😉 🔁 Save this before hoisting confuses you again 💬 Comment “TDZ” if this finally made sense ❤️ Like for more JS quirks #javascript #frontend #codingtips #webdevelopment #js #developer