Understanding JavaScript Objects: Key-Value Pairs and More

🚀 **𝐃𝐚𝐲 5 – 𝐇𝐨𝐢𝐬𝐭𝐢𝐧𝐠 𝐢𝐧 𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 (𝐂𝐥𝐞𝐚𝐫 & 𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐚𝐥 𝐄𝐱𝐩𝐥𝐚𝐧𝐚𝐭𝐢𝐨𝐧)** You might have seen this 👇 👉 Using a variable before declaring it But why does this work? 🤔 --- 💡 **What is Hoisting?** Hoisting means: 👉 Before execution, JavaScript **allocates memory for variables and functions** 👉 In simple words: **Declarations are processed before code runs** --- 💡 **Example:** ```js id="d5pro1" console.log(a); var a = 10; ``` 👉 Output: `undefined` --- 💡 **What actually happens behind the scenes?** Before execution (Memory Phase): * `a` → undefined Then execution starts: * `console.log(a)` → prints undefined * `a = 10` --- 💡 **Important Rule** 👉 JavaScript only hoists **declarations**, not values --- 💡 **var vs let vs const** 👉 **var** * Hoisted * initialized as `undefined` * can be accessed before declaration 👉 **let & const** * Hoisted * BUT not initialized --- ⚠️ **Temporal Dead Zone (TDZ)** This is the time between: 👉 variable declared 👉 and initialized During this: ❌ Accessing variable → **ReferenceError** --- 💡 **Example:** ```js id="d5pro2" console.log(a); let a = 10; ``` 👉 Output: **ReferenceError** --- ⚡ **Key Insight (Very Important)** 👉 Hoisting is NOT moving code 👉 It’s just **memory allocation before execution** --- 💡 **Why this matters?** Because it helps you understand: * unexpected `undefined` values * ReferenceErrors * how JavaScript actually runs code --- 👨💻 Continuing my JavaScript fundamentals series 👉 Next: **JavaScript Runtime & Event Loop** 👀 #JavaScript #WebDevelopment #FrontendDevelopment #Coding #SoftwareEngineer #Tech

I wrote a beginner-friendly post on JavaScript objects. It covers what objects are, why they’re useful, and how they help group related data together in a structured way, with simple examples. If you’re learning JavaScript basics, this might be helpful: https://lnkd.in/gVf6z8Yy Feedback is welcome. Hitesh Choudhary Piyush Garg

🚀 Day 10 of My JavaScript Journey ✨Today I explored how JavaScript actually works behind the scenes — and honestly, it changed the way I look at code completely 🤯 Here’s what I learned 👇 🧠 How JavaScript Code RunsJavaScript doesn’t just execute line by line — it first creates an Execution Context which manages everything. ⚙️ Execution Context Phases1️⃣ Memory Allocation Phase Variables get stored with undefined Functions are stored completely 2️⃣ Execution Phase Code runs line by line Values get assigned and functions execute 📦 Call Stack & Execution Flow JavaScript uses a Call Stack to manage function calls Each function creates its own execution context Stack follows LIFO (Last In, First Out) 💾 Stack vs Heap Memory Stack → Stores primitive values (fast ⚡) Heap → Stores objects (reference-based 🧩) 🤖 Interpreter BehaviorJavaScript reads and executes code step by step using an interpreter — not compiled like some other languages. ❓ Why undefined Appears?Because during memory phase, variables are declared but not initialized yet. ⬆️ Hoisting Explained var is hoisted with undefined Functions are fully hoisted let & const are hoisted but stay in Temporal Dead Zone (TDZ) ❌ 🚫 Temporal Dead Zone (TDZ)You can’t access let & const variables before initialization — it throws an error. ⚠️ Function Expressions vs Hoisting Function declarations → hoisted ✅ Function expressions → behave like variables ❌ 💡 Key TakeawayUnderstanding execution context, memory, and hoisting makes debugging WAY easier and helps write cleaner code 🔥 📌 Slowly moving from writing code → to understanding how it actually works inside #JavaScript #WebDevelopment #MERNStack #CodingJourney #LearnToCode #FrontendDevelopment #DeveloperLife

Revisiting the JavaScript Event Loop Sometimes going back to fundamentals is just as important as building new things. Today I revisited how the JavaScript Event Loop works a concept we use daily but don’t always think about deeply. A quick refresher: • JavaScript runs on a single-threaded call stack • Async operations are handled outside the main thread • Completed tasks move into queues • The Event Loop executes them when the call stack is empty One thing worth remembering: Promises (microtasks) are always prioritized over callbacks like setTimeout Even after working with async code regularly, understanding why things execute in a certain order is what really helps in debugging and writing better code. 📖 Article: https://lnkd.in/dnYVfHrQ #JavaScript #NodeJS #EventLoop #AsyncProgramming #BackendDevelopment

🚀 Just published a new blog on JavaScript Arrays 101: Storing Multiple Values Easily. In this article, I explain the basics of arrays in JavaScript—what arrays are, why we use them, and how they help store multiple values in a single variable. I also covered creating arrays, accessing elements using index, updating values, using the length property, and looping through arrays with simple examples. 📖 Read the full article here: https://lnkd.in/gEvcCHGv Inspired by the amazing teaching of Hitesh Choudhary Sir and Piyush Garg Sir from Chai Aur Code. ☕💻 #javascript #webdevelopment #learninginpublic #chaiAurCode

📢 Next Blog is Here! The Magic of this, call(), apply() and bind() in JavaScript ✨ 🔗 Read here: https://lnkd.in/gmmYsRqv Topics covered ✍️: ⟶ What this means in JavaScript ⟶ this inside normal functions and objects ⟶ What call() does and how to use it ⟶ What apply() does (with array arguments) ⟶ What bind() does and why it's different ⟶ Difference between call, apply, and bind ⟶ Hands-on assignment to practice all three I would also like to extend a special thanks to my mentors, Hitesh sir and Piyush sir, for their invaluable guidance and support #WebDev #JavaScript #100DaysOfCode #Chai Aur Code

Just published a new article: Array Flatten in JavaScript 🚀 Learn how to tame nested arrays with practical examples, visual diagrams, and multiple approaches—from recursion to the modern flat() method. Perfect for interview prep or leveling up your JS skills. Check it out here: [ https://lnkd.in/gxRkDnUf ] Chai Code Hitesh Choudhary Piyush Garg #chaicode #javascript #webdevcohort2026

🧠 Day 13 — Class vs Prototype in JavaScript (Simplified) JavaScript has both Classes and Prototypes — but are they different? 🤔 --- 🔍 The Truth 👉 JavaScript is prototype-based 👉 class is just syntactic sugar over prototypes --- 📌 Using Class (Modern JS) class Person { constructor(name) { this.name = name; } greet() { console.log(`Hello ${this.name}`); } } const user = new Person("John"); user.greet(); // Hello John --- 📌 Using Prototype (Core JS) function Person(name) { this.name = name; } Person.prototype.greet = function () { console.log(`Hello ${this.name}`); }; const user = new Person("John"); user.greet(); // Hello John --- 🧠 What’s happening? 👉 Both approaches: Create objects Share methods via prototype Work almost the same under the hood --- ⚖️ Key Difference ✔ Class → Cleaner, easier syntax ✔ Prototype → Core JavaScript mechanism --- 🚀 Why it matters ✔ Helps you understand how JS works internally ✔ Useful in interviews ✔ Makes debugging easier --- 💡 One-line takeaway: 👉 “Classes are just a cleaner way to work with prototypes.” --- #JavaScript #Prototypes #Classes #WebDevelopment #Frontend #100DaysOfCode

Day 4/100 of JavaScript 🚀 Today’s focus: Functions in JavaScript Functions are reusable blocks of code used to perform specific tasks Some important types with example code: 1. Parameterized function → takes input function greet(name) { return "Hello " + name; } greet("Apsar"); 2. Pure function → same input always gives same output, no side effects function add(a, b) { return a + b; } add(2, 3); 3. Callback function → function passed into another function function processUser(name, callback) { callback(name); } processUser("Apsar", function(name) { console.log("User:", name); }); 4.Function expression → function stored in a variable const multiply = function(a, b) { return a * b; }; 5.Arrow function → shorter syntax const square = (n) => n * n; Key understanding: Functions are first-class citizens in JavaScript — they can be passed, returned, and stored like values #Day4 #JavaScript #100DaysOfCode

When I started learning JavaScript, async code felt unpredictable. Things didn’t execute in order. Logs appeared out of nowhere. And promises felt like “magic”. The real issue? I didn’t understand callbacks. Everything in async JavaScript builds on top of them. So I wrote this article to break it down clearly: 👉 Execution flow 👉 Sync vs async callbacks 👉 Why they still matter in modern code If async JS has ever felt confusing, this will help. https://lnkd.in/g7DJ7yXX #JavaScript #LearningToCode #Callbacks #SoftwareDevelopment