React Closures: Stale State Bug Example

𝐓𝐫𝐢𝐜𝐤𝐲 𝐑𝐞𝐚𝐜𝐭 𝐂𝐥𝐨𝐬𝐮𝐫𝐞 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰 𝐐𝐮𝐞𝐬𝐭𝐢𝐨𝐧 🤔 Many developers understand closures in JavaScript… but get confused when it comes to React. Question: What will be the output of this code? Example 👇 import React, { useState } from "react"; export default function App() { const [count, setCount] = useState(0); const handleClick = () => { setTimeout(() => { console.log(count); }, 1000); }; return ( <> Click </> ); } Now imagine: You click the button 3 times quickly and count updates each time What will be logged after 1 second? Answer 👇 It will log the SAME value multiple times ❌ Why? Because of closure. The setTimeout callback captures the value of count at the time handleClick was created. This is called a “stale closure”. Correct approach ✅ setTimeout(() => { setCount(prev => { console.log(prev); return prev; }); }, 1000); Or use useRef for latest value. Tip for Interview ⚠️ Closures + async code can lead to stale state bugs in React. Good developers know closures. Great developers know how closures behave in React. #ReactJS #JavaScript #Closures #FrontendDeveloper #WebDevelopment #ReactInterview #CodingInterview #ReactHooks

🚀 Closure in JavaScript — Explained Like a Senior React Developer Closures are one of those concepts that look simple… but power some of the most critical patterns in React ⚡ 👉 What is a Closure? A closure is when a function remembers variables from its outer scope, even after the outer function has finished execution. 💡 In short: Function + Lexical Scope = Closure --- 🔹 Basic Example function outer() { let count = 0; return function inner() { count++; console.log(count); }; } const counter = outer(); counter(); // 1 counter(); // 2 👉 Even though outer() is done, inner() still remembers count That’s the power of closure. --- 🔹 Why Closures Matter in React? Closures are everywhere in React: ✔️ Hooks (useState, useEffect) ✔️ Event handlers ✔️ Async operations (setTimeout, API calls) ✔️ Custom hooks --- 🔹 Real-world React Problem: Stale Closure ⚠️ setCount(count + 1); setCount(count + 1); ❌ Both use the same old value of count ✅ Correct approach: setCount(prev => prev + 1); setCount(prev => prev + 1); 👉 This avoids stale closure and ensures latest state is used --- 🔹 Where Closures Help ✅ Data encapsulation (private variables) ✅ Memoization & performance optimization ✅ Debouncing / throttling ✅ Custom hooks ✅ Cleaner state management --- 🔥 Pro Insight (Senior Level) Closures are the backbone of React’s functional paradigm. Misunderstanding them can lead to bugs in: useEffect dependencies Async logic Event callbacks --- 💬 One-line takeaway 👉 “Closures allow functions to retain access to their scope — making React hooks and async logic work seamlessly.” --- #JavaScript #ReactJS #Frontend #WebDevelopment #Programming #InterviewPrep #SoftwareEngineering

🚀 Why useState is a Game-Changer in React. let's breakdown this 👇 💡 What is useState? "useState" is a React Hook that allows you to store and manage dynamic data (state) inside functional components. Without it, your UI wouldn’t respond to user input. 📱 Real-Time Example: Form Input & Validation Let’s take a simple login form 👇 import React, { useState } from "react"; function LoginForm() { const [email, setEmail] = useState(""); const [error, setError] = useState(""); const handleSubmit = (e) => { e.preventDefault(); if (!email.includes("@")) { setError("Please enter a valid email address"); } else { setError(""); alert("Form submitted successfully!"); } }; return ( <form onSubmit={handleSubmit}> <input type="text" placeholder="Enter email" value={email} onChange={(e) => setEmail(e.target.value)} /> {error && <p style={{ color: "red" }}>{error}</p>} <button type="submit">Submit</button> </form> ); } export default LoginForm 🧠 What’s happening here? - "email" → stores user input - "setEmail" → updates input as the user types - "error" → stores validation message - "setError" → shows/hides error instantly useState is what connects user actions to UI behavior. It ensures your forms are not just functional, but smart and responsible 💬 Have you implemented form validation using useState? What challenges did you face? #ReactJS #FrontendDevelopment #JavaScript #WebDevelopment #Coding

JSX is where logic meets design, turning simple { } into powerful, dynamic interfaces that breathe life into your React apps. Learn how expressions shape real UI and avoid common pitfalls along the way. 👉 Master it here: https://lnkd.in/dMfnqU-i #ReactJS #JSX #WebDevelopment #FrontendDevelopment #JavaScript #CodingLife #LearnToCode #DeveloperJourney #TechSkills

Most React Native codebases become a mess by month 3. Not because the developer was bad. Because nobody agreed on a structure from day one. Here's the folder structure I use on every project 👇 src/ ├── components/  → reusable UI only ├── screens/   → one file per screen ├── navigation/  → all route config here ├── hooks/    → useAuth, usePlayer, useBooking ├── store/    → Redux slices ├── services/   → ALL API calls live here ├── utils/    → helpers & constants ├── types/    → TypeScript interfaces └── assets/    → images & fonts 3 rules I never break: 🔴 API calls never go inside components 🟡 Every colour lives in theme.ts — nowhere else 🟢 Types folder grows with the project — never skip it Junior me put everything in /components. 6 months later it had 60 files and zero logic separation. Never again. Save this before your next project 👇 #ReactNative #TypeScript #CleanCode #MobileDev #JavaScript #2026

Why do we need to call 'super(props)' in the constructor of a React component? JavaScript classes aren't magic. They are just syntactic sugar over prototypes. If you are still using (or have used) Class Components in React, you have likely typed 'super(props)' a thousand times. But do you actually know what happens if you forget it? In JavaScript, you cannot use the keyword 'this' in a constructor until you have called the parent constructor. Since your component extends 'React.Component', calling 'super()' is what actually initializes the 'this' object. If you try to access 'this.state' or 'this.props' before that call, JavaScript will throw a ReferenceError and crash your app. But why pass 'props' into it? React sets 'this.props' for you automatically after the constructor runs. However, if you want to access 'this.props' inside the constructor itself, you must pass them to 'super(props)'. If you just call 'super()', 'this.props' will be undefined until the constructor finishes execution. Most of us have moved to Functional Components where this isn't an issue. But understanding these fundamentals is what separates a developer who just writes code from one who understands the runtime. #ReactJS #Javascript #SoftwareEngineering #WebDevelopment #Coding #ProgrammingTips

𝐀𝐝𝐯𝐚𝐧𝐜𝐞𝐝 𝐑𝐞𝐚𝐜𝐭 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰 𝐐𝐮𝐞𝐬𝐭𝐢𝐨𝐧 🚀 Many developers use "key" in React… but don’t fully understand why it’s important. Question: Why should we NOT use index as key in React lists? 🤔 Example 👇 const items = ["A", "B", "C"]; items.map((item, index) => ( Looks fine… right? ❌ Now imagine removing "A" from the list 👇 ["B", "C"] React will reuse DOM elements incorrectly because index changes. Result? ⚠️ Wrong UI updates ⚠️ State mismatch ⚠️ Unexpected bugs Correct way ✅ items.map((item) => ( Why? React uses "key" to track elements during reconciliation (Virtual DOM diffing). If keys are unstable (like index), React cannot correctly identify elements. Tip for Interview ⚠️ Key should be: ✔ Unique ✔ Stable ✔ Predictable Good developers write lists. Great developers understand reconciliation. #ReactJS #FrontendDeveloper #JavaScript #WebDevelopment #ReactInterview #AdvancedReact #CodingInterview #SoftwareDeveloper

🚀 Debugging JWT Auth — A Small Mistake That Cost Me Hours Today I ran into a classic authentication issue while working with NestJS + Next.js — and it’s a good reminder of how small misunderstandings can break the whole flow. 🔍 The Problem After login, I noticed that my localStorage was saving: token: "string" Instead of an actual JWT like: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... ⚠️ Clearly something was off. 🧠 The Root Cause My backend response looked like this: { "success": true, "data": { ...userDetails }, "token": "REAL_JWT_TOKEN" } But in my frontend, I made this mistake: const userData = res.data.data; localStorage.setItem("token", userData.token); // ❌ wrong 👉 The token wasn’t inside data — it was at the root level. ✅ The Fix const userData = res.data.data; const token = res.data.token; localStorage.setItem("token", token); localStorage.setItem("userData", JSON.stringify(userData)); 🔥 Debug smarter, not harder. #WebDevelopment #NestJS #NextJS #JWT #Authentication #Debugging #FullStack #JavaScript

Stop writing anonymous useEffect functions. Name them. This is one of the smallest changes you can make in React — and one of the most underrated. Most of us write this: useEffect(() => { fetchUser(id); }, [id]); But you can do this: useEffect(function fetchUserOnIdChange() { fetchUser(id); }, [id]); Same behavior. Completely different debugging experience. Here's why it matters: 🔍 Stack traces become readable When something goes wrong inside an effect, your browser's stack trace will show fetchUserOnIdChange instead of just useEffect. You'll know exactly which effect blew up — no more hunting through 8 anonymous functions. 🧠 Self-documenting code A named function is a contract. It tells the next developer (or future you at 11pm) why this effect exists, not just what it does. syncFormWithLocalStorage communicates more than any comment ever could. ⚡ React DevTools clarity The React profiler and DevTools display effect names. When you're profiling performance, named effects let you immediately identify what's running, when, and how often. 🤝 Easier code reviews Reviewers can scan for useEffect(function loadDashboardMetrics and instantly understand intent. No need to read the entire body just to grasp the purpose. The rule of thumb I follow: If an effect is longer than 3 lines or runs conditionally, it gets a name. No exceptions. It takes 2 seconds to type. It saves 20 minutes of debugging. Small habits compound. This is one worth picking up. 🚀 What's a small React habit that's made a big difference for your team? Drop it in the comments 👇 #React #JavaScript #WebDevelopment #FrontendEngineering #CleanCode #ReactJS #SoftwareEngineering

If you’ve written even a single line of React, you’ve done this: '<button onClick={() => handleClick(id)}>'. But have you ever paused to ask why we wrap it in an anonymous arrow function instead of just passing the handler directly? It’s not just a syntax preference; it’s about controlling when your code actually runs. The most common trap for beginners is writing `onClick={handleClick()}`. In JavaScript, adding those parentheses means "execute this right now." If you do that in React, your function runs the moment the component renders, often leading to the dreaded "Too many re-renders" error if your handler updates state. By wrapping it in an arrow function, you’re passing a reference to a function that says: "Don't run this yet. Wait until the user actually clicks." Another major reason is argument passing. If your handler needs a specific ID or an index from a loop, the arrow function acts as a closure. It "captures" that specific value from the current render cycle and carries it into the function call later. Back in the day of Class Components, we used arrow functions (or '.bind(this)') to solve the 'this' context nightmare, but in the era of Hooks, the focus has shifted entirely to execution control and data scoping. Is there a downside? Technically, yes. Every time your component re-renders, a new function instance is created. In 99% of applications, this is a micro-optimization that doesn't matter. But if you're passing that function down to a heavily optimized 'React.memo' child, that new reference might trigger unnecessary renders. That’s where 'useCallback' enters the chat. #ReactJS #WebDevelopment #SoftwareEngineering #Javascript #CodingBestPractices