Fullstack CourseLearn by building
Back to week 2

Topic

Reusing logic with custom Hooks

Definition

A custom Hook is a function starting with use that composes Hooks to share stateful logic without sharing component markup.

In simpler words

Extract repeated behavior into useSomething; each caller still receives independent state.

Hook composition, inputs, returned APIs, and rules of Hooks.

After this you can

  • Reuse browser and UI behavior with a clear API.
  • Explain the trade-off to a teammate using a small example.
  • Name at least one common bug pattern for this topic.

Understand Reusing logic with custom Hooks

Hook composition, inputs, returned APIs, and rules of Hooks.

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.

Reusing logic with custom Hooks in code

function useToggle(initial = false) {
  const [on, setOn] = useState(initial);
  return { on, toggle: () => setOn(value => !value) };
}

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

Apply Reusing logic with custom Hooks

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: Conditional hooks inside custom hook

// Wrong
function useX(flag) {
  if (!flag) return {};
  const [v, setV] = useState(0);
}

// Right
function useX(flag) {
  const [v, setV] = useState(0);
  if (!flag) return {};
  ...
}

Hooks must run unconditionally.

Mistake: Shared module mutable state

// Wrong
let shared = 0;
function useCounter() {
  return { n: shared, inc: () => shared++ };
}

// Right
function useCounter() {
  const [n, setN] = useState(0);
  return { n, inc: () => setN(x => x + 1) };
}

Each hook call needs its own state.

Mistake: Hide Axios errors

// Wrong
function useTickets() {
  useEffect(() => { list().then(setData); }, []);
  return data; // no error/loading
}

// Right
function useTickets() {
  return useQuery({ queryKey: ["tickets"], queryFn: list });
}

Callers need loading and error states.

Live playground

Reusing logic with custom Hooks sandbox

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

Imagine useOnline() wraps this state + event subscription.

Connected

function useOnline() { /* subscribe once */ }

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 Reusing logic with custom Hooks?
Syntax2. Which implementation matches Reusing logic with custom Hooks?
Practical3. When building a feature, when is Reusing logic with custom Hooks the right choice?
Logic4. What reasoning keeps Reusing logic with custom Hooks predictable as values change?
Concept5. Which statement best defines Reusing logic with custom Hooks?
Syntax6. Which implementation matches Reusing logic with custom Hooks?
Practical7. When building a feature, when is Reusing logic with custom Hooks the right choice?
Logic8. What reasoning keeps Reusing logic with custom Hooks predictable as values change?
Concept9. Which statement best defines Reusing logic with custom Hooks?
Syntax10. Which implementation matches Reusing logic with custom Hooks?