React Todo List vs Pure JavaScript Implementation

#Day59 of #100DaysOfCode Today I explored some important React and JavaScript concepts that help in building interactive web applications. 🔹 Handling Click Events – Learned how React responds to user clicks using event handlers like onClick. 🔹 Handling Non-Click Events – Explored events like keyboard input, form changes, and mouse movements. 🔹 Event Object – Understood how React provides event information (like target element, value, etc.) through the event object. 🔹 State in React – Learned how state helps store dynamic data and update the UI automatically. 🔹 Hooks – Got introduced to React Hooks which allow functional components to use features like state and lifecycle behavior. 🔹 useState() Hook – Practiced managing component state using useState. 🔹 Activity: Create Like Button – Built a simple Like Button to practice state updates and user interaction. 🔹 Closures in JavaScript – Understood how functions can access variables from their outer scope even after execution. 🔹 Re-render in React – Learned how React re-renders components when state or props change. 🔹 Callback in setState Function – Explored how callback functions help update state based on the previous state. 🔹 More About State – Deepened understanding of how state works internally in React. #React #JavaScript #MERN #WebDevelopment #100DaysOfCode #Day59complete✅👍🏻

🚀 Why Do We Need Hooks in React? In traditional JavaScript, imagine we create a button that updates a number displayed in multiple places on the UI. Every time the button is clicked, we would have to: Select each element separately Get its reference Manually update the textContent for every element If that number appears in 4–5 places, we would need to update all of them individually. This process quickly becomes messy and inefficient. This is where React Hooks changed everything. With the useState Hook, we can manage a single piece of state and React automatically updates every place in the UI where that state is used. Instead of manually manipulating the DOM multiple times, we just update the state once — and React takes care of the rest. This simple idea is what made React extremely powerful and scalable. Even organizations like Khan Academy realized how efficient UI management becomes with React. ✨ One Hook. One State. Multiple UI Updates. That’s the power of React Hooks. #ReactJS #ReactHooks #FrontendDevelopment #JavaScript #WebDevelopment #LearningInPublic #SoftwareEngineering #ReactDeveloper #CodingJourney

🚀 Understanding JSX & React DOM in React.js As I continued learning React, I explored two fundamental concepts that power how React works: JSX and React DOM. 🔹 JSX (JavaScript XML) allows us to write UI code that looks like HTML inside JavaScript. It makes component structure more readable and expressive while still being transformed into pure JavaScript behind the scenes. Example: const element = <h1>Hello World</h1>; 🔹 React DOM is responsible for rendering React elements into the actual browser DOM. It acts as the bridge between React’s virtual representation of the UI and the real web page users see. Together: • JSX describes what the UI should look like • React DOM updates and renders it efficiently Understanding these concepts helped me better grasp how React manages UI updates in a structured and optimized way. Continuing to strengthen my frontend fundamentals step by step 🚀 #ReactJS #FrontendDevelopment #WebDevelopment #JavaScript #LearningJourney #StudentDeveloper #ReactDOM #JSX

😅 When a JavaScript developer discovers React for the first time… At first: “Wait… HTML inside JavaScript???” 🤯 Then: “What is JSX?” “Why is everything a component?” “What is this useState thing?” After a few days: “Ohhhh… this is actually powerful.” With React, you stop thinking in pages… and start thinking in components. Instead of rewriting the whole DOM, you update only what changes. That’s when it clicks 💡 From: • Manipulating elements manually To: • Building reusable UI blocks • Managing state • Creating scalable frontend apps The confusion is normal. The growth is worth it. 💬 What confused you most when you first learned React? 📌 Save this if you're on your frontend journey #JavaScript #ReactJS #FrontendDevelopment #WebDevelopment #CodingJourney

𝗔 𝗦𝘂𝗯𝘁𝗹𝗲 𝗥𝗲𝗮𝗰𝘁 𝗕𝘂𝗴 𝗖𝗮𝘂𝘀𝗲𝗱 𝗯𝘆 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 Sometimes a React bug isn’t really a React problem. It’s a JavaScript closure problem. Consider this example: A component sets an interval inside useEffect and logs the state value. At first glance, you might expect the console to print the latest value of count. But it doesn’t. It always prints 0. Why? Because the callback inside setInterval captured the value of count from the first render. This happens because of JavaScript closures. When the effect runs, it closes over the variables that existed at that moment. Since the dependency array is empty, the effect runs only once — so the interval keeps using the old value. One simple fix is to include the state in the dependency array so the effect runs again when the value changes. Understanding closures is important when working with: • useEffect • useCallback • useMemo • async callbacks Many confusing React bugs are actually JavaScript closure issues. 👇 Example comparison below Day 12/100 — sharing practical frontend engineering lessons. Have you ever run into a bug caused by closures in React? #ReactJS #FrontendEngineering #JavaScript #SoftwareDevelopment #WebDevelopment

🚫 Jumping into React too early cost me clarity. When I shifted to a JS-first approach, React stopped feeling complex. React isn’t a separate skill. It’s JavaScript applied to UI with rules around state and re-renders. Here’s what actually made the difference: 1️⃣ Closures Without understanding closures, hooks feel unpredictable. They explain: • Why stale state happens • Why dependencies matter in useEffect 2️⃣ Async JavaScript API calls aren’t React problems. They’re event loop problems. Once I understood promises and async flow, state updates became logical. 3️⃣ Array Methods .map() and .filter() power dynamic rendering. If you struggle with these, JSX becomes messy fast. 4️⃣ Scope & Execution Context • Re-renders are execution cycles • Event handlers are closures • State is captured context None of this is “React magic.” It’s JavaScript. React became easier the moment I stopped “learning React” and started mastering JavaScript fundamentals. Skill sequencing matters. If you're starting in frontend, build language depth before chasing frameworks. What JS concept made things click for you? #JavaScript #React #WebDevelopment #Frontend #LearningInPublic

REACT NOTES — PART 1 (Foundations) After understanding how JavaScript works, the next step is building interfaces that scale. React simplifies complex UIs by breaking them into small, reusable components. This post covers the core foundations: • Components and component structure • JSX and how React renders UI • Virtual DOM and efficient updates • Props for passing data • State for dynamic UI behavior • Event handling in React Before learning advanced patterns or frameworks, these fundamentals must be clear. 📌 Save this if you're starting with React or revising the basics. #React #FrontendDeveloper #WebDevelopment #JavaScript #InterviewPrep #LearningInPublic #Consistency

Day 7/15 – Mastering React Custom Hook Pattern 🚀 Today I focused on the Custom Hook Pattern in React. Custom Hooks allow us to extract and reuse stateful logic across multiple components while keeping components clean and focused on UI. Instead of repeating the same logic (like API calls, form handling, or event listeners), we can move that logic into a custom hook and reuse it anywhere in the application. Key takeaway: Custom Hooks improve code reusability, readability, and separation of concerns, which is essential for building scalable React applications. Learning to design good hooks is a big step toward writing clean, production-ready React code. #React #CustomHooks #FrontendDevelopment #JavaScript #ReactPatterns #LearningInPublic

Today something interesting happened while I was building a Custom Date Picker in NextJS.🗓 I have used useRef many times before, but honestly I was mostly using it without fully understanding the concept behind it But today… it finally clicked.💫 While implementing the feature, I realized that: • useRef creates a mutable object • The value is stored inside .current • The value persists between renders • Updating .current does not trigger a re-render • It can also be used to directly access DOM elements The most interesting part for me was understanding why React doesn't re-render when current changes. Sometimes you don’t truly understand a concept until you build something real with it. Small learning today, but a very satisfying one. 💫 What was the React concept that took you the longest to understand❓️ #React #JavaScript #FrontendDevelopment #ReactHooks #BuildInPublic #LearningJourney