Extending JavaScript Prototypes: A Hidden Global Side Effect

🚀 JavaScript Magic: Why "Undefined" is actually a Feature, not a Bug! I just had a "Wow" moment diving into the JavaScript Execution Context, and it changed how I look at my code. Ever wondered why you can console.log a variable before you even declare it, and JavaScript doesn't lose its mind? 🤯 🧠 The Secret: Two-Phase Execution When your code runs, JavaScript doesn't just start at line 1. It takes two passes: 1.Memory Creation Phase: JS scans your code and allocates space for all variables and functions. 2. Execution Phase: It runs the code line-by-line. ⚡ The var Behavior (Hoisting) If you use var, JavaScript initializes it as undefined during the memory phase. Result: You can log it early. No error, just a quiet undefined. It’s like the variable is there, but its "suit" hasn't arrived yet. 🛑 The let & const Twist (TDZ) Try the same thing with let or const, and the engine throws a ReferenceError. Why? The Temporal Dead Zone (TDZ). While let and const are also "hoisted," they aren't initialized. They stay in a "dead zone" from the start of the block until the moment the code actually hits the declaration. The Lesson: JavaScript isn't just reading your code; it's preparing for it. Understanding the Execution Context makes debugging feel like having X-ray vision. 🦸♂️ Have you ever been bitten by the Temporal Dead Zone, or do you still find yourself reaching for var out of habit? Let’s discuss! 👇 #JavaScript #WebDevelopment #CodingTips #Frontend #Programming101

JavaScript objects have a powerful feature called Prototype that enables inheritance. In JavaScript, if an object doesn’t have a specific property or method, the engine automatically looks for it in its prototype. This process continues up the prototype chain until the property is found or the chain ends. Example: function Person(name) { this.name = name; } Person.prototype.greet = function () { console.log("Hello, my name is " + this.name); }; const john = new Person("John"); john.greet(); Even though john doesn’t directly have the greet() method, it can still access it through Person.prototype. This mechanism allows JavaScript objects to share methods and inherit behavior efficiently. Understanding prototypes helps you better understand how inheritance and object behavior work behind the scenes in JavaScript. Follow for more JavaScript concepts explained visually. #javascript #webdevelopment #frontenddeveloper #coding #learninginpublic #100DaysOfCode

🚨 Still using var in JavaScript without knowing the difference? This might be breaking your code… 💡 Understanding var, let, and const is one of the first steps to writing clean and predictable JavaScript. 🔹 var • Function scoped • Can be re-declared and re-assigned • Gets hoisted with undefined • Often leads to unexpected bugs in modern code 🔹 let • Block scoped (safer than var) • Can be re-assigned but not re-declared in the same scope • Helps avoid scope-related bugs 🔹 const • Block scoped • Cannot be re-assigned after declaration • Must be initialized at declaration • Perfect for values that shouldn't change ⚡ Quick rule many developers follow: • Use const by default • Use let when a value needs to change • Avoid var in modern JavaScript 📌 Small concept. Big impact on code quality. #JavaScript #WebDevelopment #Coding #FrontendDevelopment #100DaysOfCode #LearnToCode

🚀 JavaScript Prototypes Explained (Beyond “Classes”) Spent time breaking down how JavaScript actually handles inheritance under the hood. Here’s the mental model that made everything click 👇 🧠 Core Concepts: • Prototype Chain (object → parent → null) • Shared vs Instance Properties • What new actually does internally • Object.create() for manual inheritance • ES6 Classes & Static Methods 💡 Key Insight: class in JavaScript is just syntactic sugar over prototypes. Once you understand prototypes, inheritance is no longer a black box. 💻 Pattern-Based Problem Solving Focused on writing optimal solutions: • Maximum Subarray → Kadane’s Algorithm (O(n)) • Product of Array Except Self → Prefix/Suffix (O(n)) • Majority Element → Boyer–Moore (O(1) space) Instead of solving randomly, approached problems through patterns. 💡 Takeaway: When the pattern is clear, the problem becomes simple. Building a deeper understanding of how JavaScript really works — not just how to use it. 💪 #JavaScript #DSA #WebDevelopment #ProblemSolving #FrontendDeveloper #MERNStack Prototype Chain flow 👇

🧠 Ever wondered how JavaScript keeps track of which function is running? JavaScript uses something called the Call Stack. Think of it like a stack of tasks where functions are added and removed as they execute. 🔹 How the Call Stack Works JavaScript follows a Last In, First Out (LIFO) rule. That means: The last function added to the stack is the first one to finish. Example function first() { second(); } function second() { third(); } function third() { console.log("Hello from third function"); } first(); What happens in the Call Stack 1️⃣ first() is pushed to the stack 2️⃣ second() is called → pushed to the stack 3️⃣ third() is called → pushed to the stack 4️⃣ third() finishes → removed from stack 5️⃣ second() finishes → removed 6️⃣ first() finishes → removed 🔹 Visualising the Stack Call Stack at peak: - third() - second() - first() - Global() Then it unwinds back to the Global Execution Context. 💡 Why This Matters Understanding the call stack helps you understand: - Execution order - Stack overflow errors - Debugging JavaScript - Async behaviour It’s one of the core mechanics of the JavaScript engine. Next post: The Event Loop 🚀 #JavaScript #CallStack #Frontend #WebDevelopment #LearnJS #Programming #LearningInPublic

Most of us write JavaScript every day - but do we actually know what happens when our code runs? 🤔 Here's a quick breakdown: 🔹 Step 1 - Global Execution Context Before a single line runs, JS allocates memory for all variables and functions. This is where hoisting happens. 🔹 Step 2 - Execution Phase Now the code actually runs - values get assigned, functions get invoked, line by line. 🔹 Step 3 - Local Execution Context Every time a function is called, JS creates a brand new execution context just for it - with its own local memory. Once the function is done? It's destroyed. And behind all of this? The Call Stack 📚 It keeps track of every function using LIFO (Last In, First Out). The most recently called function runs first, and when it's done, execution returns to where it left off. JavaScript is single-threaded - meaning it does one thing at a time, in order. Understanding this is the key to debugging async code, closures, and so much more. Save this post if you found it helpful. ✌ #JavaScript #WebDevelopment #Programming #SoftwareEngineer #JSFundamentals #Developer

⚠️ The Danger of Splicing Arrays in a Loop "While solving the 'Move Zeroes' challenge today, I encountered a classic JavaScript pitfall: Modifying an array's length while iterating over it. The Mistake: Using .splice() inside a for loop. When you remove an element, the next one shifts left, and your loop index skips it! The Lesson: Always adjust your index or, even better, use the Two-Pointer technique. It's not just safer; it's much more performant for large datasets. Small bugs teach the biggest lessons! 🚀" "Did you know? JavaScript (ES6) allows you to swap array elements in a single line using destructuring : [a, b] = [b, a]. Clean, readable, and efficient!" Feel free to check out my progress and solutions on my LeetCode profile: I've shared my LeetCode profile link in the first comment below! #JavaScript #CodingTips #WebDevelopment #ProblemSolving #LeetCode #AngularDeveloper

🚨 JavaScript once told me 1 + "1" equals 11. And surprisingly… it wasn’t wrong. That’s Type Coercion - one of the most misunderstood parts of JavaScript. Type coercion happens when JavaScript automatically converts values from one type to another. This is why JavaScript sometimes feels unpredictable. But here’s the truth: It’s not random. It’s rule-based. Almost every strange behavior comes from how operators trigger conversions: • Math operations treat values as numbers • The + operator switches to string concatenation when text is involved • Conditionals convert values into true or false when making decisions Once you understand that operators decide how values are interpreted, JavaScript starts feeling far more logical. Type coercion isn’t a flaw in the language. It exists because the web deals with messy real-world input - forms, APIs, and user data that don’t always arrive in the expected type. The real skill isn’t avoiding type coercion. It’s understanding when JavaScript applies its rules - and why.. #JavaScript #WebDevelopment #Programming #SoftwareEngineering #FrontendDevelopment

Most developers use JavaScript every day. Very few understand what actually happens behind the scenes. One of the most important fundamentals is this: 𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 𝐢𝐬 𝐬𝐢𝐧𝐠𝐥𝐞-𝐭𝐡𝐫𝐞𝐚𝐝𝐞𝐝. It can execute only one task at a time. Yet somehow it still handles network requests, timers, and user interactions smoothly. So what makes this possible? First, every function call enters the 𝐂𝐚𝐥𝐥 𝐒𝐭𝐚𝐜𝐤. This is where JavaScript executes code. If the stack is busy, nothing else can run. But asynchronous tasks like `setTimeout`, `fetch`, and DOM events don’t run inside the JavaScript engine itself. They are handled by 𝐁𝐫𝐨𝐰𝐬𝐞𝐫 𝐖𝐞𝐛 𝐀𝐏𝐈𝐬. Once those operations finish, their callbacks move into the 𝐂𝐚𝐥𝐥𝐛𝐚𝐜𝐤 𝐐𝐮𝐞𝐮𝐞. Then the 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 steps in. It constantly checks whether the Call Stack is empty. When it is, tasks from the queue are pushed into the stack for execution. That simple cycle is what enables asynchronous behavior—even in a single-threaded language. Understanding this mental model makes development much easier: * Debug async issues by visualizing the call stack and queue * Use `async/await` confidently once you understand promises * Avoid blocking operations that freeze the event loop Once this concept clicks, JavaScript suddenly feels far less mysterious. When did the 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 finally make sense to you? #JavaScript #WebDevelopment #FrontendEngineering #EventLoop #AsyncProgramming #SoftwareEngineering #ProgrammingFundamentals #MERNStack

🚀 Just solved the "Best Time to Buy and Sell Stock" problem in JavaScript! Today I worked on improving my problem-solving skills by implementing a solution to calculate the maximum profit from stock prices. 🔍 Problem: Given an array of prices, determine the maximum profit you can achieve by buying and selling once. 💡 Approach: I started with a brute-force solution using nested loops to compare every possible buy/sell pair. While not the most optimal (O(n²)), it helped me deeply understand the problem before optimizing. 📌 Example: Input: [10, 1, 5, 6, 7, 1] Output: 6 🧠 Key takeaway: Sometimes starting simple is the best way to build strong intuition before moving to more efficient solutions. 👉 Check out my code and more JavaScript patterns here: https://lnkd.in/ej4fNeZs #JavaScript #Coding #ProblemSolving #100DaysOfCode #WebDevelopment #LearningInPublic