Shobhit Asthana’s Post

🚀 Day 7/100 of #100DaysOfCode Today was all about strengthening JavaScript fundamentals — revisiting concepts that seem simple but are often misunderstood. 🔁 map() vs forEach() Both are used to iterate over arrays, but they serve different purposes: 👉 map() Returns a new array Used when you want to transform data Does not modify the original array Example: const doubled = arr.map(num => num * 2); 👉 forEach() Does not return anything (undefined) Used for executing side effects (logging, updating values, etc.) Often modifies existing data or performs actions Example: arr.forEach(num => console.log(num)); ⚔️ Key Difference: Use map() when you need a new transformed array Use forEach() when you just want to loop and perform actions ⚖️ == vs === (Equality in JS) 👉 == (Loose Equality) Compares values after type conversion Can lead to unexpected results Example: '5' == 5 // true 😬 👉 === (Strict Equality) Compares value AND type No type coercion → safer and predictable Example: '5' === 5 // false ✅ 💡 Takeaway: Small concepts like these make a big difference in writing clean, bug-free code. Mastering the basics is what separates good developers from great ones. 🔥 Consistency > Intensity On to Day 8! #JavaScript #WebDevelopment #CodingJourney #LearnInPublic #Developers #100DaysOfCode #SheryiansCodingSchool #Sheryians

🚨 JavaScript finally started making sense after this… For a long time, I was just using functions in JS. But recently, I learned about: 👉 Scope 👉 Closures 👉 Higher Order Functions (HOF) And things clicked differently. 💡 Here’s what changed my understanding: ✅ Scope It’s not just about variables — it’s about where your code can access data ✅ Closures -> This blew my mind 🤯 A function doesn’t just execute… It remembers the environment where it was created. 👉 Even after the outer function is gone. ✅ Higher Order Functions Functions in JavaScript are not just “callable” They are: ✔ Passed as arguments ✔ Returned from other functions ✔ Stored like values 💡 The biggest shift for me: 👉 “Functions are not just actions, they are values with memory. They are first-class citizens in JavaScript” If you’re learning JavaScript: Don’t rush. These concepts feel hard at first… but once they click, everything changes. Course Instructor: Rohit Negi | Youtube Channel: CoderArmy. #JavaScript #WebDevelopment #Closures #fullstackdevelopment #LearnInPublic #coding

🚀 Day 89 of My #100DaysOfCode Challenge I thought JavaScript automatically manages memory… so we don’t have to worry about it, right? 🤔 Wrong. Today I learned about something most beginners ignore — Garbage Collection in JavaScript. 💡 What actually happens? JavaScript automatically removes unused memory using something called Garbage Collection. It works on a simple idea: 👉 If something is not reachable, it gets removed from memory. 🧠 Example let user = { name: "Tejal" }; user = null; // now previous object becomes unreachable Now JavaScript will automatically clean this memory. --- ⚠️ But here’s the real problem… Even with automatic memory cleanup, memory leaks can still happen. Some common reasons: • Unused event listeners • Closures holding references • Global variables not cleared --- 💭 What I realized I used to think memory management is not my problem as a developer… But now I understand: 👉 Writing clean code also means not holding unnecessary memory --- JavaScript handles a lot for us… but understanding what’s happening behind the scenes makes a huge difference. Learning something new every day 💻✨ #Day89 #100DaysOfCode #JavaScript #WebDevelopment #CodingJourney #LearningInPublic

Day 4 of my JavaScript learning journey. Today I learned one of the most confusing concepts so far: Hoisting. I tried something strange. greet(); function greet() { console.log("Hello!"); } The function worked even before it was defined. That’s because of hoisting. JavaScript reads the whole code first and moves function declarations to the top internally. But variables behave differently. console.log(x); var x = 5; This prints undefined, not 5. And if we use let or const, JavaScript throws a ReferenceError. This area is called the Temporal Dead Zone. My takeaway today: Always declare variables before using them. Day 4 done. JavaScript keeps getting more interesting. What JavaScript concept confused you the most when you first learned it? #JavaScript #LearningInPublic #WebDevelopment #100DaysOfCode #Frontend

🚀 Day 11 of My JavaScript Learning Journey Today I learned about JavaScript Scopes and Function Execution Context (FEC) — a core concept to understand how JavaScript manages variables and executes code. 📌 Key concepts I explored: 🔹 Scopes in JavaScript • Global Scope – Variables accessible throughout the program • Local Scope – Variables accessible within a function • Block Scope – Variables declared with let and const inside {} 🔹 Key Difference • var → Function scoped • let & const → Block scoped 🔹 Function Execution Context (FEC) Every time a function is called, JavaScript creates a new execution context. ⚙️ FEC Lifecycle: 1️⃣ Memory Creation Phase • Variables are hoisted and initialized • Functions are stored in memory 2️⃣ Execution Phase • Code runs line by line • Variables get their actual values 🔹 FEC Components • Variable Environment • Scope Chain (access to outer scope) • this keyword 💡 Understanding scopes and execution context helps in writing efficient, bug-free, and optimized JavaScript code. Step by step, I’m strengthening my JavaScript fundamentals and internal working knowledge. 💻✨ #JavaScript #WebDevelopment #FrontendDevelopment #CodingJourney #LearningInPublic #DeveloperJourney #ProgrammingBasics

📣 𝗡𝗲𝘅𝘁 𝗕𝗹𝗼𝗴 𝗶𝘀 𝗛𝗲𝗿𝗲! ⤵️ Arrow Functions in JavaScript — A Simpler Way to Write Functions ⚡🧠 Regular functions work fine. But when logic becomes small and frequent, typing all that syntax starts feeling heavy. This blog explains arrow functions in a clear, beginner-friendly way — focusing on syntax, mental models, and real usage. 🔗 𝗥𝗲𝗮𝗱 𝗵𝗲𝗿𝗲: https://lnkd.in/gMBAZxX5 𝗧𝗼𝗽𝗶𝗰𝘀 𝗰𝗼𝘃𝗲𝗿𝗲𝗱 ✍🏻: ⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺ ⇢ What arrow functions actually are ⇢ Converting normal functions to arrow step by step ⇢ Basic syntax and parameter rules ⇢ Implicit return — the real magic ⇢ When implicit return does NOT work ⇢ Using arrow functions in map(), filter(), and callbacks ⇢ Common beginner mistakes and how to fix them ⇢ When to use arrow functions vs regular functions ⇢ Practical examples for faster understanding 💬 If functions still feel verbose or repetitive, this article helps you write cleaner and more modern JavaScript. #ChaiAurCode #JavaScript #ArrowFunctions #WebDevelopment #ProgrammingBasics #Beginners #LearningInPublic #100DaysOfCoding

🚀 Just finished building my JavaScript Complete Theory Notes / Cheat Sheet 📘⚡ Over the past few days, I compiled a structured roadmap of JavaScript concepts covering everything from fundamentals to advanced topics. Here’s what I included 👇 🔹 Variables & Data Types 🔹 Operators, Type Coercion & Control Flow 🔹 Functions, Scope, Closures & Hoisting 🔹 this keyword and prototypes 🔹 Arrays, Objects, Maps & Sets 🔹 ES6+ features like Destructuring, Spread, Rest, Modules 🔹 Async JavaScript (Callbacks, Promises, Async/Await, Event Loop) 🔹 DOM Manipulation & Event Handling 🔹 Web APIs, Storage, and Modern JS Patterns What started as simple revision notes slowly turned into a complete developer reference guide. The best part? While writing this, I didn’t just memorize syntax, I started understanding how JavaScript actually thinks behind the scenes: ⚡ Call Stack ⚡ Heap Memory ⚡ Event Loop ⚡ Microtasks vs Macrotasks Learning never stops. Next step: applying these concepts in real-world projects and interview-focused problem solving 💻🔥 #JavaScript #WebDevelopment #FrontendDeveloper #ReactJS #FullStackDeveloper #CodingJourney #SoftwareDevelopment #LearningInPublic #TechJourney

DAY 07 of Tech Today I learned about **objects in JavaScript**, and I kept it simple so I could really understand it. An object is just a way to store data using **key and value pairs**. It helps organize information better instead of using too many separate variables. One thing that surprised me was **auto-boxing**. I learned that JavaScript can turn simple values like strings into objects for a short time. That’s why I can use things like `.toUpperCase()` on a string. JavaScript handles it in the background, which is really interesting. I also learned about **methods**. A method is just a function inside an object. This means an object can store data and also do something with that data. Next was **shorthand object properties**. Instead of repeating the same name twice, JavaScript allows me to write it in a shorter way when the variable name matches the key. It makes my code cleaner. Then I learned **shorthand methods**, which is just a shorter way to write functions inside objects. It looks neater and saves time. Lastly, I looked at **built-in objects** like `Math` and `Date`. These are already created in JavaScript, so I can use them anytime without building them myself. Today’s lesson helped me understand that objects are very important in JavaScript, and I’m getting more comfortable using them. #LearningwithTsacademy #30daysofTech #JavaScript

📣 𝗡𝗲𝘅𝘁 𝗕𝗹𝗼𝗴 𝗶𝘀 𝗛𝗲𝗿𝗲! ⤵️ Function Declaration vs Function Expression — What’s the Real Difference? 🧠⚙️ Functions help you stop repeating logic. But JavaScript gives you more than one way to create them. This blog explains the difference between function declarations and function expressions — in a calm, beginner-friendly way. 🔗 𝗥𝗲𝗮𝗱 𝗵𝗲𝗿𝗲: https://lnkd.in/gfrPt9t2 𝗧𝗼𝗽𝗶𝗰𝘀 𝗰𝗼𝘃𝗲𝗿𝗲𝗱 ✍🏻: ⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺ ⇢ Why functions exist (reusability mental model) ⇢ Function declaration syntax and usage ⇢ Function expression and storing functions in variables ⇢ Side-by-side comparison of both styles ⇢ Hoisting explained through simple experiments ⇢ The confusing var behavior trap ⇢ When to prefer declarations vs expressions ⇢ Real practice examples that make the difference click ⇢ Beginner advice to avoid overthinking 💬 If hoisting or function types ever confused you, this article helps you see the practical difference instead of memorizing theory. #ChaiAurCode #JavaScript #Functions #ProgrammingBasics #WebDevelopment #Beginners #LearningInPublic #100DaysOfCoding

🧠 Ever wondered how JavaScript keeps track of which function is running? JavaScript uses something called the Call Stack. Think of it like a stack of tasks where functions are added and removed as they execute. 🔹 How the Call Stack Works JavaScript follows a Last In, First Out (LIFO) rule. That means: The last function added to the stack is the first one to finish. Example function first() { second(); } function second() { third(); } function third() { console.log("Hello from third function"); } first(); What happens in the Call Stack 1️⃣ first() is pushed to the stack 2️⃣ second() is called → pushed to the stack 3️⃣ third() is called → pushed to the stack 4️⃣ third() finishes → removed from stack 5️⃣ second() finishes → removed 6️⃣ first() finishes → removed 🔹 Visualising the Stack Call Stack at peak: - third() - second() - first() - Global() Then it unwinds back to the Global Execution Context. 💡 Why This Matters Understanding the call stack helps you understand: - Execution order - Stack overflow errors - Debugging JavaScript - Async behaviour It’s one of the core mechanics of the JavaScript engine. Next post: The Event Loop 🚀 #JavaScript #CallStack #Frontend #WebDevelopment #LearnJS #Programming #LearningInPublic