Junior State Management Interview Questions (50 MCQs)

Question 1

When is local state enough?

Accepted Answer

When only one component / nearby branch needs it

Answer

It must always be global

Answer

Only for theme

Answer

It should never be local

Question 2

What is Context a better fit for?

Accepted Answer

Fairly stable data like theme/locale/auth

Answer

Every keystroke in a heavy input with hundreds of consumers

Answer

Fully replacing the network

Answer

CSS only

Question 3

How does data flow in Flux/Redux?

Accepted Answer

Unidirectional: View → Action → Store → View

Answer

Free bidirectional between all layers

Answer

Only Store to DOM with no actions

Answer

Random

Question 4

What is prop drilling?

Accepted Answer

Passing props through layers that don't need them

Answer

Removing unused props

Answer

Sending props to the server

Answer

Mutating props in a child

Question 5

Why not mutate state directly (`state.items.push(x)`)?

Accepted Answer

The reference doesn't change, so React/selectors miss the update

Answer

Because `push` doesn't exist

Answer

It causes a syntax error

Answer

It's fine

Question 6

If `fullName` comes from `first` and `last`, it's better to...

Accepted Answer

Compute it during render, not store it separately

Answer

Store it in a third state and sync via effect

Answer

Store it in localStorage

Answer

Keep it in a ref

Question 7

What does “single source of truth” mean?

Accepted Answer

Each piece of data has exactly one owner/location

Answer

Only one component in the app

Answer

Only one file in the project

Answer

All data lives on the server

Question 8

Why keep filters and pagination in the URL query string?

Accepted Answer

It's shareable, bookmarkable, and works with back/forward

Answer

It's the safest place for passwords

Answer

It's faster than state

Answer

It removes SEO

Question 9

What is a Redux action?

Accepted Answer

A plain object with a `type` (and usually `payload`)

Answer

A function that mutates state directly

Answer

A React component

Answer

An HTTP request

Question 10

If `setCount(count + 1)` is called three times in one handler with `count` = 0, what happens and what's the fix?

Accepted Answer

It ends at 1; use `setCount(c => c + 1)`

Answer

It ends at 3 and there's no problem

Answer

React throws because set was called multiple times

Answer

It ends at 1; you must use `useEffect`

Question 11

Why does `console.log(name)` right after `setName("Ali")` still print the old value?

Accepted Answer

State updates on the next render; `name` is a fixed snapshot for this render

Answer

Because `setName` returns a Promise that must be awaited

Answer

Because `console.log` is disabled in React

Answer

Because strings are immutable in JS

Question 12

Two sibling components need to read and change the same value. What's the simplest approach?

Accepted Answer

Lift the state to the closest common parent and pass it via props

Answer

Create separate `useState` in both and sync them with effects

Answer

Always install Redux

Answer

Keep the value in a module-level global variable

Question 13

What is a controlled input?

Accepted Answer

An input whose `value` comes from state and updates via `onChange`

Answer

An input that only uses `defaultValue`

Answer

An input whose value is read from the DOM via `ref`

Answer

An input that is disabled

Question 14

When is `useReducer` usually a better fit than `useState`?

Accepted Answer

When several related values have complex update logic

Answer

When there's just one simple boolean

Answer

When we want to cache server data

Answer

When the component has no state

Question 15

If a component calls `useContext(ThemeContext)` with no Provider above it, what is returned?

Accepted Answer

The default value passed to `createContext`

Answer

Always `null`

Answer

React throws an error

Answer

The value of the last rendered Provider anywhere in the app

Question 16

What happens when a Context Provider's `value` changes?

Accepted Answer

All components consuming that Context re-render

Answer

Only components reading the changed field re-render

Answer

No component re-renders

Answer

The whole page reloads

Question 17

In Redux, what is the only way to change state?

Accepted Answer

Dispatching an action

Answer

Mutating `store.getState()` directly

Answer

Calling `store.setState()`

Answer

Changing component props

Question 18

What is the signature of a reducer?

Accepted Answer

`(state, action) => newState`

Answer

`(action) => void`

Answer

`(state) => Promise<state>`

Answer

`(dispatch, getState) => void`

Question 19

What does the `useSelector` hook in react-redux do?

Accepted Answer

Reads part of the store state and subscribes to its changes

Answer

Dispatches an action

Answer

Creates a new store

Answer

Registers a new reducer

Question 20

Why wrap the app in `<Provider store={store}>` from react-redux?

Accepted Answer

So hooks like `useSelector` and `useDispatch` can access the store

Answer

So state is automatically saved on the server

Answer

So Redux can manage CSS

Answer

So reducers run asynchronously

Question 21

What does `createSlice` in Redux Toolkit generate?

Accepted Answer

A reducer and action creators based on the defined case reducers

Answer

Only a React component

Answer

An API client for fetching

Answer

A CSS file

Question 22

What does `configureStore` add by default compared to the old `createStore`?

Accepted Answer

Thunk middleware, DevTools setup, and dev checks like mutation detection

Answer

A GraphQL server

Answer

Automatic persistence to localStorage

Answer

Server-side rendering

Question 23

What does `combineReducers` do?

Accepted Answer

Combines reducers so each manages one key of the state

Answer

Merges several stores into one

Answer

Runs actions in parallel

Answer

Turns reducers into middleware

Question 24

How many stores does Redux typically recommend per app?

Accepted Answer

A single store with multiple slices

Answer

One store per component

Answer

One store per page

Answer

No store; only Context

Question 25

Which value should NOT be put in Redux state or actions?

Accepted Answer

A Promise, function, or class instance

Answer

A string

Answer

An array of numbers

Answer

A plain object

Question 26

Which Redux DevTools feature helps debugging the most?

Accepted Answer

Viewing action history and time-traveling between states

Answer

Automatic bundle compression

Answer

Converting code to TypeScript

Answer

Running unit tests

Question 27

In Zustand, what does `create((set) => ({ count: 0 }))` return?

Accepted Answer

A hook usable in components without any Provider

Answer

A Provider component that must wrap the app

Answer

A Redux reducer

Answer

A raw React Context

Question 28

In Zustand, what does `set({ count: 1 })` do to the other state fields?

Accepted Answer

Keeps them; it shallow-merges at the top level

Answer

Deletes them all, leaving only `count`

Answer

Deep-merges all nested objects

Answer

Throws because the whole state must be passed

Question 29

Why prefer `useStore(s => s.count)` over `useStore()` in Zustand?

Accepted Answer

So the component re-renders only when `count` changes

Answer

Because `useStore()` without arguments throws

Answer

Because the selector saves data to localStorage

Answer

Because the selector makes the code async

Question 30

In Jotai, what do `const countAtom = atom(0)` and `useAtom(countAtom)` give you?

Accepted Answer

A `[value, setValue]` pair like `useState`, shared across components

Answer

A global Redux store

Answer

A query for fetching data

Answer

A ref that never triggers re-renders

Question 31

What is the role of `queryKey` in `useQuery`?

Accepted Answer

A unique cache identifier; components with the same key share data

Answer

The HTTP request URL

Answer

An API key for authentication

Answer

The component name for DevTools

Question 32

On the first render of `useQuery` with no cache, what is `data`?

Accepted Answer

`undefined`, and the status is `pending`

Answer

An empty array `[]`

Answer

`null`, with status `success`

Answer

A Promise

Question 33

What is `useMutation` in React Query used for?

Accepted Answer

Server-side data changes like POST, PUT, and DELETE

Answer

Reading and caching data with GET

Answer

Directly mutating local state

Answer

Changing component styles

Question 34

Why does React Query refetch data when you return to the browser tab?

Accepted Answer

`refetchOnWindowFocus` is enabled by default for stale data

Answer

Because the cache is cleared on every tab switch

Answer

Because the browser reloads the page

Answer

It's a bug and shouldn't happen

Question 35

What's the main difference between server state and client state?

Accepted Answer

Server state is owned remotely and can become stale without us knowing

Answer

Server state is always smaller

Answer

Client state never changes

Answer

Server state is stored only in cookies

Question 36

How do you store an object in `localStorage`?

Accepted Answer

Save with `JSON.stringify` and read with `JSON.parse`

Answer

Store the object directly with `setItem`

Answer

Use `toString()`

Answer

It's not possible

Question 37

How does `sessionStorage` differ from `localStorage`?

Accepted Answer

`sessionStorage` is per-tab and cleared when the tab closes

Answer

`sessionStorage` is stored on the server

Answer

`sessionStorage` has unlimited capacity

Answer

`sessionStorage` is shared across all tabs

Question 38

Why can reading `localStorage` in a component body in Next.js throw `window is not defined`?

Accepted Answer

Because the component also renders on the server, where `window` doesn't exist

Answer

Because Next.js bans `localStorage`

Answer

Because `localStorage` must be imported first

Answer

Because `localStorage` only exists in Safari

Question 39

How do you fully reset a form's internal state when the selected user changes?

Accepted Answer

Give the form component `key={userId}`

Answer

By reloading the page

Answer

By clearing the browser cache

Answer

By renaming the component

Question 40

What does React use to preserve a component's state?

Accepted Answer

The component type and its position in the render tree

Answer

The state variable name

Answer

The component's file path

Answer

The import order

Question 41

How does changing `ref.current` differ from calling a `useState` setter?

Accepted Answer

Changing a ref doesn't trigger a re-render

Answer

Changing a ref re-renders the whole app

Answer

A ref resets after every render

Answer

Refs can only hold DOM elements

Question 42

State is `{ name, age }`. Which correctly updates only `name`?

Accepted Answer

`setUser({ ...user, name: "Sara" })`

Answer

`setUser({ name: "Sara" })`

Answer

`user.name = "Sara"; setUser(user)`

Answer

`setUser("Sara")`

Question 43

What's the difference between `useState(compute())` and `useState(() => compute())`?

Accepted Answer

The second runs `compute` only on the first render

Answer

There's no difference

Answer

The second makes state async

Answer

The first runs only once

Question 44

Which removes an item from array state immutably?

Accepted Answer

`setItems(items.filter(i => i.id !== id))`

Answer

`items.splice(index, 1); setItems(items)`

Answer

`delete items[index]; setItems(items)`

Answer

`items.pop(); setItems(items)`

Question 45

Which correctly toggles `done` on one todo in array state?

Accepted Answer

`setTodos(todos.map(t => t.id === id ? { ...t, done: !t.done } : t))`

Answer

`todos.find(t => t.id === id).done = true; setTodos(todos)`

Answer

`setTodos(todos.forEach(t => t.done = true))`

Answer

`setTodos([...todos]); todos[0].done = true`

Question 46

What happens if you call the setter with the current value (`setCount(5)` when `count` is 5)?

Accepted Answer

React detects it via `Object.is` and skips re-rendering children

Answer

The whole tree always re-renders

Answer

React throws an error

Answer

The value becomes `undefined`

Question 47

Which is the best candidate for global state?

Accepted Answer

The logged-in user and app theme

Answer

The text typed into a local search input

Answer

Whether a single dropdown is open

Answer

Whether a button is hovered

Question 48

Why does React Hook Form re-render less in large forms?

Accepted Answer

Because it uses uncontrolled inputs and refs by default

Answer

Because it renders the form on the server

Answer

Because it removes validation entirely

Answer

Because it stores each field in Redux

Question 49

Which statement about React Context is most accurate?

Accepted Answer

Context transports a value down the tree; it doesn't manage state itself

Answer

Context is a full state library with middleware

Answer

Context automatically persists data to localStorage

Answer

Context only works in class components

Question 50

In a Next.js Client Component, which hook reads `?page=2` from the URL?

Accepted Answer

`useSearchParams()` then `searchParams.get("page")`

Answer

`useState("page")`

Answer

`useContext(URL)`

Answer

`useRef(window.page)`

State Management · Junior · 50

When is local state enough?