Custom React Hook for Reusable Data Fetching

𝐈𝐬 𝐲𝐨𝐮𝐫 `𝐮𝐬𝐞𝐄𝐟𝐟𝐞𝐜𝐭` 𝐟𝐢𝐫𝐢𝐧𝐠 𝐰𝐚𝐲 𝐭𝐨𝐨 𝐨𝐟𝐭𝐞𝐧? 𝐘𝐨𝐮 𝐦𝐢𝐠𝐡𝐭 𝐛𝐞 𝐟𝐚𝐥𝐥𝐢𝐧𝐠 𝐟𝐨𝐫 𝐚 𝐜𝐨𝐦𝐦𝐨𝐧 𝐝𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐚𝐫𝐫𝐚𝐲 𝐭𝐫𝐚𝐩. We've all been there: you put an object or array into your `useEffect`'s dependency array, thinking it's stable. But because JavaScript compares objects and arrays by reference, even if their content is identical, `useEffect` sees a new object on every render and re-runs your effect. This can lead to performance hits, stale data, or even infinite loops. 🚫 The Problem: ```javascript function MyComponent({ data }) { const options = { id: data.id, filter: 'active' }; useEffect(() => { // This runs every render if 'options' object is new fetchData(options); }, [options]); // 'options' is a new object reference each time // ... } ``` ✅ The Fix: Stabilize with `useMemo` If your object or array doesn't logically change across renders (or only changes based on specific primitives), wrap it in `useMemo`. This memoizes the object itself, ensuring its reference remains the same unless its dependencies actually change. ```javascript function MyComponent({ data }) { const stableOptions = useMemo(() => ({ id: data.id, filter: 'active' }), [data.id]); // Only re-create if data.id changes useEffect(() => { fetchData(stableOptions); }, [stableOptions]); // Now only re-runs if stableOptions' reference changes // ... } ``` This trick is a lifesaver for optimizing `useEffect` calls, especially when dealing with complex configurations or filtering logic passed down as props. It keeps your effects clean and your app performant. What's been your biggest `useEffect` headache, and how did you solve it? #React #FrontendDevelopment #JavaScript #Performance #WebDev

What are the differences between var, let, and const in JavaScript? 1. var: Traditional and Globalized Scope: Function-level scope. Variables declared with var are scoped to the function they are declared in, or globally if declared outside of a function. Hoisting: var declarations are hoisted, meaning they are moved to the top of their scope, but their values are not initialized until the code reaches the declaration line. Re-declaration: You can redeclare variables declared with var within the same scope. Example: var x = 5; if (true) { var x = 10; // same variable, overwrites the previous value } console.log(x); // 10 2. let: Modern and Block-scoped Scope: Block-level scope. let is limited to the block (inside loops, conditionals, etc.) where it is declared, offering more predictable behavior. Hoisting: Variables declared with let are also hoisted, but they cannot be accessed until the execution reaches the line where they are declared, leading to a "temporal dead zone." Re-declaration: You cannot redeclare a variable declared with let in the same scope. Example: let y = 5; if (true) { let y = 10; // different variable, does not affect the outer one } console.log(y); // 5 3. const: Immutable and Block-scoped Scope: Block-level scope, just like let. Immutability: Variables declared with const cannot be reassigned after their initial assignment. However, this does not make the value immutable if it's an object or array. You can still change properties or elements within them. Re-declaration: You cannot redeclare a const variable in the same scope, just like let. Example: const z = 5; // z = 10; // Error: Assignment to constant variable. const obj = { name: "John" }; obj.name = "Jane"; // Allowed console.log(obj); // { name: "Jane" } Key Differences at a Glance: var: Function-scoped, hoisted, can be redeclared. let: Block-scoped, hoisted with TDZ (Temporal Dead Zone), cannot be redeclared in the same scope. const: Block-scoped, cannot be reassigned, cannot be redeclared, but objects/arrays declared with const can have mutable properties/elements. When to Use: Use var if you're working with legacy code or need to support older JavaScript versions (not recommended for modern JS). Use let for mutable variables that need to change their values within a block or loop. Use const for immutable values or when you want to prevent accidental reassignment, especially for constants and objects/arrays that you want to maintain structure but modify their contents. 🔧 Mastering var, let, and const will make you a more efficient JavaScript developer and help you avoid tricky bugs! 💻 #JavaScript #WebDevelopment #CodingTips #JavaScriptBestPractices #TechTips #JavaScriptForDevelopers #WebDev #Programming

Who really owns your form data? In a standard HTML input, the DOM is the boss. It holds the value in its own internal memory, and you only "ask" for it when the user hits submit. But in React, we don't like hidden state. We want every piece of data to be explicit and predictable. This is where Controlled Components come in. In this pattern, the React state is the single source of truth. The input doesn't maintain its own value. Instead, you tell the input exactly what to display using the 'value' prop, and you update that value through an 'onChange' handler that modifies the state. The input is "controlled" because its behavior is entirely driven by the React component. Why go through this extra boilerplate? It gives you total coordination over the UI. Since the data lives in your state, you can perform instant field validation, disable the submit button based on specific criteria, or even format the user's input in real-time. There is no "syncing" issue between the DOM and your logic because they are never out of alignment. Of course, controlling every single character stroke in a massive form can feel like overkill. For simple, high-performance scenarios where you just need the data at the end, Uncontrolled Components using 'refs' might be faster. But for most applications, the predictability of a controlled flow far outweighs the cost of a few extra lines of code. It ensures that what the user sees is exactly what your application "knows". #ReactJS #SoftwareEngineering #WebDevelopment #FrontendArchitecture #CodingTips #Javascript

𝐌𝐚𝐬𝐭𝐞𝐫𝐢𝐧𝐠 𝐒𝐭𝐚𝐭𝐞 𝐋𝐨𝐠𝐢𝐜 & 𝐂𝐑𝐔𝐃 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 ⚛️ Yesterday was about the "comeback," but today is about the "consistency." I spent my session diving into dynamic data management—building a Name Manager that handles full CRUD (Create, Read, Update, Delete) logic. To move from static pages to interactive apps, I focused on these three technical pillars: 🔹 𝐮𝐬𝐞𝐒𝐭𝐚𝐭𝐞 (𝐓𝐡𝐞 𝐌𝐞𝐦𝐨𝐫𝐲): In React, components reset on every render. useState acts as the persistent "brain," allowing the app to remember data even when the UI updates. I practiced using setter functions to trigger re-renders safely. 🔹 .𝐦𝐚𝐩() (𝐓𝐡𝐞 𝐔𝐈 𝐅𝐚𝐜𝐭𝐨𝐫𝐲): This is how we turn raw data into an interface. It loops through an array and transforms strings into interactive components. It’s the engine behind every dynamic list you see online. 🔹 .𝐟𝐢𝐥𝐭𝐞𝐫() (𝐓𝐡𝐞 𝐈𝐦𝐦𝐮𝐭𝐚𝐛𝐥𝐞 𝐃𝐞𝐥𝐞𝐭𝐞): React rule #1: Don't mutate state. Instead of "erasing" data from the original array, I used .filter() to create a brand-new copy. This is the secret to building predictable, bug-free applications. 𝐖𝐡𝐚𝐭 𝐈 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 𝐭𝐨𝐝𝐚𝐲: ✅ Create: Added new entries using the Spread Operator [...]. ✅ Read: Rendered a dynamic, real-time list with .map(). ✅ Update/Delete: Built the logic to modify and remove specific items without breaking the state. 𝐓𝐡𝐞 𝐁𝐢𝐠 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲: In React, we don't modify the past; we create a fresh copy of the future! 🚀 #ReactJS #WebDevelopment #JavaScript #FrontendDeveloper #LearningInPublic

In this post, I focused on visualizing how data moves within a React application using a Data Flow Diagram (DFD). Understanding data flow allows developers to: • Build more organized and scalable applications • Avoid unnecessary complexity and bugs • Clearly separate logic from UI • Improve maintainability and readability This approach helped me move beyond writing components to truly understanding how data drives the entire application. #React #Frontend #WebDevelopment #JavaScript #SoftwareArchitecture #CleanCode

JS Object vs. Map: Why simple {} might be slow In JavaScript, we often default to using simple objects {} as dictionaries. Most of the time, it works just fine. But there’s a tipping point where choice of data structure directly impacts both performance and code maintainability. I recently refactored a module in one of Node.js services and here is why we should choose Map for heavy-duty tasks: Non-String Keys: In an Object, keys are limited to Strings or Symbols. In a Map, a key can be anything - an object, an array, or even a function. This is a game-changer for metadata caching. Performance: Map is specifically optimized for frequent additions and removals. If your service handles high-frequency data updates, the performance gap becomes noticeable. Predictable Iteration: Unlike Objects, Map always preserves the insertion order of elements. Built-in Size: No more Object.keys(obj).length. You get the size instantly with .size. The bottleneck: We needed to maintain an in-memory cache for user sessions where the key was a complex device configuration object. Initially, we used JSON.stringify(config) to create string keys. The result was massive CPU overhead on serialization and slower lookups as the cache grew. The solution: By switching to a Map, we used the configuration object itself as the key. No serialization, O(1) lookup time, and much cleaner code. #javascript #nodejs #backend #performance #cleancode #Map #datastructures

🟨 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗗𝗮𝘆 𝟱𝟴: 𝗗𝗮𝘁𝗮 𝗡𝗼𝗿𝗺𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝗶𝗻 𝗥𝗲𝗮𝗰𝘁 (𝗪𝗵𝘆 𝗡𝗲𝘀𝘁𝗲𝗱 𝗦𝘁𝗮𝘁𝗲 𝗗𝗼𝗲𝘀𝗻’𝘁 𝗦𝗰𝗮𝗹𝗲) Ever built a drag & drop UI or complex state… and updates started getting messy? 🤔 🔹 𝗪𝗵𝗲𝗿𝗲 𝗧𝗵𝗶𝘀 𝗛𝗮𝗽𝗽𝗲𝗻𝘀 APIs usually return nested data 👇 But in React, we often transform it into a normalized structure for easier updates & better performance. 🔹 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 (𝗡𝗲𝘀𝘁𝗲𝗱 𝗦𝘁𝗮𝘁𝗲) const data = [ { id: "todo", cards: [ { id: 1, title: "Fix bug" }, { id: 2, title: "Update UI" } ] }, { id: "progress", cards: [ { id: 3, title: "API work" } ] } ]; 👉 Moving a card = moving full object 😵 👉 Updating = deep nested changes ❌ 👉 Causes unnecessary re-renders in React 🔹 𝗧𝗵𝗲 𝗙𝗶𝘅 (𝗡𝗼𝗿𝗺𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻) const data = { columns: { todo: { id: "todo", cardIds: [1, 2] }, progress: { id: "progress", cardIds: [3] } }, cards: { 1: { id: 1, title: "Fix bug" }, 2: { id: 2, title: "Update UI" }, 3: { id: 3, title: "API work" } } }; 👉 Columns store only IDs 👉 Cards stored once (single source of truth) 🔹 𝗪𝗵𝗮𝘁 𝗖𝗵𝗮𝗻𝗴𝗲𝗱 (𝗥𝗲𝗮𝗰𝘁 𝗣𝗲𝗿𝘀𝗽𝗲𝗰𝘁𝗶𝘃𝗲) Before: • Deep state updates • Re-renders large parts of UI • Hard to maintain After: • Update small pieces of state ✅ • Minimal re-renders (better performance) ⚡ • Cleaner, predictable updates 🔹 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 👉 In React, treat state like a database • Store entities once • Reference them using IDs 👉 Drag & Drop = move IDs, not objects 💬 GitHub link in comments. #JavaScript #React #Frontend #Day58 #100DaysOfCode

“set (𝙧𝙚𝙫𝙖𝙡𝙞𝙙𝙖𝙩𝙚: 𝟲𝟬) and move on” This works in Next.js — until it doesn’t. Now you’re: • serving stale data for up to 60s • re-fetching even when nothing changed • adding load for no reason This is where caching stops being an optimization — and becomes about 𝘄𝗵𝗼 𝗼𝘄𝗻𝘀 𝗳𝗿𝗲𝘀𝗵𝗻𝗲𝘀𝘀. At a high level: 𝗦𝘁𝗮𝘁𝗶𝗰 𝗿𝗲𝗻𝗱𝗲𝗿𝗶𝗻𝗴 → speed 𝗗𝘆𝗻𝗮𝗺𝗶𝗰 𝗿𝗲𝗻𝗱𝗲𝗿𝗶𝗻𝗴 → freshness 𝗖𝗮𝗰𝗵𝗶𝗻𝗴 + 𝗿𝗲𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 → where we balance the two But this abstraction starts to break down at scale. 👉 𝗧𝗶𝗺𝗲-𝗯𝗮𝘀𝗲𝗱 𝗿𝗲𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 (𝗿𝗲𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗲) periodically refetches data This works well when data becomes stale in predictable intervals Think dashboards, blogs, or analytics snapshots 👉 𝗢𝗻-𝗱𝗲𝗺𝗮𝗻𝗱 𝗿𝗲𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 (𝗿𝗲𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗲𝗧𝗮𝗴, 𝗿𝗲𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗲𝗣𝗮𝘁𝗵) flips the model Don't blindly revalidate — react to change In one of our systems, moving from time-based to event-driven invalidation: • reduced redundant fetches significantly • cache behavior became predictable under load This becomes the default once writes are frequent. 👉 𝗙𝘂𝗹𝗹 𝗥𝗼𝘂𝘁𝗲 𝗖𝗮𝗰𝗵𝗲 𝘃𝘀 𝗗𝗮𝘁𝗮 𝗖𝗮𝗰𝗵𝗲 • Full Route Cache → caches the rendered output • Data Cache → caches the underlying fetch calls That separation is powerful: Don't rebuild the entire page — refresh just the data 🧠 𝗠𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆 𝗦𝘁𝗼𝗽 𝘁𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗶𝗻 𝘁𝗶𝗺𝗲 → 𝘀𝘁𝗮𝗿𝘁 𝘁𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗶𝗻 𝗲𝘃𝗲𝗻𝘁𝘀 Instead of → “𝘳𝘦𝘷𝘢𝘭𝘪𝘥𝘢𝘵𝘦 𝘦𝘷𝘦𝘳𝘺 𝘟 𝘴𝘦𝘤𝘰𝘯𝘥𝘴” Think → “𝘸𝘩𝘢𝘵 𝘦𝘷𝘦𝘯𝘵 𝘴𝘩𝘰𝘶𝘭𝘥 𝘮𝘢𝘬𝘦 𝘵𝘩𝘪𝘴 𝘥𝘢𝘵𝘢 𝘴𝘵𝘢𝘭𝘦?” ❓Interested to hear how this plays out in write-heavy or multi-region setups. #NextJS #Caching #ReactJS #WebDevelopment #FullStack #JavaScript #SoftwareEngineering #SystemDesign #FrontendDevelopment

You’re still building forms manually from JSON? --- Every time I get a JSON response, I end up doing the same thing: → read structure → map fields → wire inputs → repeat… again --- It’s boring. It’s repetitive. And it shouldn’t exist in 2026. --- So I built something for myself: 👉 Paste JSON 👉 Get a working form instantly --- No setup. No backend. No config headaches. Just: JSON → UI --- Introducing: 🔧 JSON → Form (part of useSignal) 👉 https://lnkd.in/grSx-SEi --- It’s fully browser-native. Which means: - your data never leaves your machine - everything runs instantly - no dependency on any service --- This isn’t just a generator. It’s a way to: → skip repetitive UI work → prototype faster → actually focus on logic --- Try it once. You probably won’t go back to building forms manually. --- 💬 Curious — how are you handling JSON → forms today? #frontend #webdevelopment #javascript #reactjs #devtools #buildinpublic #productivity #developers #webdev

𝐘𝐨𝐮𝐫 `useEffect` 𝐢𝐬 𝐥𝐲𝐢𝐧𝐠 𝐭𝐨 𝐲𝐨𝐮 (𝐨𝐫 𝐦𝐚𝐲𝐛𝐞 𝐲𝐨𝐮'𝐫𝐞 𝐥𝐲𝐢𝐧𝐠 𝐭𝐨 𝐢𝐭). Ever wonder why your `useEffect` hook fires endlessly, or seemingly ignores state updates? The culprit is often more subtle than a missing dependency: it's how JavaScript handles equality for non-primitive types in your dependency array. When you put an object, array, or function directly into `useEffect`'s dependency array, React performs a shallow comparison. If that object/array is re-created on every render (even if its contents are the same), `useEffect` sees a "new" dependency and re-runs. This is a classic source of infinite loops or performance bottlenecks. **Example:** ```jsx // Problematic: obj is new on every render const MyComponent = ({ data }) => { const obj = { id: data.id, name: data.name }; useEffect(() => { // This runs on every render if obj is not memoized console.log('Doing something with obj', obj); }, [obj]); // <--- Shallow comparison sees a new obj reference // ... } ``` **Better approaches:** 1. **Destructure primitives:** If you only need specific primitive values from an object, pass those directly. ```jsx useEffect(() => { console.log('Doing something with id and name', data.id, data.name); }, [data.id, data.name]); // <--- Primitives are compared by value ``` 2. **`useMemo` for stable objects/arrays:** If you absolutely need the whole object, ensure it's memoized. ```jsx const memoizedObj = useMemo(() => ({ id: data.id, name: data.name }), [data.id, data.name]); useEffect(() => { console.log('Doing something with memoizedObj', memoizedObj); }, [memoizedObj]); ``` 3. **`useCallback` for stable functions:** Always wrap functions defined inside components (and passed as props or dependencies) with `useCallback`. Understanding this shallow comparison nuance is key to writing robust and performant React components. It's often where the toughest `useEffect` bugs hide! How do you debug tricky `useEffect` dependencies? Share your tips! #React #JavaScript #Frontend #WebDevelopment #TypeScript