Action — a function passed to startTransition, a form's action prop, or used via useActionState/useOptimistic; runs as a transition and can be async. (Ch 48, 60, 65, 97)
Batching — combining multiple set calls within one event handler into a single re-render rather than one per call. (Ch 24)
Client Component — a component in a file marked 'use client'; executes in the browser, can use state/Effects/browser APIs. (Ch 112)
Commit — the step where React applies the minimal DOM changes calculated during render; follows render, precedes browser paint. (Ch 22)
Context — a mechanism for passing a value to any depth of descendant without prop drilling, created with createContext and read with useContext/use. (Ch 32, 50, 80, 91)
Controlled component — a form element whose value is driven entirely by state + an onChange handler, with no internal DOM-owned value. (Ch 98)
Derived state — a value computed from existing props/state at render time instead of stored as its own state variable. (Ch 28, 37)
Effect — code run via useEffect/useLayoutEffect/useInsertionEffect to synchronize a component with something outside React; has a setup function and optional cleanup. (Ch 36)
Effect Event — a function created with useEffectEvent that reads the latest props/state without itself being a reactive Effect dependency. (Ch 39, 54)
Element — the lightweight, immutable object JSX compiles to (via createElement); describes what to render, not a DOM node or component instance. (Ch 81)
Fragment — <>...</> or <Fragment>; groups JSX children with no extra DOM node. (Ch 67)
Hook — a function starting with use that lets a component tap into React features (state, Effects, context, etc.); must be called at the top level, in the same order every render. (Ch 116)
Hydration — attaching React to server-rendered HTML, reusing the existing DOM and wiring up event listeners rather than re-creating markup. (Ch 95)
Key — a stable identifier for a list item or element, used to preserve/reset state and track identity across renders. (Ch 17, 30)
Lifting state up — moving state from sibling components into their closest common parent so they can share/coordinate it. (Ch 3, 29)
Memoization — caching a value/function/component's output so it's only recomputed when its inputs change (useMemo, useCallback, memo); increasingly automated by React Compiler. (Ch 42, 49, 59, 88)
Portal — content rendered into a DOM node outside a component's normal DOM position, via createPortal, while staying in the React tree for context/events. (Ch 102)
Props — the read-only object a component receives from its parent; a fixed snapshot per render. (Ch 15)
Pure function / purity — same inputs always produce the same output, no mutation of anything that predates the call; required for both rendering and reducers. (Ch 18, 114)
Reducer — a pure (state, action) => newState function centralizing related state-update logic, used with useReducer. (Ch 31, 61)
Ref — a mutable { current: value } box from useRef, persisting across renders without causing re-renders when changed; also used to access DOM nodes. (Ch 34, 62)
Render — React calling component functions to compute the next JSX output; must be pure. (Ch 22)
Render tree — the tree of components (not DOM/HTML nodes) React builds during a render pass. (Ch 19)
Rules of Hooks — Hooks called only at the top level, in the same order every render, only from component/Hook bodies. (Ch 116)
Server Component — the default component type in an RSC app; renders only on the server, never ships its own code to the client. (Ch 110)
Server Function — a function marked 'use server', callable from client code but always executing on the server. (Ch 111, 113)
Snapshot — the fixed props/state values a given render "sees"; a setter call never changes the current render's snapshot, only schedules a new one. (Ch 23)
State — data a component remembers across renders via useState/useReducer; mutating it directly is forbidden — always replace with a new value. (Ch 21, 25, 26)
Strict Mode — a development-only wrapper (<StrictMode>) that double-invokes renders/Effects to surface purity and cleanup bugs; no production effect. (Ch 69)
Suspense — <Suspense fallback={...}>; shows a fallback while descendants are "suspended" (not yet ready), then reveals the real content. (Ch 70)
Synchronization — the general concept an Effect exists to maintain: keeping a component in sync with something outside React as long as its dependency values hold. (Ch 36, 38)
Transition — a state update marked low-priority via useTransition/startTransition, interruptible by more urgent updates. (Ch 65, 90)
Uncontrolled component — a form element whose value the DOM manages internally, set via defaultValue/defaultChecked and read on-demand (often via a ref). (Ch 98)