Keeping components pure in code
function Badge({ status }) {
return <span>{status}</span>;
}Read the example from data and control flow to the resulting UI. Keep the component boundary small.
Back to week 1
Topic
Keeping components pure
Definition
A pure React component returns the same JSX for the same props and state without changing external values during rendering.
In simpler words
Rendering should calculate UI, not change variables, start requests, or edit the DOM.
Pure rendering, local mutation, and predictable re-renders.
After this you can
- Recognize work that belongs in an event handler or Effect.
- Explain the trade-off to a teammate using a small example.
- Name at least one common bug pattern for this topic.
Understand Keeping components pure
Pure rendering, local mutation, and predictable re-renders.
Start by identifying which value or browser behavior changes. Then describe the UI from that current input instead of editing the DOM as a separate source of truth.
Apply Keeping components pure
Keep rendering as a calculation. Put user-triggered changes in event handlers, preserve UI memory in state, and reserve external synchronization for Effects or the server-state layer.
Name values by their UI meaning, test the loading and error path when data is remote, and avoid keeping two editable copies of the same value.
Ask before adding code: is this local UI memory, shared client state, or Nest-owned server state?
Where bugs hide
Definition
High-bug areas are places where a small API misuse looks correct but produces stale UI, duplicate work, or silent failures.
In simpler words
Each mistake below shows Wrong vs Right code — compare them side by side.
When something misbehaves, match the symptom to a pattern below before rewriting the feature.
Prefer fixing the ownership or update path over adding another Effect or sync step.
Mistake: setState during render
// Wrong
function Box({ n }) {
if (n > 10) setFlag(true); // loop risk
return <p>{n}</p>;
}
// Right
function Box({ n }) {
const flag = n > 10; // derive
return <p>{flag ? "big" : n}</p>;
}Derive during render or update in an event/Effect intentionally.
Mistake: Mutating props to sort
// Wrong
function List({ items }) {
items.sort();
return items.map(...);
}
// Right
function List({ items }) {
const sorted = [...items].sort();
return sorted.map(...);
}Copy before sorting — never mutate props.
Mistake: Unstable IDs in render
// Wrong
return <li key={Math.random()}>{title}</li>;
// Right
return <li key={ticket.id}>{title}</li>;IDs must be stable across renders.
Live playground
Keeping components pure sandbox
Change one input at a time and predict the next render.
Pure render: same props/state → same UI. Derive values; do not fetch or setState while rendering.
3
// Right — derive during render
const label = n > 10 ? "big" : n;
return <p>{label}</p>;
// Wrong — setState during render (loop risk)
// if (n > 10) setFlag(true);Keep in mind
- Keep the formal definition in mind; it explains which tool belongs where.
- Prefer one source of truth over synchronized copies of the same value.
- When behavior surprises you, trace: input → update → render → committed UI.
- Study the Wrong vs Right examples in “Where bugs hide” before you merge.
Test
Check your understanding
At least 10 questions — mix of concept, syntax, practical, and logic. Score ≥ 80% (enforced by the API) to save progress.
Checking your session…
10 questions · concept 3 · syntax 3 · practical 2 · logic 2