React.js • Chapter 36 • Foundations to Advanced
Data Fetching Patterns
Study each React concept through explanations, focused examples, code, reasoning, expected behavior, practice, and review.
36.1 Fetching in an Effect
Fetching in an Effect is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery. In Chapter 36, the purpose is to make the behavior observable rather than memorizing an API. Follow the value from its source through the component tree and identify what React needs in order to produce the next interface. This section 36.1 connects the idea directly to Data Fetching Patterns.
For Fetching in an Effect, inspect reactive dependencies, connection setup, cleanup, race conditions, and whether an effect is needed at all. A reliable React design makes ownership explicit, keeps rendering predictable, and separates calculations from synchronization with external systems. When a feature seems complicated, reduce it to one component, one state change, or one boundary and rebuild from that verified behavior. In Data Fetching Patterns, keep the Fetching in an Effect responsibility visible while you test it.
This topic emphasizes structure. Use complete states for loading, success, empty data, and failure when those states can occur. After the example works, explain why React rendered what you see and which change would cause another render; that reasoning is more valuable than copying syntax. For section 36.1, relate that explanation back to Fetching in an Effect.
Key terms in plain language
- Action — an operation that changes data or coordinates asynchronous UI work.
- Fetching — a focused part of fetching in an effect used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Effect — a focused part of fetching in an effect used to describe one responsibility, input, rendering decision, or boundary in the interface.
10 teaching examples
Example 1: Refactoring exercise
Take a large Search panel component that mixes Fetching in an Effect with unrelated concerns. Extract one focused component or custom hook, give it a narrow API, and confirm that the user-visible behavior stays the same.
Example 2: Performance experiment
Profile the Shopping cart before optimizing Fetching in an Effect. Record which components render, what calculation is costly, and whether the delay is actually noticeable; apply an optimization only when the measurement supports it. Fetching in an Effect is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 3: Production review
Assume the Dashboard filter feature using Fetching in an Effect ships to many devices and languages. Review error recovery, loading states, accessibility, RTL layout, small-screen width, security boundaries, and whether monitoring can reveal failures.
Example 4: Smallest useful case
Create the smallest working version of Fetching in an Effect inside a Team roster. Keep one input and one visible result, then describe reactive dependencies, connection setup, cleanup, race conditions, and whether an effect is needed at all. This gives you a baseline before extra features hide the important behavior. Fetching in an Effect is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 5: Change one input
Keep the Analytics card example stable but change one input that affects Fetching in an Effect. Predict what React will render before running the code, then compare the result with your prediction and explain the render path.
Example 6: Two-component comparison
Build one version of the Booking flow with the Fetching in an Effect responsibility in the parent and another with it in the child. Compare data ownership, reuse, and how many components need to know about the decision. Fetching in an Effect is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 7: Failure or edge case
Create a safe edge case for Fetching in an Effect in the Support ticket: empty data, a missing prop, a rejected request, rapid clicks, or an unmounted element. Show the user a clear state instead of allowing confusing or stale output.
Example 8: Accessibility check
Use Fetching in an Effect in the Lesson tracker while testing keyboard access, semantic markup, labels, focus order, and understandable status feedback. React does not replace browser accessibility rules, so verify the generated interface.
Example 9: State ownership check
For the Course catalog, identify which component truly owns the information involved in Fetching in an Effect. Remove duplicated state and derive values during rendering when they can be calculated from existing props or state. Fetching in an Effect is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 10: Network-delay scenario
Assume the Profile settings is waiting on a slow API while using Fetching in an Effect. Decide what stays interactive, what shows pending feedback, what can be cancelled, and how stale responses are prevented from replacing newer data.
React coding example
import { useEffect, useState } from 'react';
export default function TopicDemo() {
const [data, setData] = useState(null);
const [error, setError] = useState('');
useEffect(() => {
const controller = new AbortController();
fetch('/api/example', { signal: controller.signal })
.then(r => r.ok ? r.json() : Promise.reject(new Error('Request failed')))
.then(setData)
.catch(e => { if (e.name !== 'AbortError') setError(e.message); });
return () => controller.abort();
}, []);
return <section><h2>{"Fetching in an Effect"}</h2>{error ? <p role="alert">{error}</p> : <pre>{JSON.stringify(data, null, 2)}</pre>}</section>;
}Step-by-step code explanation
- Identify the responsibility demonstrated by Fetching in an Effect.
- Read the component from inputs to returned JSX before focusing on individual syntax.
- Trace which event, prop, promise, or state update can cause the visible result to change.
- Test one normal path and one edge case so the behavior is not inferred from the happy path alone.
- Keep the example small enough that you can explain every render and every external side effect.
Expected behavior: A small React interface demonstrating Fetching in an Effect; the exact browser text depends on the interaction or data used in the example.
Practice exercise
Create a small interface focused on Fetching in an Effect. Write the expected screen state before running it, test one edge case, and change one input or interaction. Then explain which component owns the relevant data, what caused the render, and one accessibility or small-screen check you would perform before shipping the feature. Record the result as the Chapter 36 practice for Data Fetching Patterns.
36.2 Loading Error and Empty States
State is component memory that persists between renders. Updating state schedules another render rather than changing the current render in place. In Chapter 36, the purpose is to make the behavior observable rather than memorizing an API. Follow the value from its source through the component tree and identify what React needs in order to produce the next interface. This section 36.2 connects the idea directly to Data Fetching Patterns.
For Loading Error and Empty States, inspect initial state, update timing, immutable changes, and the next render. A reliable React design makes ownership explicit, keeps rendering predictable, and separates calculations from synchronization with external systems. When a feature seems complicated, reduce it to one component, one state change, or one boundary and rebuild from that verified behavior. In Data Fetching Patterns, keep the Loading Error and Empty States responsibility visible while you test it.
This topic emphasizes data flow. Use complete states for loading, success, empty data, and failure when those states can occur. After the example works, explain why React rendered what you see and which change would cause another render; that reasoning is more valuable than copying syntax. For section 36.2, relate that explanation back to Loading Error and Empty States.
Key terms in plain language
- Action — an operation that changes data or coordinates asynchronous UI work.
- Loading — a focused part of loading error and empty states used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Error — a focused part of loading error and empty states used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Empty — a focused part of loading error and empty states used to describe one responsibility, input, rendering decision, or boundary in the interface.
10 teaching examples
Example 1: Performance experiment
Profile the Appointment form before optimizing Loading Error and Empty States. Record which components render, what calculation is costly, and whether the delay is actually noticeable; apply an optimization only when the measurement supports it. State is component memory that persists between renders. Updating state schedules another render rather than changing the current render in place.
Example 2: Production review
Assume the Photo gallery feature using Loading Error and Empty States ships to many devices and languages. Review error recovery, loading states, accessibility, RTL layout, small-screen width, security boundaries, and whether monitoring can reveal failures.
Example 3: Smallest useful case
Create the smallest working version of Loading Error and Empty States inside a Support ticket. Keep one input and one visible result, then describe initial state, update timing, immutable changes, and the next render. This gives you a baseline before extra features hide the important behavior. State is component memory that persists between renders. Updating state schedules another render rather than changing the current render in place.
Example 4: Change one input
Keep the Lesson tracker example stable but change one input that affects Loading Error and Empty States. Predict what React will render before running the code, then compare the result with your prediction and explain the render path.
Example 5: Two-component comparison
Build one version of the Course catalog with the Loading Error and Empty States responsibility in the parent and another with it in the child. Compare data ownership, reuse, and how many components need to know about the decision. State is component memory that persists between renders. Updating state schedules another render rather than changing the current render in place.
Example 6: Failure or edge case
Create a safe edge case for Loading Error and Empty States in the Profile settings: empty data, a missing prop, a rejected request, rapid clicks, or an unmounted element. Show the user a clear state instead of allowing confusing or stale output.
Example 7: Accessibility check
Use Loading Error and Empty States in the Search panel while testing keyboard access, semantic markup, labels, focus order, and understandable status feedback. React does not replace browser accessibility rules, so verify the generated interface.
Example 8: State ownership check
For the Shopping cart, identify which component truly owns the information involved in Loading Error and Empty States. Remove duplicated state and derive values during rendering when they can be calculated from existing props or state. State is component memory that persists between renders. Updating state schedules another render rather than changing the current render in place.
Example 9: Network-delay scenario
Assume the Dashboard filter is waiting on a slow API while using Loading Error and Empty States. Decide what stays interactive, what shows pending feedback, what can be cancelled, and how stale responses are prevented from replacing newer data.
Example 10: Refactoring exercise
Take a large Message composer component that mixes Loading Error and Empty States with unrelated concerns. Extract one focused component or custom hook, give it a narrow API, and confirm that the user-visible behavior stays the same.
React coding example
import { useEffect, useState } from 'react';
export default function TopicDemo() {
const [data, setData] = useState(null);
const [error, setError] = useState('');
useEffect(() => {
const controller = new AbortController();
fetch('/api/example', { signal: controller.signal })
.then(r => r.ok ? r.json() : Promise.reject(new Error('Request failed')))
.then(setData)
.catch(e => { if (e.name !== 'AbortError') setError(e.message); });
return () => controller.abort();
}, []);
return <section><h2>{"Loading Error and Empty States"}</h2>{error ? <p role="alert">{error}</p> : <pre>{JSON.stringify(data, null, 2)}</pre>}</section>;
}Step-by-step code explanation
- Identify the responsibility demonstrated by Loading Error and Empty States.
- Read the component from inputs to returned JSX before focusing on individual syntax.
- Trace which event, prop, promise, or state update can cause the visible result to change.
- Test one normal path and one edge case so the behavior is not inferred from the happy path alone.
- Keep the example small enough that you can explain every render and every external side effect.
Expected behavior: A small React interface demonstrating Loading Error and Empty States; the exact browser text depends on the interaction or data used in the example.
Practice exercise
Create a small interface focused on Loading Error and Empty States. Write the expected screen state before running it, test one edge case, and change one input or interaction. Then explain which component owns the relevant data, what caused the render, and one accessibility or small-screen check you would perform before shipping the feature. Record the result as the Chapter 36 practice for Data Fetching Patterns.
36.3 Avoiding Race Conditions
Avoiding Race Conditions is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery. In Chapter 36, the purpose is to make the behavior observable rather than memorizing an API. Follow the value from its source through the component tree and identify what React needs in order to produce the next interface. This section 36.3 connects the idea directly to Data Fetching Patterns.
For Avoiding Race Conditions, inspect inputs, component ownership, visible output, edge cases, and the reason another render occurs. A reliable React design makes ownership explicit, keeps rendering predictable, and separates calculations from synchronization with external systems. When a feature seems complicated, reduce it to one component, one state change, or one boundary and rebuild from that verified behavior. In Data Fetching Patterns, keep the Avoiding Race Conditions responsibility visible while you test it.
This topic emphasizes edge cases. Use complete states for loading, success, empty data, and failure when those states can occur. After the example works, explain why React rendered what you see and which change would cause another render; that reasoning is more valuable than copying syntax. For section 36.3, relate that explanation back to Avoiding Race Conditions.
Key terms in plain language
- Action — an operation that changes data or coordinates asynchronous UI work.
- Avoiding — a focused part of avoiding race conditions used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Race — a focused part of avoiding race conditions used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Conditions — a focused part of avoiding race conditions used to describe one responsibility, input, rendering decision, or boundary in the interface.
10 teaching examples
Example 1: Production review
Assume the Quiz screen feature using Avoiding Race Conditions ships to many devices and languages. Review error recovery, loading states, accessibility, RTL layout, small-screen width, security boundaries, and whether monitoring can reveal failures.
Example 2: Smallest useful case
Create the smallest working version of Avoiding Race Conditions inside a Profile settings. Keep one input and one visible result, then describe inputs, component ownership, visible output, edge cases, and the reason another render occurs. This gives you a baseline before extra features hide the important behavior. Avoiding Race Conditions is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 3: Change one input
Keep the Search panel example stable but change one input that affects Avoiding Race Conditions. Predict what React will render before running the code, then compare the result with your prediction and explain the render path.
Example 4: Two-component comparison
Build one version of the Shopping cart with the Avoiding Race Conditions responsibility in the parent and another with it in the child. Compare data ownership, reuse, and how many components need to know about the decision. Avoiding Race Conditions is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 5: Failure or edge case
Create a safe edge case for Avoiding Race Conditions in the Dashboard filter: empty data, a missing prop, a rejected request, rapid clicks, or an unmounted element. Show the user a clear state instead of allowing confusing or stale output.
Example 6: Accessibility check
Use Avoiding Race Conditions in the Message composer while testing keyboard access, semantic markup, labels, focus order, and understandable status feedback. React does not replace browser accessibility rules, so verify the generated interface.
Example 7: State ownership check
For the Appointment form, identify which component truly owns the information involved in Avoiding Race Conditions. Remove duplicated state and derive values during rendering when they can be calculated from existing props or state. Avoiding Race Conditions is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 8: Network-delay scenario
Assume the Photo gallery is waiting on a slow API while using Avoiding Race Conditions. Decide what stays interactive, what shows pending feedback, what can be cancelled, and how stale responses are prevented from replacing newer data.
Example 9: Refactoring exercise
Take a large Task board component that mixes Avoiding Race Conditions with unrelated concerns. Extract one focused component or custom hook, give it a narrow API, and confirm that the user-visible behavior stays the same.
Example 10: Performance experiment
Profile the Notification center before optimizing Avoiding Race Conditions. Record which components render, what calculation is costly, and whether the delay is actually noticeable; apply an optimization only when the measurement supports it. Avoiding Race Conditions is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
React coding example
import { useEffect, useState } from 'react';
export default function TopicDemo() {
const [data, setData] = useState(null);
const [error, setError] = useState('');
useEffect(() => {
const controller = new AbortController();
fetch('/api/example', { signal: controller.signal })
.then(r => r.ok ? r.json() : Promise.reject(new Error('Request failed')))
.then(setData)
.catch(e => { if (e.name !== 'AbortError') setError(e.message); });
return () => controller.abort();
}, []);
return <section><h2>{"Avoiding Race Conditions"}</h2>{error ? <p role="alert">{error}</p> : <pre>{JSON.stringify(data, null, 2)}</pre>}</section>;
}Step-by-step code explanation
- Identify the responsibility demonstrated by Avoiding Race Conditions.
- Read the component from inputs to returned JSX before focusing on individual syntax.
- Trace which event, prop, promise, or state update can cause the visible result to change.
- Test one normal path and one edge case so the behavior is not inferred from the happy path alone.
- Keep the example small enough that you can explain every render and every external side effect.
Expected behavior: A small React interface demonstrating Avoiding Race Conditions; the exact browser text depends on the interaction or data used in the example.
Practice exercise
Create a small interface focused on Avoiding Race Conditions. Write the expected screen state before running it, test one edge case, and change one input or interaction. Then explain which component owns the relevant data, what caused the render, and one accessibility or small-screen check you would perform before shipping the feature. Record the result as the Chapter 36 practice for Data Fetching Patterns.
36.4 Caching Concepts
Caching Concepts is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery. In Chapter 36, the purpose is to make the behavior observable rather than memorizing an API. Follow the value from its source through the component tree and identify what React needs in order to produce the next interface. This section 36.4 connects the idea directly to Data Fetching Patterns.
For Caching Concepts, inspect inputs, component ownership, visible output, edge cases, and the reason another render occurs. A reliable React design makes ownership explicit, keeps rendering predictable, and separates calculations from synchronization with external systems. When a feature seems complicated, reduce it to one component, one state change, or one boundary and rebuild from that verified behavior. In Data Fetching Patterns, keep the Caching Concepts responsibility visible while you test it.
This topic emphasizes accessibility. Use complete states for loading, success, empty data, and failure when those states can occur. After the example works, explain why React rendered what you see and which change would cause another render; that reasoning is more valuable than copying syntax. For section 36.4, relate that explanation back to Caching Concepts.
Key terms in plain language
- Action — an operation that changes data or coordinates asynchronous UI work.
- Caching — a focused part of caching concepts used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Concepts — a focused part of caching concepts used to describe one responsibility, input, rendering decision, or boundary in the interface.
10 teaching examples
Example 1: Smallest useful case
Create the smallest working version of Caching Concepts inside a Dashboard filter. Keep one input and one visible result, then describe inputs, component ownership, visible output, edge cases, and the reason another render occurs. This gives you a baseline before extra features hide the important behavior. Caching Concepts is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 2: Change one input
Keep the Message composer example stable but change one input that affects Caching Concepts. Predict what React will render before running the code, then compare the result with your prediction and explain the render path.
Example 3: Two-component comparison
Build one version of the Appointment form with the Caching Concepts responsibility in the parent and another with it in the child. Compare data ownership, reuse, and how many components need to know about the decision. Caching Concepts is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 4: Failure or edge case
Create a safe edge case for Caching Concepts in the Photo gallery: empty data, a missing prop, a rejected request, rapid clicks, or an unmounted element. Show the user a clear state instead of allowing confusing or stale output.
Example 5: Accessibility check
Use Caching Concepts in the Task board while testing keyboard access, semantic markup, labels, focus order, and understandable status feedback. React does not replace browser accessibility rules, so verify the generated interface.
Example 6: State ownership check
For the Notification center, identify which component truly owns the information involved in Caching Concepts. Remove duplicated state and derive values during rendering when they can be calculated from existing props or state. Caching Concepts is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 7: Network-delay scenario
Assume the Quiz screen is waiting on a slow API while using Caching Concepts. Decide what stays interactive, what shows pending feedback, what can be cancelled, and how stale responses are prevented from replacing newer data.
Example 8: Refactoring exercise
Take a large Language selector component that mixes Caching Concepts with unrelated concerns. Extract one focused component or custom hook, give it a narrow API, and confirm that the user-visible behavior stays the same.
Example 9: Performance experiment
Profile the Account menu before optimizing Caching Concepts. Record which components render, what calculation is costly, and whether the delay is actually noticeable; apply an optimization only when the measurement supports it. Caching Concepts is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 10: Production review
Assume the Data table feature using Caching Concepts ships to many devices and languages. Review error recovery, loading states, accessibility, RTL layout, small-screen width, security boundaries, and whether monitoring can reveal failures.
React coding example
import { useEffect, useState } from 'react';
export default function TopicDemo() {
const [data, setData] = useState(null);
const [error, setError] = useState('');
useEffect(() => {
const controller = new AbortController();
fetch('/api/example', { signal: controller.signal })
.then(r => r.ok ? r.json() : Promise.reject(new Error('Request failed')))
.then(setData)
.catch(e => { if (e.name !== 'AbortError') setError(e.message); });
return () => controller.abort();
}, []);
return <section><h2>{"Caching Concepts"}</h2>{error ? <p role="alert">{error}</p> : <pre>{JSON.stringify(data, null, 2)}</pre>}</section>;
}Step-by-step code explanation
- Identify the responsibility demonstrated by Caching Concepts.
- Read the component from inputs to returned JSX before focusing on individual syntax.
- Trace which event, prop, promise, or state update can cause the visible result to change.
- Test one normal path and one edge case so the behavior is not inferred from the happy path alone.
- Keep the example small enough that you can explain every render and every external side effect.
Expected behavior: A small React interface demonstrating Caching Concepts; the exact browser text depends on the interaction or data used in the example.
Practice exercise
Create a small interface focused on Caching Concepts. Write the expected screen state before running it, test one edge case, and change one input or interaction. Then explain which component owns the relevant data, what caused the render, and one accessibility or small-screen check you would perform before shipping the feature. Record the result as the Chapter 36 practice for Data Fetching Patterns.
36.5 Framework Data Loading
Framework Data Loading is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery. In Chapter 36, the purpose is to make the behavior observable rather than memorizing an API. Follow the value from its source through the component tree and identify what React needs in order to produce the next interface. This section 36.5 connects the idea directly to Data Fetching Patterns.
For Framework Data Loading, inspect server output, client boundaries, hydration consistency, streaming sequence, and deployment runtime. A reliable React design makes ownership explicit, keeps rendering predictable, and separates calculations from synchronization with external systems. When a feature seems complicated, reduce it to one component, one state change, or one boundary and rebuild from that verified behavior. In Data Fetching Patterns, keep the Framework Data Loading responsibility visible while you test it.
This topic emphasizes production behavior. Use complete states for loading, success, empty data, and failure when those states can occur. After the example works, explain why React rendered what you see and which change would cause another render; that reasoning is more valuable than copying syntax. For section 36.5, relate that explanation back to Framework Data Loading.
Key terms in plain language
- Action — an operation that changes data or coordinates asynchronous UI work.
- Framework — a focused part of framework data loading used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Data — a focused part of framework data loading used to describe one responsibility, input, rendering decision, or boundary in the interface.
- Loading — a focused part of framework data loading used to describe one responsibility, input, rendering decision, or boundary in the interface.
10 teaching examples
Example 1: Change one input
Keep the Task board example stable but change one input that affects Framework Data Loading. Predict what React will render before running the code, then compare the result with your prediction and explain the render path.
Example 2: Two-component comparison
Build one version of the Notification center with the Framework Data Loading responsibility in the parent and another with it in the child. Compare data ownership, reuse, and how many components need to know about the decision. Framework Data Loading is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 3: Failure or edge case
Create a safe edge case for Framework Data Loading in the Quiz screen: empty data, a missing prop, a rejected request, rapid clicks, or an unmounted element. Show the user a clear state instead of allowing confusing or stale output.
Example 4: Accessibility check
Use Framework Data Loading in the Language selector while testing keyboard access, semantic markup, labels, focus order, and understandable status feedback. React does not replace browser accessibility rules, so verify the generated interface.
Example 5: State ownership check
For the Account menu, identify which component truly owns the information involved in Framework Data Loading. Remove duplicated state and derive values during rendering when they can be calculated from existing props or state. Framework Data Loading is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 6: Network-delay scenario
Assume the Data table is waiting on a slow API while using Framework Data Loading. Decide what stays interactive, what shows pending feedback, what can be cancelled, and how stale responses are prevented from replacing newer data.
Example 7: Refactoring exercise
Take a large Upload panel component that mixes Framework Data Loading with unrelated concerns. Extract one focused component or custom hook, give it a narrow API, and confirm that the user-visible behavior stays the same.
Example 8: Performance experiment
Profile the Team roster before optimizing Framework Data Loading. Record which components render, what calculation is costly, and whether the delay is actually noticeable; apply an optimization only when the measurement supports it. Framework Data Loading is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
Example 9: Production review
Assume the Analytics card feature using Framework Data Loading ships to many devices and languages. Review error recovery, loading states, accessibility, RTL layout, small-screen width, security boundaries, and whether monitoring can reveal failures.
Example 10: Smallest useful case
Create the smallest working version of Framework Data Loading inside a Photo gallery. Keep one input and one visible result, then describe server output, client boundaries, hydration consistency, streaming sequence, and deployment runtime. This gives you a baseline before extra features hide the important behavior. Framework Data Loading is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
React coding example
import { useEffect, useState } from 'react';
export default function TopicDemo() {
const [data, setData] = useState(null);
const [error, setError] = useState('');
useEffect(() => {
const controller = new AbortController();
fetch('/api/example', { signal: controller.signal })
.then(r => r.ok ? r.json() : Promise.reject(new Error('Request failed')))
.then(setData)
.catch(e => { if (e.name !== 'AbortError') setError(e.message); });
return () => controller.abort();
}, []);
return <section><h2>{"Framework Data Loading"}</h2>{error ? <p role="alert">{error}</p> : <pre>{JSON.stringify(data, null, 2)}</pre>}</section>;
}Step-by-step code explanation
- Identify the responsibility demonstrated by Framework Data Loading.
- Read the component from inputs to returned JSX before focusing on individual syntax.
- Trace which event, prop, promise, or state update can cause the visible result to change.
- Test one normal path and one edge case so the behavior is not inferred from the happy path alone.
- Keep the example small enough that you can explain every render and every external side effect.
Expected behavior: A small React interface demonstrating Framework Data Loading; the exact browser text depends on the interaction or data used in the example.
Practice exercise
Create a small interface focused on Framework Data Loading. Write the expected screen state before running it, test one edge case, and change one input or interaction. Then explain which component owns the relevant data, what caused the render, and one accessibility or small-screen check you would perform before shipping the feature. Record the result as the Chapter 36 practice for Data Fetching Patterns.
Chapter 36 review — 20 questions and answers
1. What problem does Fetching in an Effect help solve in this chapter?
Answer: Fetching in an Effect is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
2. What should you inspect when Fetching in an Effect does not behave as expected?
Answer: Check reactive dependencies, connection setup, cleanup, race conditions, and whether an effect is needed at all. Reduce the example until you can identify the input, render decision, update, and visible result.
3. How can you practice Fetching in an Effect without copying a large application?
Answer: Build a small component focused on Fetching in an Effect, predict its output, change one condition, and explain why React renders the new result.
4. What production concern belongs with Fetching in an Effect?
Answer: Review error recovery, accessibility, performance, security boundaries, localization, and small-screen behavior according to what Fetching in an Effect touches.
5. What problem does Loading Error and Empty States help solve in this chapter?
Answer: State is component memory that persists between renders. Updating state schedules another render rather than changing the current render in place.
6. What should you inspect when Loading Error and Empty States does not behave as expected?
Answer: Check initial state, update timing, immutable changes, and the next render. Reduce the example until you can identify the input, render decision, update, and visible result.
7. How can you practice Loading Error and Empty States without copying a large application?
Answer: Build a small component focused on Loading Error and Empty States, predict its output, change one condition, and explain why React renders the new result.
8. What production concern belongs with Loading Error and Empty States?
Answer: Review error recovery, accessibility, performance, security boundaries, localization, and small-screen behavior according to what Loading Error and Empty States touches.
9. What problem does Avoiding Race Conditions help solve in this chapter?
Answer: Avoiding Race Conditions is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
10. What should you inspect when Avoiding Race Conditions does not behave as expected?
Answer: Check inputs, component ownership, visible output, edge cases, and the reason another render occurs. Reduce the example until you can identify the input, render decision, update, and visible result.
11. How can you practice Avoiding Race Conditions without copying a large application?
Answer: Build a small component focused on Avoiding Race Conditions, predict its output, change one condition, and explain why React renders the new result.
12. What production concern belongs with Avoiding Race Conditions?
Answer: Review error recovery, accessibility, performance, security boundaries, localization, and small-screen behavior according to what Avoiding Race Conditions touches.
13. What problem does Caching Concepts help solve in this chapter?
Answer: Caching Concepts is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
14. What should you inspect when Caching Concepts does not behave as expected?
Answer: Check inputs, component ownership, visible output, edge cases, and the reason another render occurs. Reduce the example until you can identify the input, render decision, update, and visible result.
15. How can you practice Caching Concepts without copying a large application?
Answer: Build a small component focused on Caching Concepts, predict its output, change one condition, and explain why React renders the new result.
16. What production concern belongs with Caching Concepts?
Answer: Review error recovery, accessibility, performance, security boundaries, localization, and small-screen behavior according to what Caching Concepts touches.
17. What problem does Framework Data Loading help solve in this chapter?
Answer: Framework Data Loading is best understood through action: an operation that changes data or coordinates asynchronous UI work. Focus on pending state, optimistic feedback, promise reading, form submission, and recovery.
18. What should you inspect when Framework Data Loading does not behave as expected?
Answer: Check server output, client boundaries, hydration consistency, streaming sequence, and deployment runtime. Reduce the example until you can identify the input, render decision, update, and visible result.
19. How can you practice Framework Data Loading without copying a large application?
Answer: Build a small component focused on Framework Data Loading, predict its output, change one condition, and explain why React renders the new result.
20. What production concern belongs with Framework Data Loading?
Answer: Review error recovery, accessibility, performance, security boundaries, localization, and small-screen behavior according to what Framework Data Loading touches.