"Mastering Conditional Statements in JavaScript"

✨ Today I learned something simple but powerful in JavaScript — Removing duplicates & flattening arrays! These two tricks help keep your data clean and easy to work with. 🚀 🔹 Remove Duplicates from an Array Using Set (fast & clean): const numbers = [1, 2, 2, 3, 4, 4, 5]; const uniqueNumbers = [...new Set(numbers)]; console.log(uniqueNumbers); // [1, 2, 3, 4, 5] --- 🔹 Flatten a Nested Array Using flat(): const nested = [1, [2, [3, 4]], 5]; const flatArray = nested.flat(2); console.log(flatArray); // [1, 2, 3, 4, 5] --- 🔥 These small improvements help write cleaner, more readable code. If you're learning JavaScript, definitely try these out! #JavaScript #Learning #WebDevelopment #CodingJourney #100DaysOfCode

🚀 If you still use var in JavaScript... you’re living in 2010! Let’s talk about one of the most underrated but powerful differences every JS developer must understand 👇 When I was learning JavaScript, I thought var and let were just different ways to declare a variable... But the day I understood why let replaced var, everything changed. 💡 Here’s the truth: 🔹 var is function-scoped, gets hoisted, and even worse — it attaches itself to the window object in browsers! Meaning: Anyone can access or even overwrite your variables globally 😱 var token = "mySecret"; console.log(window.token); // 🫣 Accessible to everyone Now imagine storing API keys, tokens, or user info like that... Yes — that’s not just bad practice; it’s a security risk. 🔒 Why let (and const) are the heroes: ✅ Block-scoped (safe inside { }) 🚫 Not attached to window ⚡ No accidental redeclaration 🔥 Prevents bugs caused by hoisting They bring safety, clarity, and modern standards to your code. When you finally understand this while learning JS, you realize why every developer, framework, and company today avoids var completely. It’s not just about syntax — it’s about secure, predictable, and professional JavaScript. 💪 #JavaScript #WebDevelopment #CodingTips #FrontendDevelopment #MERNStack #LearnCoding #WebDeveloper #CodeNewbie #TechCommunity #DeveloperLife #CodingJourney #LetsCode #100DaysOfCode

💻 Day 16— Coder Army | JavaScript Project Today I created a Background Color Changer App using pure HTML, CSS, and JavaScript 🎨 In this project, I used Event Delegation — a JavaScript technique that allows handling all button clicks with just one event listener 👇 Whenever you click a color button, the entire page background changes to that color instantly 💡 🧠 Key Learnings: DOM Selection using getElementById() and querySelector() Event Handling using addEventListener() Event Object & event.target to detect which button was clicked Dynamic Style Change using style.backgroundColor ⚙️ Core JS Code: const parent = document.getElementById('parent'); parent.addEventListener('click', (event) => { const child = event.target; const body = document.querySelector('body'); body.style.backgroundColor = child.id; }); This small project helped me understand how one event listener can manage multiple elements efficiently 🧠✨ 💬 Simple logic, great learning — that’s the power of JavaScript + Coder Army practice 💪 #CoderArmy #JavaScript #Day17 #MiniProject #WebDevelopment #CodingJourney #LearnByDoing #RohitNygi

 Understanding Variables in JavaScript Today, I explored one of the core fundamentals of JavaScript — Variables. Variables act as containers for storing data, and they play a major role in how programs handle, update, and manage information. JavaScript provides three ways to declare variables: var, let, and const. Each behaves differently in terms of scope, reassignment, and hoisting — making it important to choose the right one based on the requirement. 🔍 Key Points I Learned ✔️ Variables store dynamic values like numbers, strings, arrays, objects, etc. ✔️ var → function-scoped, older way, can lead to unexpected behavior ✔️ let → block-scoped, ideal for values that change ✔️ const → block-scoped, used for fixed values (cannot be reassigned) ✔️ ES6 improved code reliability by introducing let and const Building strong fundamentals like variables helps in writing cleaner, predictable, and modern JavaScript code. 🚀 Grateful to my mentor Sudheer Velpula for guiding and encouraging consistent learning. 🙌 #JavaScript #Variables #WebDevelopment #Frontend #CodingJourney #ES6 #ProgrammingBasics #LearnJavaScript #TechLearning #DeveloperCommunity

🚀 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

🧠 JavaScript Closures — Explained in a Simple Way In JavaScript, a closure happens when a function remembers and can still use variables from the place where it was created — even after the outer function has finished. Think of it like having a key to a room. Even if the door is closed later… you can still enter and use the items inside. 🔑🚪 Here’s a quick example: function outer() { let message = "Hello 👋"; return function inner() { console.log(message); }; } const fn = outer(); fn(); // 👉 Output: Hello 👋 ✅ inner() still has access to message ✅ That memory power = Closure 🌟 Why Closures Are Useful? Private data (hidden variables) Remembering values (callbacks, timers) Custom functions (pre-filled data) Example: function greet(name) { return () => console.log("Hello " + name); } const hiJohn = greet("John"); hiJohn(); // Hello John 🔹One-line Definition: Closure = Function + Remembered outer variables If you found this helpful, follow for more: JavaScript | Full Stack | Real-world Coding Tips #JavaScript #Closures #Coding #WebDevelopment #LearnJS #Cognothink

*5 Things I Wish I Knew When Starting JavaScript 👨💻* Looking back, JavaScript was both exciting and confusing when I started. Here are 5 things I wish someone had told me earlier: *1. var is dangerous. Use "let" and "const" "var" is function-scoped and can lead to unexpected bugs. "let" and "const" are block-scoped and safer. *2. JavaScript is asynchronous Things like "setTimeout()"and "fetch()" don’t behave in a straight top-down flow. Understanding the *event loop* helps a lot. *3. Functions are first-class citizens* – You can pass functions as arguments, return them, and even store them in variables. It’s powerful once you get used to it. *4. The DOM is slow – avoid unnecessary access* – Repeated DOM queries and manipulations can hurt performance. Use "documentFragment" or batch changes when possible. *5. Don’t ignore array methods* map(), "filter()" , "reduce()", "find()"… they make code cleaner and more readable. I wish I started using them sooner. 💡 *Bonus Tip:* "console.log()" is your best friend during debugging! If you’re starting out with JS, save this. And if you're ahead in the journey — what do *you* wish you knew earlier? #JavaScript #WebDevelopment #CodingJourney #Frontend #LearnToCode #DeveloperTips

💛 𝗗𝗮𝘆 𝟯 — 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁: 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 𝗮𝗻𝗱 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 Today’s focus was one of the most powerful and favorite topics in JavaScript — 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 🔁 💡 𝗖𝗼𝗻𝗰𝗲𝗽𝘁: A closure gives a function access to its outer scope even after the outer function has finished execution. This enables data encapsulation, function factories, and state preservation. 💻 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 𝟭 — 𝗕𝗮𝘀𝗶𝗰 𝗖𝗹𝗼𝘀𝘂𝗿𝗲: function outer() {  let count = 0;  return function inner() {   count++;   console.log("Count:", count);  }; } const counter = outer(); counter(); // Count: 1 counter(); // Count: 2 🧠 Here, inner() remembers the variable count from outer() even after it’s done — that’s closure in action! 💻 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 𝟮 — 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗨𝘀𝗲: Closures power concepts like private variables: function createUser(name) {  return {   getName: function () {    return name;   },  }; } const user = createUser("Ravi"); console.log(user.getName()); // Ravi 🧠 𝗞𝗲𝘆 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀: ✅ Inner functions retain references to outer scope variables. ✅ Closures are the backbone of callbacks, event handlers, and functional programming. ✅ Used in frameworks like React (hooks rely on closure principles). 🔥 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆: Closures aren’t magic — they’re just functions remembering where they came from. #JavaScript #Closures #Functions #FrontendDevelopment #100DaysOfCode #LearningEveryday

#1: JavaScript Variables - From Basics to Best Practices 🚀 Just stumbled upon a JavaScript behavior that might surprise many beginners - and even some experienced developers! Let me break it down: // The usual suspects const apiKey = "abc123"; let userName = "sandeepsharma"; var userRole = "admin"; // The sneaky one that causes trouble userLocation = "Berlin"; // Wait, no declaration?! Here's what's happening behind the scenes: When you assign a value without const, let, or var, JavaScript quietly creates a global variable: // In browser environments: window.userLocation = "Berlin"; console.log(userLocation); // "Berlin" - it works! Why this should scare you: 🌐 Pollutes the global namespace 🔍 Makes debugging a nightmare 💥 Can overwrite existing variables 🚨 Throws ReferenceError in strict mode The Professional Fix: "use strict"; // Your new best friend const apiKey = "abc123"; // Constant values let userName = "sandeepsharma"; // Variables that change var userRole = "admin"; // Legacy - avoid in new code let userStatus; // Properly declared undefined My Golden Rules for Variables: 1. Start with const - use it by default 2. Upgrade to let only when reassignment is needed 3. Retire var - it's time to move on 4. Never use undeclared variables - strict mode prevents this 5. Always initialize variables - even if with undefined Pro Debugging Tip: // Instead of multiple console.log statements: console.table({apiKey, userName, userRole, userLocation, userStatus}); Notice Line: Explicit declarations make your code more predictable, maintainable, and professional. That accidental global variable might work today but could cause hours of debugging tomorrow! What's your favorite JavaScript variable tip? Share in the comments! 👇 #JavaScript #WebDevelopment #ProgrammingTips #Coding #SoftwareEngineering #Tech #CareerGrowth

New Video in our DSA in JavaScript Series! In this video, we start a brand-new chapter — Queue 🧠 — one of the most important data structures in DSA! You’ll learn step-by-step what a Queue is, how it follows the FIFO (First In, First Out) principle, and where it’s used in real-world applications and DSA problems. We’ll go through: - What is a Queue and how it works - Understanding the FIFO concept with real-life examples - Queue operations — Enqueue, Dequeue, Peek, isEmpty, isFull - Where Queues are used in DSA (BFS, Scheduling, Buffers, etc.) By the end of this video, you’ll clearly understand: How Queue differs from Stack (FIFO vs LIFO) Why Queues are essential in problem solving Real-life use cases like Printer Queue, Task Scheduling, etc. Foundation for upcoming topics like Circular Queue, Priority Queue, and Deque This is a concept + theory video, so make sure to watch till the end before we move to implementation in the next one! * Watch here → https://lnkd.in/gyWSuZ4V * Watch the complete DSA in JavaScript playlist here: https://lnkd.in/g2qrGaSH * Download the PPT for this topic here: https://lnkd.in/gnga7zf6