JavaScript .sort() Quirk: Why [10, 2, 5] isn't [2, 5, 10]

💡 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: 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 👇

JavaScript type coercion isn't magic. It's a spec. Every unexpected output follows the same rules, in the same order: 1. Identify the operator 2. If an object is involved → call valueOf(), then toString() 3. If operator is + and either side is a string → concatenate 4. If operator is -, *, / → convert both sides to numbers 5. Compute That's it. Five steps. Runs every time. --- Where this breaks production code: [10] + [1] = "101" → Arrays are objects. valueOf() returns the array itself (not a primitive), so toString() runs next. [10].toString() = "10", [1].toString() = "1". Then + sees two strings. Concatenates. [10] - [1] = 9 → - forces ToNumber. [10] → 10, [1] → 1. Subtracts normally. Boolean([]) = true → [] is not in the falsy list. Truthy. "0" == false → true, but Boolean("0") → true → == coerces both sides to number first. Boolean() checks the falsy list directly. input.value, localStorage, URLSearchParams → Always strings. Wrap with Number() or parseInt() before any arithmetic. --- The complete falsy list (memorise this, not the edge cases): false / 0 / -0 / 0n / "" / null / undefined / NaN Eight values. Everything else is truthy. --- Use === by default. Use == only when you explicitly want coercion — and you almost never do. The spec is 20 years old. The bugs are still new because developers skip the fundamentals. #JavaScript #WebDev #Frontend #SoftwareEngineering #Programming

JavaScript just got way more powerful (and cleaner) with this feature… Most developers still write strings like this: "Hello " + name + " you are " + age + " years old" Messy Hard to read Error-prone But there’s a better way: Template Literals (ES6) Now you can write: Hello ${name}, you are ${age} years old Clean. Simple. Powerful. Here’s why Template Literals are a game changer: String Interpolation No more + operator chaos Directly embed variables inside strings Multi-line Strings Write clean formatted text without \n Embed Expressions ${num1 + num2} ${isAdmin ? "Admin" : "Guest"} Function Calls inside Strings ${greet()} Advanced Level (Most developers don’t use this enough): Tagged Template Literals Customize how strings are processed String.raw Handle raw strings like file paths easily Real Talk: Template literals don’t just improve code They improve how you think while writing code Cleaner syntax = Better readability = Fewer bugs My Take: If you're still not using template literals properly you're writing JavaScript the hard way Pro Tip: Use template literals for: Dynamic UI content API responses Clean logging HTML rendering I recently explored this deeply and it changed how I write strings in JavaScript What about you? Are you using template literals daily or still using + ? Here is link to visit my blog: https://lnkd.in/dYiNa-bz Piyush Garg | Hitesh Choudhary | Anirudh Patel | Suraj Kameshvar Prasad #javascript #webdevelopment #coding #programming #frontend #developers #learninpublic

✍️ One syntax change. Massive readability improvement. I wrote a complete guide on Template Literals in JavaScript — and why every developer should stop using + for string building. What's covered: → The exact problems with traditional string concatenation → How backtick strings work and what ${} actually does → Embedding variables, expressions, ternaries, and function calls inline → Multi-line strings — write HTML, SQL, and logs the way they're meant to look → Real use cases: dynamic URLs, HTML generation, dynamic class names, logging → Tagged template literals — how styled-components and GraphQL's gql work under the hood Readability is not a nice-to-have. It's how you write code other people (and future you) can actually maintain. Read the full blog here 👇 🔗https://lnkd.in/gJJp2xut Check out my Hashnode profile 👇 🔗 https://lnkd.in/gAwxuryw #JavaScript #WebDevelopment #CleanCode #Programming #ES6 #piyushgarg #chaicode #hiteshchoudhary

Hot take: var isn't just outdated — it was always broken. We just didn't have anything better. I wrote a deep-dive blog post explaining exactly why modern JavaScript dropped it: 1. No block scope — variables leak outside { } blocks 2. Attaches to the global window object 3. Silent hoisting — returns undefined before declaration with zero warnings 4. Can't shadow let/const across scope boundaries 5. Forces you to write closure workarounds that let fixes in one character The post also covers the Temporal Dead Zone, the classic setTimeout loop bug, and a real code example from a closure deep-dive. If you've ever been told "just don't use var" but never understood why — this one's for you. #JavaScript #ES6 #WebDevelopment #Frontend #Programming #TechBlog

🔁 Understanding Loops in JavaScript — A Quick Guide Loops are fundamental in JavaScript when you need to execute a block of code multiple times. Choosing the right loop can make your code more readable and efficient. Here are the most common types of loops in JavaScript 👇 1️⃣ "for" Loop – Best when you know how many times the loop should run. for (let i = 0; i < 5; i++) { console.log("Iteration:", i); } 2️⃣ "while" Loop – Runs as long as the condition remains true. let i = 0; while (i < 5) { console.log("Count:", i); i++; } 3️⃣ "do...while" Loop – Executes at least once before checking the condition. let i = 0; do { console.log("Value:", i); i++; } while (i < 5); 4️⃣ "for...of" Loop – Perfect for iterating over iterable objects like arrays, strings, or maps. const fruits = ["Apple", "Banana", "Mango"]; for (const fruit of fruits) { console.log(fruit); } 5️⃣ "for...in" Loop – Used to iterate over object keys. const user = { name: "Sujit", role: "Frontend Developer" }; for (let key in user) { console.log(key, user[key]); } 💡 Quick Tip: Use "for...of" for arrays and "for...in" for objects to keep your code clean and readable. Mastering loops helps you handle data structures, API responses, and complex logic more efficiently. #javascript #webdevelopment #frontend #codingtips #programming

🔁 Understanding Loops in JavaScript — A Quick Guide Loops are fundamental in JavaScript when you need to execute a block of code multiple times. Choosing the right loop can make your code more readable and efficient. Here are the most common types of loops in JavaScript 👇 1️⃣ "for" Loop – Best when you know how many times the loop should run. for (let i = 0; i < 5; i++) { console.log("Iteration:", i); } 2️⃣ "while" Loop – Runs as long as the condition remains true. let i = 0; while (i < 5) { console.log("Count:", i); i++; } 3️⃣ "do...while" Loop – Executes at least once before checking the condition. let i = 0; do { console.log("Value:", i); i++; } while (i < 5); 4️⃣ "for...of" Loop – Perfect for iterating over iterable objects like arrays, strings, or maps. const fruits = ["Apple", "Banana", "Mango"]; for (const fruit of fruits) { console.log(fruit); } 5️⃣ "for...in" Loop – Used to iterate over object keys. const user = { name: "Sujit", role: "Frontend Developer" }; for (let key in user) { console.log(key, user[key]); } 💡 Quick Tip: Use "for...of" for arrays and "for...in" for objects to keep your code clean and readable. Mastering loops helps you handle data structures, API responses, and complex logic more efficiently. #javascript #webdevelopment #frontend #codingtips #programming

I just added a new article to my series on functional programming for the web. It's actually a new variation on a previous article, but using lazy evaluation as allowed by JavaScript through iterators, and it shows some possibilities that will help in many other cases.