React Debounced Search Input Challenge

I used to think React loads everything at once… until I learned lazy loading. 🤯 Now I understand how apps become faster and more efficient. ⚡ 💠Load only what is needed 💠 Improve performance 💠 Reduce bundle size Here are my notes for revision. ✍️ #React #JavaScript #LearningInPublic #FrontendDeveloper

⚡ Lazy Loading in React — a quick visual breakdown → Before: 3.7 MB loaded on page open   → After: 405 KB loaded on page open   → Result: 4.3× faster First Contentful Paint 🚀  All of this with just 2 lines of code using React.lazy() + Suspense. This is a small but often underestimated concept that can significantly improve performance. Swipe to see the network panel & Lighthouse scores 👉  #ReactJS #WebPerformance #Frontend #JavaScript #React

Built a Password Generator using React while learning React Hooks in depth. Worked with useState, useEffect, useCallback, and useRef to understand state management, DOM access, and performance optimization in a practical way. #ReactJS #WebDevelopment #Frontend #LearningInPublic #JavaScript

🔒 React sanitizes user input automatically. But one line can break everything. Normal rendering? You're safe. <p>{userInput}</p> // React escapes this. Always . The moment you do this — you're on your own: dangerouslySetInnerHTML={{ __html: userInput }} The word "dangerous" is literally in the name. React is warning you. Always pair it with DOMPurify. And never trust user-controlled URLs — a javascript: href executes on click. React is secure by default. Just don't fight against it. Ever used dangerouslySetInnerHTML in production? 👇 #ReactJS #WebSecurity #Frontend #JavaScript

useEffect is one of the most misunderstood hooks in React. Most bugs I’ve seen weren’t because React is complex — they were because the mental model was wrong. Here’s a practical breakdown with real examples. Day 2/100 — sharing practical frontend engineering lessons from real-world projects. What’s the most confusing useEffect bug you’ve faced? #ReactJS #FrontendEngineering #JavaScript #WebPerformance #SoftwareArchitecture

In React, a Hook is just a JavaScript object. Each Hook stores: the state value a queue of updates and a reference to the next Hook Internally it looks like this: { memoizedState: state, queue: updates, next: nextHook } React stores Hooks as a linked list attached to the component's Fiber node. Fiber → Hook → Hook → Hook → null This is why Hooks must always be called in the same order. React reads them one by one during every render. When you call setState, React adds the update to the Hook's queue, and processes it during the next render. Hooks are not magic. They are simple objects connected together. Understanding this helps explain many React behaviors. #reactjs #javascript #webdevelopment

Many developers use useEffect. But very few truly understand it. The purpose of useEffect is simple: to handle side effects. Such as: • API calls • DOM updates • event listeners The key lies in the dependency array. Think of it as a trigger: • When dependencies change → effect runs • When they don’t → effect is skipped Common mistakes: • Empty dependency array misunderstood • Incorrect dependencies causing infinite loops useEffect isn’t magic. It’s just logic. #reactjs #frontenddevelopment #javascript #webdevelopment #codingtips

Today I learned about Lists & Keys in React. Lists allow us to render multiple items dynamically using methods like map(). For example: We can display a list of users, products, or tasks easily. Keys are used to uniquely identify each item in a list. This helps React efficiently update only the changed elements instead of re-rendering everything. Using unique keys improves performance and avoids bugs. Up Next: Forms in React 👀 React Series – Day 8 🚀 #ReactJS #LearningInPublic #WebDevelopment #FrontendDeveloper #JavaScript #100DaysOfCode

Today I learned how useEffect cleanup actually works in React — and it completely changed how I think about side effects. When we use useEffect, it runs after render. But what many beginners ignore is the cleanup function. Why is cleanup important? Prevents memory leaks Stops unnecessary API calls Removes event listeners properly Clears intervals and timeouts Example: When you add an event listener inside useEffect, you must remove it when the component unmounts. Otherwise, it keeps running in the background. That’s where cleanup comes in. useEffect(() => { const handleResize = () => console.log("Resized"); window.addEventListener("resize", handleResize); return () => { window.removeEventListener("resize", handleResize); }; }, []); The function returned inside useEffect runs: Before the next effect runs When the component unmounts Small detail. Big difference in performance. React is simple — until you understand the details. #ReactJS #FrontendDeveloper #JavaScript #WebDevelopment #LearningInPublic #100DaysOfCode

Why Array Comparison in React State Is Tricky? If you’ve ever updated an array in React and your component didn’t re-render, you’re not alone. The reason? React compares state by reference, not by value. So if you modify the same array instead of creating a new one, React thinks nothing changed — even if the data inside it did. Never mutate state directly. Always create a new array or object when updating state. #ReactJS #JavaScript #FrontendDevelopment #WebDevelopment