JavaScript Scope: let vs var in Blocks

🚀 **JavaScript: var vs let vs const (Every Developer Should Know This)** Understanding the difference between `var`, `let`, and `const` is one of the most important fundamentals in JavaScript. Let’s simplify it 👇 --- 🔴 **var** • Function scoped • Can be **reassigned** • Can be **redeclared** • Hoisted and initialized as `undefined` ```javascript var x = 10; x = 20; // ✅ allowed var x = 30; // ✅ allowed ``` ⚠️ Old JavaScript way. Avoid using `var` in modern code. --- 🟢 **let** • Block scoped `{ }` • Can be **reassigned** • ❌ Cannot be redeclared in the same scope • Hoisted but in **Temporal Dead Zone (TDZ)** ```javascript let y = 10; y = 20; // ✅ allowed let y = 30; // ❌ Error ``` ✔ Best for variables that will change. --- 🟣 **const** • Block scoped • ❌ Cannot be reassigned • ❌ Cannot be redeclared • Hoisted with **Temporal Dead Zone** ```javascript const z = 10; z = 20; // ❌ Error ``` ✔ Best for constants. --- 🎯 **Best Practice** ✔ Use **const by default** ✔ Use **let when value changes** ❌ Avoid **var** This makes your code **cleaner, safer, and predictable.** --- 💬 Interview Question: What is **Temporal Dead Zone (TDZ)** in JavaScript? Comment your answer 👇 --- #JavaScript #WebDevelopment #FrontendDevelopment #Coding #Programming #SoftwareEngineering #LearnToCode #DeveloperTips #JS #TechCommunity

But I can still change const even though it is immutable, Const a = [] a.push(7) Above code is completely valid. Can anyone explain that .. comment below 👇

🚀 **Scope in JavaScript (Every Developer Must Understand This)** Scope determines **where a variable is accessible** in your code. If you don’t understand scope, you’ll eventually face unexpected bugs. Let’s break it down 👇 --- ## 🌍 1️⃣ Global Scope Variables declared outside any function are accessible everywhere. ```js let name = "Abhishek"; function greet() { console.log(name); } ``` ✔ Accessible inside functions ✔ Accessible across the file --- ## 🧠 2️⃣ Function Scope (`var`) `var` is function-scoped. ```js function test() { var message = "Hello"; } console.log(message); // ❌ Error ``` It exists only inside the function. --- ## 📦 3️⃣ Block Scope (`let` / `const`) `let` and `const` are block-scoped. ```js if (true) { let age = 25; } console.log(age); // ❌ Error ``` Accessible only inside `{ }` --- ## ⚠ Common Mistake with `var` ```js if (true) { var age = 25; } console.log(age); // 25 😱 ``` Why? Because `var` ignores block scope and leaks outside the block. --- ## 🎯 Best Practice ✅ Use `const` by default ✅ Use `let` when value needs to change ❌ Avoid `var` in modern JavaScript --- Mastering scope makes you stronger in: ✔ Closures ✔ Event Loop ✔ Asynchronous JavaScript ✔ Interviews --- 💬 What should I explain next? 1️⃣ Closures 2️⃣ Event Loop #JavaScript #FrontendDevelopment #WebDevelopment #Programming #CodingInterview #JSConcepts #SoftwareEngineering #FullStackDeveloper #LearnToCode #DeveloperTips #100DaysOfCode #TechCommunity

😂 **JavaScript Be Like…** “This is my favorite language.” Until… ```js "11" + 1 // "111" "11" - 1 // 10 ``` And suddenly everyone is sweating 😅 --- ## 💡 What’s Happening Here? 🔹 `"11" + 1` → `+` triggers **string concatenation** → Result: `"111"` 🔹 `"11" - 1` → `-` forces **numeric conversion** → Result: `10` --- ### 🚀 Welcome to JavaScript Type Coercion JavaScript automatically converts types depending on the operator. ✔ `+` → Can concatenate strings ✔ `-`, `*`, `/` → Force numeric conversion This flexibility is powerful… But if you don’t understand it, it becomes dangerous. --- ### 🎯 Lesson: Always be aware of data types. Use `Number()`, `String()`, or `parseInt()` explicitly when needed. Because in JavaScript… It works. But not always the way you expect 😄 --- 💬 Have you ever been confused by JS type coercion? #JavaScript #FrontendDevelopment #WebDevelopment #ProgrammingHumor #CodingLife #JSConcepts #SoftwareEngineering #FullStackDeveloper #LearnToCode #TechCommunity #DeveloperMemes #100DaysOfCode

I used to write JavaScript strings like this… and it was painful. "Hello " + name + " welcome to JavaScript" Too many + signs. Hard to read. Easy to break. Then I discovered Template Literals in JavaScript. Suddenly strings became cleaner, more powerful, and much easier to manage. You can now: • Embed variables → ${name} • Embed expressions → ${total + tax} • Write multi-line strings easily • Improve code readability Example: let text = `Hello, ${name}! Welcome to JavaScript.`; Small feature. Huge improvement for writing clean JavaScript. I just published a quick blog explaining Template Literals with examples 👇 https://lnkd.in/dytp3HtH Would love your feedback and thoughts! Do you prefer template literals or string concatenation in JavaScript? 🤔 Hitesh Choudhary | Piyush Garg | Akash Kadlag | Shubham Waje | Suraj Kumar Jha #chaicode #JavaScript #WebDevelopment #Programming #LearnToCode #100DaysOfCode ``` 🚀

Method: Array.from() In JavaScript, Array.from() is one of the most underrated yet powerful methods that can make code cleaner, smarter, and more efficient. What is Array.from()? In simple words, Array.from() is a built-in JavaScript method that creates a new array from: ✅ Arrays ✅Array-like objects (like arguments or NodeList) ✅ Iterable objects like Maps and Sets Basic Syntax: Array.from(arrayLike, mapFunction) Example 1: const str = 'Hello' const array = Array.from(str) console.log(array); output: ['H', 'e', 'l', 'l', 'o '] Example 2: const numbers = [1, 2, 3, 4] const result = Array.from(numbers, number => number * 2) console.log(result); output: [2, 4, 6, 8] Example 2: const nums = Array.from({ length:10 },(value, i )=> i + 1) console.log(nums); output : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] #120DaysOfCode #JavaScript #WebDevelopment #Networking #API #JSON #AsyncAwait #FullStackDeveloper #MERNStackDeveloper #ReactDeveloper #BackendEngineer

💻 JavaScript Intermediate – Custom map() Function The map() method is widely used to transform arrays. Here’s how you can implement it manually. 📌 Problem: Apply a function to each element of an array and return a new array. function customMap(arr, callback) { let result = []; for (let i = 0; i < arr.length; i++) { result.push(callback(arr[i])); } return result; } let numbers = [1, 2, 3]; let doubled = customMap(numbers, function(num) { return num * 2; }); console.log(doubled); 📤 Output: [2, 4, 6] 📖 Explanation: • map() creates a new array by applying a function to each element. • Here, we manually implemented the same logic using a loop and callback. 💡 Tip: Understanding this helps you grasp how higher-order functions work in JavaScript. #JavaScript #Coding #WebDevelopment #FrontendDevelopment #LearnToCode #ProgrammingTips

📊 Day 13 – Poll Answer & Explanation ```javascript const a = [1, 2, 3]; const b = a; b.push(4); console.log(a); console.log(b); ``` ### ❓ What will be the output? ## ✅ Correct Answer: **B** ``` [1,2,3,4] [1,2,3,4] ``` --- ## 📌 Step-by-Step Explanation **1️⃣ Arrays are Reference Types** In **JavaScript**, arrays are **objects**. Objects are stored in **memory by reference**, not by value. --- **2️⃣ Assigning `b = a`** ```javascript const b = a; ``` This **does NOT create a new array**. Instead, **both `a` and `b` point to the same array in memory**. ``` a ──► [1,2,3] b ──► ``` --- **3️⃣ Modifying the Array** ```javascript b.push(4); ``` Since **`b` references the same array**, the original array is modified. ``` a ──► [1,2,3,4] b ──► ``` --- **4️⃣ Final Output** ```javascript console.log(a); // [1,2,3,4] console.log(b); // [1,2,3,4] ``` Both variables print the **same updated array**. --- ## 💡 Key Takeaway 👉 **Arrays and objects in JavaScript are stored by reference.** 👉 If multiple variables reference the **same object**, modifying one **affects all of them**. #JavaScript #WebDevelopment #FrontendDevelopment #Programming #CodingInterview #DeveloperCommunity #100DaysOfCode #LearnToCode

💡 Pass by Value vs Pass by Reference in JavaScript (Simple Explanation) If you're learning JavaScript, understanding how data is passed is crucial 👇 🔹 Pass by Value (Primitives) When you assign or pass a primitive type (number, string, boolean, null, undefined, symbol, bigint), JavaScript creates a copy. let a = 10; let b = a; b = 20; console.log(a); // 10 console.log(b); // 20 👉 Changing b does NOT affect a because it's a copy. 🔹 Pass by Reference (Objects) When you work with objects, arrays, functions or date objects, JavaScript passes a reference (memory address). let obj1 = { name: "Ali" }; let obj2 = obj1; obj2.name = "Ahmed"; console.log(obj1.name); // Ahmed console.log(obj2.name); // Ahmed 👉 Changing obj2 ALSO affects obj1 because both point to the same object. 🔥 Key Takeaway Primitives → 📦 Copy (Independent) Objects → 🔗 Reference (Shared) 💭 Pro Tip To avoid accidental changes in objects, use: Spread operator {...obj} Object.assign() Understanding this concept can save you from hidden bugs in real-world applications 🚀 #JavaScript #WebDevelopment #Frontend #Programming #CodingTips

🚨 JavaScript Dates are full of quirks… but a better solution is coming... While on mission of understanding JavaScript today, I learned Strings and the Date object — and discovered how surprisingly complex they are under the hood. What I learned about Strings JavaScript strings are immutable. Any method applied to a string returns a new string instead of modifying the original one. There are three ways to create strings: • 'single quotes' • "double quotes" • `template literals` Template literals are the most modern and flexible because they allow: • Multi-line strings • Embedded expressions using ${} • Cleaner and more readable code I also practiced several important string properties and methods: • length • character indexing • toUpperCase() / toLowerCase() • indexOf() / lastIndexOf() / includes() • slice() / substring() • replace() / replaceAll() • trim() • split() Another interesting detail is that strings are primitive values but behave like objects when methods are called — JavaScript temporarily wraps them using an internal object. Now comes to JavaScript Dates One surprising fact: A JavaScript Date is basically just a big number. That number represents the milliseconds since the Unix Epoch: Jan 1, 1970 — 00:00:00 UTC Learned various methods of creating date. Some quirks of JavaScript Dates JavaScript’s Date API has a few odd behaviors: • Months are zero-indexed (January = 0) • Date objects are mutable • Many methods depend on the local timezone A better future: Temporal API The JavaScript community is working on a modern replacement called Temporal. I summarized these concepts in a carousel of notes to reinforce my understanding. Course Instructor: Rohit Negi | Youtube channel: Coder Army #JavaScript #WebDevelopment #LearningInPublic #TemporalAPI #BuildInPublic #Fullstackdevelopment