Navigation state persistence in React Native - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens to navigation state after app restart?

Consider a React Native app using React Navigation with state persistence enabled. The user navigates from Home to Profile screen. Then the app is closed and reopened.

What will be the visible screen after reopening?

A The app shows the Home screen because navigation state is reset on restart.

B The app shows the Profile screen because navigation state was saved and restored.

C The app crashes because navigation state cannot be persisted.

D The app shows a blank screen because state restoration failed silently.

💡 Hint

Think about what state persistence means for navigation.

When navigation state persistence is enabled, the app saves the current navigation stack. On restart, it restores this stack, so the user returns to the last visited screen.

🧠 Conceptual

intermediate

Which method is used to save navigation state in React Navigation?

In React Navigation, to persist navigation state, which method is typically used to save the state externally?

A Using <code>onStateChange</code> callback to save state to storage.

B Using <code>useEffect</code> to reset navigation state on every render.

C Using <code>navigation.reset()</code> to save state.

D Using <code>componentDidMount</code> lifecycle method to save state.

💡 Hint

Look for a callback that triggers when navigation state changes.

The onStateChange prop on the NavigationContainer is called whenever navigation state changes. This is where you save the state to persistent storage.

❓ lifecycle

advanced

Why might navigation state restoration fail on app start?

Given this code snippet for restoring navigation state in React Native:

const [isReady, setIsReady] = React.useState(false);
const [initialState, setInitialState] = React.useState();

React.useEffect(() => {
  async function restoreState() {
    const savedState = await AsyncStorage.getItem('NAVIGATION_STATE');
    if (savedState) {
      setInitialState(JSON.parse(savedState));
    }
    setIsReady(true);
  }
  restoreState();
}, []);

if (!isReady) {
  return null;
}

return (
  <NavigationContainer initialState={initialState} onStateChange={...} >...
);

What is a common reason this restoration might silently fail and show the initial screen instead of the saved state?

A The <code>initialState</code> is set after the NavigationContainer mounts, so it ignores it.

B AsyncStorage.getItem returns a promise that is never awaited.

C The <code>isReady</code> state is set to true before <code>initialState</code> is set.

D The saved state is not stringified before saving.

💡 Hint

Think about when NavigationContainer reads the initialState prop.

NavigationContainer reads the initialState only on first mount. If initialState is undefined at that time and set later, it will ignore it and start fresh.

🔧 Debug

advanced

What error occurs if navigation state is corrupted on restore?

If the saved navigation state in AsyncStorage is corrupted or incomplete JSON, what error will React Navigation most likely throw when trying to restore it?

A ReferenceError: NavigationContainer is not defined

B TypeError: Cannot read property 'routes' of undefined

C SyntaxError: Unexpected token in JSON at position X

D RangeError: Maximum call stack size exceeded

💡 Hint

Consider what happens when JSON.parse fails.

If the saved state is corrupted, JSON.parse throws a SyntaxError indicating invalid JSON syntax.

🧠 Conceptual

expert

How to optimize navigation state persistence for large apps?

In a large React Native app with many screens, persisting the entire navigation state can be slow and cause UI delays. Which approach best optimizes navigation state persistence?

A Persist the full navigation state on every state change without throttling.

B Persist navigation state only when the app goes to background.

C Disable state persistence and rely on default navigation behavior.

D Persist only the minimal necessary parts of the navigation state, like current route name and params.

💡 Hint

Think about saving less data to improve performance.

Saving only essential parts of the navigation state reduces storage size and speeds up restoration, improving app responsiveness.

Practice

1. What is the main purpose of navigation state persistence in a React Native app?

easy

A. To change the app's theme based on user preference

B. To speed up the app's loading time by caching images

C. To save the user's current screen so they return to it after closing the app

D. To reset the app to the home screen every time it opens

Solution

1. Step 1: Understand navigation state persistence

   Navigation state persistence means saving where the user is in the app so they can continue from the same place later.

2. Step 2: Identify the correct purpose

   Only To save the user's current screen so they return to it after closing the app describes saving the current screen to restore it after app restart.

3. Final Answer:

   To save the user's current screen so they return to it after closing the app -> Option C

4. Quick Check:

   Navigation state persistence = save current screen [OK]

Hint: Remember: persistence means saving state for later use [OK]

Common Mistakes:

• Confusing navigation state with app theme or cache
• Thinking it resets app screens instead of saving them

2. Which of the following is the correct way to use NavigationContainer for state persistence?

easy

A.

B.

C.

D.

Solution

1. Step 1: Recall NavigationContainer props for persistence

   The correct props are initialState to set saved state and onStateChange to save new state.

2. Step 2: Match options with correct props

   Only uses initialState and onStateChange correctly.

3. Final Answer:

   <NavigationContainer initialState={savedState} onStateChange={saveState}> -> Option D

4. Quick Check:

   Use initialState and onStateChange props [OK]

Hint: Look for exact prop names: initialState and onStateChange [OK]

Common Mistakes:

• Using wrong prop names like state or onChange
• Swapping savedState and saveState variables

3. Given this code snippet, what will happen after the user navigates to 'Profile' and the app restarts?

const [initialState, setInitialState] = React.useState();
React.useEffect(() => {
  AsyncStorage.getItem('NAV_STATE').then(state => {
    if(state) setInitialState(JSON.parse(state));
  });
}, []);

 AsyncStorage.setItem('NAV_STATE', JSON.stringify(state))}
>
  {/* screens */}
;

medium

A. The app opens on the default initial screen ignoring saved state

B. The app opens on the 'Profile' screen automatically

C. The app crashes due to missing navigation state

D. The app opens on a blank screen

Solution

1. Step 1: Understand AsyncStorage usage

   The code loads saved navigation state from AsyncStorage and sets it as initialState.

2. Step 2: Effect of initialState on NavigationContainer

   Passing initialState restores the last screen, so the app opens on 'Profile' after restart.

3. Final Answer:

   The app opens on the 'Profile' screen automatically -> Option B

4. Quick Check:

   Saved state restores last screen [OK]

Hint: Saved state in initialState restores last screen [OK]

Common Mistakes:

• Assuming app ignores saved state and resets
• Thinking missing state causes crash

4. Identify the bug in this code that tries to persist navigation state:

const [navState, setNavState] = React.useState();

React.useEffect(() => {
  AsyncStorage.getItem('NAV_STATE').then(state => {
    setNavState(state);
  });
}, []);

 AsyncStorage.setItem('NAV_STATE', JSON.stringify(state))}
>
  {/* screens */}
;

medium

A. The saved state is not parsed from JSON before setting navState

B. The onStateChange callback should not stringify the state

C. initialState should be set to null instead of undefined

D. AsyncStorage.getItem should be called inside onStateChange

Solution

1. Step 1: Check AsyncStorage.getItem usage

   AsyncStorage.getItem returns a JSON string, so it must be parsed before use.

2. Step 2: Identify missing JSON.parse

   The code sets navState directly to the string, causing navigation to fail.

3. Final Answer:

   The saved state is not parsed from JSON before setting navState -> Option A

4. Quick Check:

   Parse JSON before setting state [OK]

Hint: Always parse JSON from AsyncStorage before using [OK]

Common Mistakes:

• Forgetting JSON.parse on saved state
• Misusing onStateChange callback

5. You want to persist navigation state but only save it after the user has navigated at least once. Which approach correctly implements this behavior?

hard

A. Use a ref to track if navigation happened, then save state in onStateChange only if true

B. Save state immediately on app start inside useEffect

C. Call AsyncStorage.clear() before saving state to avoid duplicates

D. Set initialState to null and never update it

Solution

1. Step 1: Understand conditional saving need

   We want to save navigation state only after user navigates once, so we track navigation occurrence.

2. Step 2: Use a ref to track navigation

   A ref can store a boolean flag that updates on first navigation, then onStateChange saves state only if true.

3. Step 3: Evaluate other options

   Save state immediately on app start inside useEffect saves immediately, ignoring condition; C clears storage unnecessarily; D disables persistence.

4. Final Answer:

   Use a ref to track if navigation happened, then save state in onStateChange only if true -> Option A

5. Quick Check:

   Track navigation with ref before saving state [OK]

Hint: Use a ref flag to save state only after first navigation [OK]

Common Mistakes:

• Saving state too early before navigation
• Clearing storage unnecessarily
• Ignoring initialState updates