Understanding JSX in React: Simplifying JavaScript and HTML

DAY 7 OF POSTING REACT CONTENT ⚛️ WHY DOES REACT CODE LOOK LIKE HTML INSIDE JAVASCRIPT? 🤔 It looks like HTML, but it’s not HTML. React understands only JavaScript. So this syntax is just a clean way to write JavaScript for UI. This is called JSX. JSX exists only to make UI code: 👉 easier to read 👉 easier to write 👉 easier to manage Behind the scenes, JSX is converted into normal JavaScript. 💬 Did this explanation make JSX feel simpler? #ReactJS #ReactBasics #JavaScript #FrontendDevelopment #LearnInPublic #WebDevelopment #CodingJourney

Hello everyone, I’d like to explain two JavaScript concepts—currying and closures—using the dynamic onChange handler in the code snippet below. Here’s a breakdown of how and why it works: 💡 The Concept: Instead of a standard function, we create a function that returns another function. 🧠 What is happening under the hood? 1. Currying (The Setup): We don't pass all arguments (field and e) at once. First, we call handleInputChange('email'). Result: This returns a new function that is sitting there, waiting specifically for the event e. 2. Closure (The Memory): Even after that first function finishes running, the returned function "remembers" the field variable ('email') because of closure. The Payoff: When React finally triggers the onChange event, our inner function executes with access to both the specific field name (saved from the closure) and the event (provided by React). One handler. Infinite inputs. Cleaner code. 🚀 Check out the implementation below. Have you used this pattern in your projects, or do you prefer a different approach? #JavaScript #ReactJS #WebDevelopment #CodingTips #CleanCode

Ever wondered how JavaScript remembers variables even after a function has finished execution? It's The magic of Closure.  A closure gives a function access to its outer scope. In JavaScript, closures are created every time a function is created, at function creation time. Example: function outer() {  let count = 0;  return function inner() {   count++;   console.log(count);  }; } const counter = outer(); counter(); Result => 1 counter(); Result => 2 counter(); Result => 3 Explanation: Inner function remembers count from outer. Every time you call counter(), it retains the previous value. Usefulness of Closure: => Data encapsulation (private variables) => Memoization / caching => Event handlers & async callbacks Do you use closures in your projects? Share your use case below! #JavaScript #WebDevelopment #Closures #ReactJS #NexjJS #MERNStack #CodingTips

JavaScript be like: NaN = Not a Number typeof NaN = “number” Make it make sense 😄 Fun part? NaN is technically a numeric value in JavaScript — it represents an invalid number result (like 0/0). 🙃 And it gets better: NaN === NaN → false Only JavaScript can be this confident and confusing at the same time. #JavaScript #JS #DeveloperHumor #WebDevelopment

I thought I understood this JavaScript concept… until I really did 👇 📌 Parameter Scope in JavaScript Function parameters are not special variables they are simply local variables scoped to the function. function greet(userName) {  console.log(userName);  } console.log(userName); // ❌ ReferenceError: userName is not defined Key Takeaway: userName exists only inside the function's execution context. But here’s the interesting part 👀 Parameters also follow lexical scope, which means inner functions can access them via closures: function outer(x) {  function inner() {   console.log(x); // ✅ Accesses 'x' from the outer scope  }  inner(); } And a subtle gotcha most beginners miss ⤵️ Default parameters are evaluated in their own scope at the moment the function is called, strictly before the function body begins to run. Understanding scope like this changed how I read and debug JavaScript code. Small concepts. Big clarity. 🚀 #JavaScript #WebDevelopment #LearningInPublic #Frontend #CodingTips #Scope

#Day 58/100 – Why JavaScript is Single-Threaded (and why that’s actually powerful) ⚡ When I first heard “JavaScript is single-threaded” I thought… Wait — only one thing at a time? Isn’t that slow? But today I understood something important. JavaScript being single-threaded is not a weakness. It’s the reason the web feels smooth. Imagine editing a form and suddenly the page freezes because 5 things run at once. That would be chaos. Instead, JavaScript follows a rule: Do one thing clearly, finish it, then move to the next. This makes UI predictable and prevents race conditions. But then how do videos load, APIs fetch data, and timers run? Because the browser handles heavy work in the background and JavaScript handles the result when it’s ready. So JS stays simple. The browser stays powerful. Big realization 💡 JavaScript isn’t trying to do everything at once — it’s trying to do everything in order. And that’s why websites don’t constantly break. Today I stopped thinking “single-threaded = limitation” Now I see “single-threaded = stability” #100DaysOfCode #JavaScript #WebDevelopment #LearningInPublic #FrontendDevelopment #CodingJourney

DAY 14 OF POSTING REACT CONTENT ⚛️ WHY DOES REACT TAKE VALUES OUT OF OBJECTS DIRECTLY? 🤔 In JavaScript, data usually comes as objects. Accessing the same object again and again makes code harder to read. So JavaScript allows us to pick only what we need from an object and use it directly. React uses this everywhere to keep code: 👉 clean 👉 readable 👉 less repetitive That’s why React code often looks shorter without doing anything extra. 💬 Did destructuring confuse you the first time you saw React code? #ReactJS #JavaScript #ReactBasics #FrontendDevelopment #LearnInPublic #WebDevelopment #CodingJourney

Is the Node.js event loop the key to understanding how JavaScript works? Before you answer, TAKE THIS QUICK TEST: * Do you know what goes into the call stack? * Can you clearly explain the difference between microtasks and macrotasks? * Do you know why Promise.then() runs before setTimeout(fn, 0)? * Can you explain it without drawing the famous diagram? 😄 If any of those made you pause… WELCOME TO THE CLUB. I learned the event loop early in my JavaScript journey. I could repeat the definitions. I used async/await daily. Everything worked. So I assumed I UNDERSTOOD it. Then I revisited “You Don’t Know JS” by Kyle Simpson and realized something humbling: There’s a difference between * USING JavaScript * UNDERSTANDING JavaScript * EXPLAINING JavaScript The event loop isn’t just an interview topic. It explains * Why logs appear in a certain order * Why blocking code freezes everything * Why async behaves the way it does * How JavaScript stays single-threaded but still feels concurrent Here’s the REAL TEST: If you can clearly explain the event loop to a beginner WITHOUT jargon, you probably understand JavaScript at a deeper level. So let’s make this interactive. In one or two sentences, how would you explain the event loop to someone new to JavaScript? Let’s see who REALLY knows it. 😄 #JavaScript #NodeJS #WebDevelopment #SoftwareEngineering #AsyncProgramming #100DaysOfCode

One of the most important (and often confusing) concepts in JavaScript is the Execution Context. Whenever JavaScript runs your code, it does not execute it line by line immediately. Instead, it creates an Execution Context, which happens in two phases: 1️⃣ Memory Creation Phase (Hoisting Phase) • Variables are allocated memory • Functions are stored fully in memory • var variables are initialized with undefined Eg: console.log(a); // undefined var a = 10; 2️⃣ Code Execution Phase • JavaScript assigns actual values to variables • Executes function calls line by line ⸻ 🧠 Types of Execution Contexts 1. Global Execution Context • Created first • Associated with the global object (window in browsers) 2. Function Execution Context • Created whenever a function is invoked • Each function call gets its own context 3. Eval Execution Context (rarely used) ⸻ 📦 Call Stack • JavaScript uses a Call Stack to manage execution contexts • LIFO (Last In, First Out) • Helps JS know which function to execute and return from ⸻ 💡 Why this matters? Understanding Execution Context helps you master: • Hoisting • Scope & Closures • this keyword • Debugging tricky bugs • Writing better, predictable JavaScript If you’re preparing for JavaScript or React interviews, this concept is a must-know 🔥 #JavaScript #WebDevelopment #Frontend #ReactJS #ExecutionContext #InterviewPrep #JSConcepts

Today I learn about the Shortest code in JavaScript, guess what it is ? it is an "empty .js file" 🚀 because, when we run a empty file in js, a global execution context (GEC) sill created ✅, although it does not allocate any memory space for variables and functions but still it stores the window object inside it. Even with 0 bytes of code, the engine still creates a **Global Execution Context**. #javascript JavaScript Notes