Fullstack CourseLearn by building
Back to week 1

Topic

Updating objects in state

Definition

Object state should be replaced with a new object rather than mutated so React can compare references predictably.

In simpler words

Copy the object and change only the field you need.

Immutability, spread syntax, and nested updates.

After this you can

  • Update form and UI objects without mutating prior state.
  • Explain the trade-off to a teammate using a small example.
  • Name at least one common bug pattern for this topic.

Understand Updating objects in state

Immutability, spread syntax, and nested updates.

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.

Updating objects in state in code

setTicket(previous => ({
  ...previous,
  status: "done",
}));

Read the example from data and control flow to the resulting UI. Keep the component boundary small.

Apply Updating objects in state

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: Mutate then set same object

// Wrong
ticket.status = "done";
setTicket(ticket);

// Right
setTicket({ ...ticket, status: "done" });

Same reference may skip a reliable update.

Mistake: Shallow copy with nested mutate

// Wrong
const next = { ...ticket };
next.meta.flag = true; // shared nested ref
setTicket(next);

// Right
setTicket({
  ...ticket,
  meta: { ...ticket.meta, flag: true },
});

Copy each level you change.

Mistake: JSON deep clone everything

// Wrong
setTicket(JSON.parse(JSON.stringify(ticket)));

// Right
setTicket({ ...ticket, status: "done" });

JSON drops undefined/Dates and is usually unnecessary.

Live playground

Updating objects in state sandbox

Change one input at a time and predict the next render.

Nest eng · member
setPerson({ ...person, name }); // new object

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

Concept1. Which statement best defines Updating objects in state?
Syntax2. Which implementation matches Updating objects in state?
Practical3. When building a feature, when is Updating objects in state the right choice?
Logic4. What reasoning keeps Updating objects in state predictable as values change?
Concept5. Which statement best defines Updating objects in state?
Syntax6. Which implementation matches Updating objects in state?
Practical7. When building a feature, when is Updating objects in state the right choice?
Logic8. What reasoning keeps Updating objects in state predictable as values change?
Concept9. Which statement best defines Updating objects in state?
Syntax10. Which implementation matches Updating objects in state?