Why var vs let matters in JavaScript loops and setTimeout

🔍 How JavaScript source maps actually work (I never asked…) Today I stumbled upon a great post about JavaScript source maps. We've been using source maps for years… but I never actually stopped to ask myself how the magic works. 📌 TL;DR, Things I didn’t know: 0️⃣ A source map is just a JSON file that maps every chunk of minified code back to the original file, line & column. 1️⃣ The weird mappings string is a compact Base64 + VLQ (variable length quantity, for compressing numbers efficiently) encoding of deltas, not gibberish. 2️⃣ Browsers/devtools decode it instantly, so breakpoints and errors show up in the real code instead of bundle.min.js. 3️⃣ It’s heavily optimized, which is why it’s tiny and fast enough to ship with production bundles. If you ever wondered what’s inside a .map file or how devtools time-travel back to the original code, check this out: 🔗 https://lnkd.in/dhKfX2Vr #javascript #webdev #typescript #frontend #debugging #performance #programming #developers #sourcemaps #webtools

📌 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

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

Hey, Mates. How are you doing? You know, Even experienced devs trip over JavaScript quirks sometimes — here are a few I’ve seen (and made myself 😅 as well): 1. Using var instead of let or const var is function-scoped and can cause weird bugs due to hoisting. ✅ Use let for variables that change and const for ones that don’t. 2. Forgetting to handle async properly Mixing promises, callbacks, and async/await can lead to race conditions or unhandled rejections. ✅ Always await async functions or chain with .then(), and wrap in try/catch. 3. Comparing values incorrectly == does type coercion (and sometimes weirdly!). ✅ Stick to === for strict comparison. 4. Misunderstanding this Arrow functions don’t have their own this — they inherit from the parent scope. ✅ Know when to use arrow functions vs regular ones. 5. Not handling floating-point math 0.1 + 0.2 !== 0.3 (yes, really). ✅ Use libraries like decimal.js or round your values when precision matters. ⸻ These are small details — but they separate good JavaScript from great JavaScript. 💬 What’s a JS mistake you’ve seen (or made) that taught you something valuable? #JavaScript #WebDevelopment #Programming #CodingTips #Frontend

When I started learning the DOM in Javascript, I thought it would be simple. You know… “Just select elements and change them,” right? 😂 I didn’t know I was entering a battlefield. Let me share a short story. The first time I wrote document.getElementById(), I spent almost 20 minutes wondering why my code wasn’t working… Only to realize my HTML had id="titel" instead of id="title". One small typo. One long headache. 😭 Then came the moment I tried to change text with .textContent. I refreshed the browser like 12 times, cleared cache, even restarted VS Code… Turns out I placed my script above the HTML, so the DOM hadn’t loaded yet. 🥲 But here’s where it gets interesting: Every error made me better. Every bug forced me to understand what the browser was actually doing. Every “why is this not working?” pushed me to learn one more thing. Now when I manipulate the DOM, it feels like I understand it better. So here’s my question to you: What was the first big challenge you faced while learning the DOM or JavaScript in general? Let’s share and learn from each other. 👇 #javascript #frontend #webdevelopment #codingjourney #learninpublic  #techcommunity #developerlife #programming #html #css #DOM

Today’s JavaScript Learning: DOM & Window Object I explored how JavaScript interacts with the browser environment using the Window object and the Document Object Model (DOM). Learnt how to: Access and manipulate HTML elements dynamically using methods like getElementById() getElementsByClassName() getElementsByTagName() querySelector() & querySelectorAll() Modify content and style directly from JavaScript using properties like innerText, innerHTML, and textContent Create and update elements in real time — like appending unique text to multiple divs! This session really helped me understand how JavaScript controls and updates web pages behind the scenes. #javascriptlearning #webdevelopment #frontend #dommanipulation #codingjourney

💡 Understanding var, let, and const in JavaScript — A Must for Every Developer! When writing JavaScript, knowing how variables behave is crucial for clean and bug-free code. Here’s a quick breakdown 👇 🔹 var Scope: Function-scoped Hoisted: Yes (initialized as undefined) Re-declaration: Allowed ⚠️ Can cause unexpected results due to hoisting and re-declaration. 🔹 let Scope: Block-scoped ({ }) Hoisted: Yes (but not initialized — Temporal Dead Zone) Re-declaration: ❌ Not allowed in same scope ✅ Preferred for variables that can change. 🔹 const Scope: Block-scoped Hoisted: Yes (not initialized — Temporal Dead Zone) Re-declaration / Re-assignment: ❌ Not allowed ✅ Use for constants and values that never change. 🔍 Example: { var a = 10; let b = 20; const c = 30; } console.log(a); // ✅ Works (function-scoped) console.log(b); // ❌ Error (block-scoped) console.log(c); // ❌ Error (block-scoped) 🧠 Pro tip: Always prefer let and const over var for predictable and safer code. ✨ Which one do you use most often — let or const? Let’s discuss 👇 #JavaScript #WebDevelopment #Frontend #CodingTips #ES6

Recently I was preparing for JavaScript and I stumbled upon a simple concept — but most people don’t know the key differences between var and let. Here’s a quick example: ` for (var i = 0; i < 3; i++) {  setTimeout(() => console.log(i), 1000); } // Output: 3 3 3 ` ` for (let i = 0; i < 3; i++) {  setTimeout(() => console.log(i), 1000); } // Output: 0 1 2 ` Key differences: Scope: var is function-scoped, let is block-scoped. Hoisting & Temporal Dead Zone: var is hoisted and initialized with undefined, let is hoisted but not initialized — accessing it before declaration throws a ReferenceError. Understanding these small details can save you from tricky bugs, especially in loops and async code! #JavaScript #JS #WebDevelopment #FrontendDevelopment #Coding #LearnToCode #DeveloperTips #TechCommunity #CodeSnippet #Programming ## I’d appreciate it if you could share a few more examples to help me understand.

💡 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

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