Redux Multiple Choice Questions (MCQs) and Answers

The Redux state is being mutated in the reducer.

Middleware is missing.

The dispatch function is not working.

The store is not updating the UI.

Any synchronous state update inside reducers

Actions that modify the Redux store directly

Operations like API calls, timers, or logging that happen outside Redux

Pure functions that return a new state

Using Redux Thunk for async actions

Using Redux Saga for complex side effects

Directly modifying the Redux state inside reducers

Using middleware like Redux Observable

It allows async operations to be handled outside reducers

It removes the need for action creators

It replaces reducers

It modifies the store directly

API calls are synchronous and block UI updates

Reducers must be pure functions without side effects

Reducers cannot access external APIs

Reducers should return promises instead of state objects

Thunk is synchronous while Saga is asynchronous

Thunk uses functions inside actions, while Saga uses generators to manage side effects

Thunk modifies reducers, while Saga modifies actions

Saga requires no additional setup while Thunk does

const fetchData = () => dispatch => { dispatch({ type: 'FETCH_START' }); fetch('/api/data').then(res => res.json()).then(data => dispatch({ type: 'FETCH_SUCCESS', payload: data })); };

const fetchData = () => { return { type: 'FETCH_START' }; }

const fetchData = async () => { const data = await fetch('/api/data'); return { type: 'FETCH_SUCCESS', payload: data }; }

const fetchData = () => store.getState();

The Redux action will fail because async is not supported

The API call will execute and update the store correctly

The function must return a promise instead of dispatching actions

The await keyword should not be used in Redux

The saga listens for FETCH_DATA actions and makes an API call when triggered

The saga replaces the Redux store

The reducer modifies the store directly

The saga runs once on app load and never again

The call effect does not return a promise

The response needs to be converted using yield call([response, 'json'])

The fetch call should be placed inside a reducer

The saga should return an action object instead of dispatching it

The API response is incorrect

The function does not return a promise

The success action is missing in the dispatch chain

Redux Thunk does not support API calls

The Saga function is missing a yield statement

The reducer is not handling the actions

The dispatch function is not working

Saga cannot handle side effects

The action is dispatched multiple times without condition checks

Redux does not support async actions

Reducers modify the Redux store directly

Middleware is missing in the Redux setup

It improves the performance of React components

It ensures the Redux store can modify state directly

It prevents unnecessary re-renders in React and ensures predictable state updates

It allows direct changes to be made inside reducers

By modifying the existing state object

By using the setState function

By returning a new object with updated properties

By using this.state directly

Redux throws an error

React may not detect changes, leading to incorrect UI updates

The Redux store automatically corrects the mutation

The action gets dispatched twice

Using the spread operator (...state, newItem)

Using state.push(newItem)

Modifying state directly

Using a global variable

return { ...state, count: state.count + 1 };

state.count++; return state;

return Object.assign(state, { count: state.count + 1 });

state = { count: state.count + 1 }; return state;

return { ...state, items: state.items.push(newItem) };

return { ...state, items: [...state.items, newItem] };

state.items.push(newItem); return state;

return { state.items.concat(newItem) };

The reducer does not handle actions correctly

The reducer mutates state directly instead of returning a new object

The reducer is missing an initial state

The reducer should use useState instead of Redux

The reducer is modifying the existing state instead of returning a new one

The component is not connected to Redux

The action type is missing

The Redux store is missing middleware

The reducer is returning a new state object instead of modifying it

The reducer is modifying the state object directly

Middleware is missing

Actions are dispatched incorrectly

Using console.log inside reducers

Using the Redux DevTools extension

Manually checking the store.getState() function

Observing UI changes

The Redux store crashes immediately

Actions stop being dispatched

State updates do not trigger re-renders in React components

The store automatically resets to the initial state

The action type is not handled in the reducer

The Redux store is missing middleware

The reducer is modifying state directly

The dispatch function is incorrect

An action is missing a type property

A reducer is calling dispatch inside itself

The Redux store has no initial state

Middleware is incorrectly applied

The reducer should return null instead of state

The reducer is mutating the state directly

The reducer should call dispatch instead

State should be reset inside the reducer

return { ...state, todos: [...state.todos, action.payload] };

state.todos.push(action.payload); return state;

state = { todos: action.payload }; return state;

return Object.assign(state, { todos: action.payload });

The API call is missing

The function is dispatching the same action twice

The reducer is incorrect

Middleware is missing

Use Redux middleware

Use localStorage to save and rehydrate the state

Add more reducers to the store

Use React Context instead of Redux