How JavaScript source maps work: a JSON file that maps minified code to original files.

🚀 JavaScript Gotchas: var vs let in Loops & setTimeout Same code, different output 👇 Ever wondered why this code prints 5 5 5 5 5 instead of 0 1 2 3 4? for (var i = 0; i < 5; i++) { setTimeout(() => { console.log(i); }, 1000); } 💡 Reason: var is function-scoped — only one i exists for the entire loop. setTimeout callbacks run after the loop finishes, so each callback sees the final value of i → 5. ✅ Fix it with let: for (let i = 0; i < 5; i++) { setTimeout(() => { console.log(i); }, 1000); } let is block-scoped — each iteration gets a new copy of i. Now, callbacks “remember” the correct value of i. ✅ Output: 0 1 2 3 4 💡 Key takeaway: var → shared variable in loop → tricky in async callbacks let → separate variable per iteration → safer & predictable ✨ Tip: Even setTimeout(..., 0) behaves the same! The event loop always runs callbacks after the current synchronous code. #JavaScript #CodingTips #FrontendDevelopment #WebDevelopment #Programming #LearnJS #DeveloperTips #AsyncJavaScript #Closures

Ever seen a variable live even after its function dies? That’s Closure — the memory ninja of JavaScript 🧠 One of JavaScript’s most powerful (and tricky) features 💡 Let’s look at a simple example 👇 function counter() { let count = 0; return function () { count++; console.log(count); }; } const increment = counter(); increment(); // 1 increment(); // 2 increment(); // 3 Wait… how does count still remember its value? Didn’t the counter() function finish already? 😅 Here’s the magic 🪄 > A closure allows a function to “remember” the variables from the scope in which it was created — even after that scope is gone. In this example, The inner function still has access to count, Because it closes over the variables from its outer function. That’s why we call it a Closure 🔁 Closures are the reason we can create: ✅ Private variables ✅ Function factories ✅ Modular, memory-efficient code In short — > A closure is how JavaScript gives functions memory 🧠 #JavaScript #Closures #WebDevelopment #Frontend #MERNStack #NodeJS #ReactJS #Coding #SoftwareEngineering #Developers #JSFundamentals

Ever seen a variable live even after its function is done? 🤔 That’s not a bug — that’s Closure, one of JavaScript’s most powerful (and tricky) features 💡 Let’s look at a simple example 👇 function counter() { let count = 0; return function () { count++; console.log(count); }; } const increment = counter(); increment(); // 1 increment(); // 2 increment(); // 3 Wait… how does count still remember its value? Didn’t the counter() function finish already? 😅 Here’s the magic 🪄 > A closure allows a function to “remember” the variables from the scope in which it was created — even after that scope is gone. In this example, The inner function still has access to count, Because it closes over the variables from its outer function. That’s why we call it a Closure 🔁 Closures are the reason we can create: ✅ Private variables ✅ Function factories ✅ Modular, memory-efficient code In short — > A closure is how JavaScript gives functions memory 🧠 #JavaScript #Closures #WebDevelopment #Frontend #MERNStack #NodeJS #ReactJS #Coding #SoftwareEngineering #Developers #JSFundamentals

Understanding the difference between JavaScript's forEach() and map() is crucial for writing efficient code. Both iterate over arrays, but with key differences: forEach() runs a function on each array element without returning a new array. It’s great for side effects like logging or updating UI. map() transforms each element and returns a new array, perfect for data transformation without mutating the original array. Use forEach() when you want to perform actions without changing the array, and map() when you want to create a new array from existing data. Quick example: javascript const numbers = [1, 2, 3]; numbers.forEach(num => console.log(num * 2)); // Just logs the result const doubled = numbers.map(num => num * 2); // Returns [2, 4, 6] Master these to write cleaner, more expressive JavaScript! #JavaScript #WebDevelopment #ProgrammingTips #Coding

Relearning Frontend Fundamentals: A technical look at nodes in DOM tree can you guess how many nodes are there in the following html ?   <body>     <h1>DOM</h1>     text1     <p>Document Object Model</p>     white text2   </body> The answer is 9! ,Because all line breaks (\n) and indentations ( ) are parsed as separate Text Nodes (nodeType: 3). These fill the gaps between your Element Nodes. Even comments are treated as node (nodeType: 8) The most important node types are element (tags) and text (content) You can see the properties of each node below which shows relational data of each node with other nodes , value , type of node For more details about node properties ,types and methods have a look at mdn docs : https://lnkd.in/dqCP-yVC #FrontendDevelopment #JavaScript #DOM #WebDev #BrowserInternals

“The Secret Behind JavaScript’s Magic — The Event Loop 🧠” When I first learned JavaScript, I used to wonder — how can it handle so many things at once even though it’s single-threaded? 🤔 The answer lies in one beautiful mechanism — The Event Loop. Here’s what actually happens behind the scenes 👇 1️⃣ JavaScript runs in a single thread — only one thing executes at a time. 2️⃣ But when something async happens (like setTimeout, fetch, or Promise), those tasks are offloaded to the browser APIs or Node.js APIs. 3️⃣ Once the main call stack is empty, the event loop takes pending callbacks from the task queue (or microtask queue) and pushes them back into the stack to execute. So while it looks like JavaScript is multitasking, it’s actually just scheduling smartly — never blocking the main thread. Example:- console.log("Start"); setTimeout(() => console.log("Inside Timeout"), 0); Promise.resolve().then(() => console.log("Inside Promise")); console.log("End"); Output:- Start   End   Inside Promise   Inside Timeout Even though setTimeout was “0 ms”, Promises (microtasks) always run before timeouts (macrotasks). That’s the secret sauce 🧠💫 Understanding this single concept can help you debug async behavior like a pro. #JavaScript #EventLoop #Async #WebDevelopment #Coding

How JS Converts [] + {} to [object Object] —🤯 JavaScript can be weirdly magical sometimes. Ever tried this in your console? 👇 [] + {} // Output: "[object Object]" At first glance, it looks confusing — why does an empty array and an empty object become a string? Let’s decode the magic 🪄 1️⃣ + Operator in JS The + operator doesn’t just add numbers — it can also concatenate strings. 2️⃣ Type Conversion Happens! [] (empty array) → when converted to string becomes "" (empty string). {} (empty object) → when converted to string becomes "[object Object]". 3️⃣ Final Expression So JS actually does: "" + "[object Object]" → "[object Object]" ✅ Bonus twist: Try reversing it: {} + [] Now it gives 0 because {} is treated as an empty block,not an object. 🤯 JavaScript — where logic meets magic ✨ 🔹 Follow Prashansa Sinha for more fun JS mysteries and simple explanations 👩💻 #JavaScript #WebDevelopment #Coding #Frontend #JS #LearnToCode #Programming #TechCommunity #Developers #CodeNewbie #WebDev

💡 Most devs think shallow copies always affect the original… but that’s not true! Let’s clear this common JavaScript misconception 👇 🧩 Example 1 — Primitives let obj = { a: 1, b: 2, c: 3 }; let obj2 = { ...obj }; obj2.b++; console.log(obj.b); // 2 ✅ unchanged ➡️ Here b is a primitive (number). Primitives are copied by value, so obj and obj2 have separate copies. Incrementing obj2.b doesn’t affect obj.b. ⚠️ Example 2 — Nested Objects let obj = { a: 1, b: { x: 10 } }; let obj2 = { ...obj }; obj2.b.x = 99; console.log(obj.b.x); // 99 ❗changed ➡️ Here b is an object, and a shallow copy only copies its reference. Both obj.b and obj2.b point to the same memory. So changing one affects the other. 💬 TL;DR Shallow copy doesn’t always affect the original — it depends on what’s inside the object. Primitives → safe Objects → shared #JavaScript #Frontend #WebDevelopment #ReactJS #CodingTips #Programming #JSFacts

JavaScript Concept — “The Power of Closures” 💭 Ever wondered how JavaScript functions “remember” the variables around them? That’s the magic of Closures — one of JavaScript’s most elegant features. Closures allow a function to access variables from its outer scope, even after that scope has closed. This concept powers some of the most powerful patterns in JS — from private variables to event handlers. Here’s a small example 👇 function counter() { let count = 0; return function() { count++; return count; }; } const add = counter(); console.log(add()); // 1 console.log(add()); // 2 It’s simple, elegant, and shows how deep JavaScript really is. #JavaScript #WebDevelopment #Coding #Frontend #Learning

📌 Day 23 of My JavaScript Brush-up Series Today, I focused on one of the key features that makes JavaScript more organized and scalable Modules 📦 If you’ve ever worked on a growing codebase, you know how messy things can get when everything lives in one giant file. Modules fix that by letting you split code into reusable pieces. 👉🏿 What Are Modules? Modules let you separate your code into multiple files and control what gets shared between them. Each file can export what it wants to share, and other files can import those exports when needed. 👉🏿 Example: Exporting // math.js export const add = (a, b) => a + b; export const subtract = (a, b) => a - b; // or export all at once export default function multiply(a, b) { return a * b; } 👉🏿 Example: Importing // main.js import multiply, { add, subtract } from "./math.js"; console.log(add(5, 3)); // 8 console.log(subtract(10, 4)); // 6 console.log(multiply(2, 3)); // 6 👉🏿 Named vs Default Exports ✍🏿 Named exports → must be imported using {} and with the same name. ✍🏿 Default exports → one per file, can be imported with any name. 💡 Why Modules Matter ✍🏿 They promote code reusability and readability. ✍🏿 They help avoid variable clashes in the global scope. ✍🏿 They make your project modular and maintainable especially when using build tools or frameworks. 📸 I’ve attached a visual showing how modules communicate through import/export 👇🏿 👉🏿 Question: When did you first realize splitting code into modules makes debugging way easier? 😄 #JavaScript #LearningInPublic #FrontendDevelopment #DaysOfCode #WebDevelopment #Modules #ES6