Creating context in React - Quick Revision & Summary

Recall & Review

beginner

What is React Context used for?

React Context is used to share data across components without passing props manually at every level. It helps avoid 'prop drilling' by providing a way to pass data through the component tree.

beginner

How do you create a new Context in React?

You create a new Context by calling React.createContext(). This returns an object with Provider and Consumer components.

beginner

What is the role of the Context Provider?

The Provider component supplies the context value to its child components. Any component inside the Provider can access the shared data.

beginner

How do components consume context values in React?

Components can consume context values using the useContext hook or the Context.Consumer component.

intermediate

Why should you avoid updating context value too often?

Updating context value too often causes all consuming components to re-render, which can hurt performance. It's best to keep context values stable or memoized.

Which React function creates a new context?

A React.useContext()

B React.createContext()

C React.createProvider()

D React.useProvider()

React.createContext() creates a new context object with Provider and Consumer.

What component provides the context value to children?

A Context.Provider

B useContext

C Context.Consumer

D React.Fragment

Context.Provider wraps children and supplies the context value.

How do you access context value inside a functional component?

A Using useContext hook

B Using Context.Provider

C Using React.createContext()

D Using setState

useContext hook reads the current context value inside functional components.

What problem does React Context help solve?

A Managing component state locally

B Handling events

C Styling components

D Avoiding prop drilling

Context helps avoid passing props through many layers (prop drilling).

What happens if the context value changes?

A Only Provider re-renders

B React throws an error

C All consuming components re-render

D Nothing changes

All components using the context will re-render when the value changes.

Explain how to create and use React Context to share data between components.

Think about how to share data without passing props step-by-step.

Describe why and when you should use React Context instead of props.

Consider a family sharing a secret without telling everyone individually.

Practice

1. What is the main purpose of React's createContext() function?

easy

A. To manage local component state

B. To create a new React component

C. To fetch data from an API

D. To create a context object that allows sharing data without passing props manually

Solution

1. Step 1: Understand what createContext() does

   This function creates a context object that can hold data to be shared across components without passing props manually.

2. Step 2: Compare with other options

   Creating components, fetching data, or managing local state are unrelated to createContext().

3. Final Answer:

   To create a context object that allows sharing data without passing props manually -> Option D

4. Quick Check:

   Purpose of createContext() = share data without props [OK]

Hint: Remember: createContext() sets up shared data space [OK]

Common Mistakes:

• Confusing context creation with component creation
• Thinking it fetches data from APIs
• Mixing it up with useState for local state

2. Which of the following is the correct way to create a context in React?

easy

A. const MyContext = useContext();

B. const MyContext = React.createContext();

C. const MyContext = createContext();

D. const MyContext = React.useContext();

Solution

1. Step 1: Identify correct syntax for creating context

   The correct way is to call createContext() from the React object: React.createContext().

2. Step 2: Check other options

   const MyContext = createContext(); misses the React prefix, which causes an error unless imported separately. Options A and D use useContext(), which is for consuming context, not creating it.

3. Final Answer:

   const MyContext = React.createContext(); -> Option B

4. Quick Check:

   Creating context = React.createContext() [OK]

Hint: Use React.createContext() to create context, not useContext() [OK]

Common Mistakes:

• Using useContext() instead of createContext()
• Omitting React prefix without import
• Confusing creation and consumption functions

3. Given the code below, what will be logged to the console?

const MyContext = React.createContext('default');

function Display() {
  const value = React.useContext(MyContext);
  console.log(value);
  return null;
}

function App() {
  return (
    <MyContext.Provider value="hello">
      <Display />
    </MyContext.Provider>
  );
}

medium

A. "hello"

B. "default"

C. undefined

D. Error: useContext called outside provider

Solution

1. Step 1: Understand context default and provider value

   The context default is "default", but the Display component is inside a provider with value "hello".

2. Step 2: Determine value consumed by useContext

   Since Display is inside the provider, useContext(MyContext) returns "hello".

3. Final Answer:

   "hello" -> Option A

4. Quick Check:

   Provider value overrides default = "hello" [OK]

Hint: Provider value overrides default context value [OK]

Common Mistakes:

• Assuming default value is always used
• Thinking useContext errors without provider
• Confusing string quotes in output

4. Identify the error in the following React context usage:

const ThemeContext = React.createContext('light');

function Button() {
  const theme = React.useContext();
  return <button>Theme is {theme}</button>;
}

medium

A. Provider is missing around Button

B. Context should be created with useContext

C. Missing argument in useContext call

D. Button component must be class-based to use context

Solution

1. Step 1: Check useContext usage

   The useContext hook requires the context object as an argument. Here, it is called without any argument.

2. Step 2: Verify other options

   Context is correctly created with createContext. Provider is optional but not an error here. Functional components can use hooks, so no need for class-based.

3. Final Answer:

   Missing argument in useContext call -> Option C

4. Quick Check:

   useContext requires context argument [OK]

Hint: Always pass context object to useContext() [OK]

Common Mistakes:

• Calling useContext() without argument
• Confusing createContext and useContext
• Thinking Provider is mandatory to avoid errors

5. You want to create a theme context that provides either "light" or "dark" mode to your app. Which approach correctly creates and uses this context with a provider and consumer component?

hard

A. const ThemeContext = React.createContext('light');

function ThemeProvider({ children }) {
const theme = 'dark';
return (
<ThemeContext.Provider value={theme}>
{children}
</ThemeContext.Provider>
);
}

function DisplayTheme() {
const theme = React.useContext(ThemeContext);
return <div>Current theme: {theme}</div>;
}

B. const ThemeContext = React.useContext('light');

function ThemeProvider({ children }) {
const theme = 'dark';
return (
<ThemeContext.Provider value={theme}>
{children}
</ThemeContext.Provider>
);
}

function DisplayTheme() {
const theme = React.useContext(ThemeContext);
return <div>Current theme: {theme}</div>;
}

C. const ThemeContext = React.createContext();

function ThemeProvider({ children }) {
const theme = 'dark';
return (
<ThemeContext.Provider value={theme}>
{children}
</ThemeContext.Provider>
);
}

function DisplayTheme() {
const theme = React.useContext();
return <div>Current theme: {theme}</div>;
}

D. const ThemeContext = React.createContext('light');

function ThemeProvider({ children }) {
const [theme, setTheme] = React.useState('dark');
return (
<ThemeContext.Provider value={theme}>
{children}
</ThemeContext.Provider>
);
}

function DisplayTheme() {
const theme = React.useContext(ThemeContext);
return <div>Current theme: {theme}</div>;
}

Solution

1. Step 1: Check context creation and default value

   const ThemeContext = React.createContext('light'); function ThemeProvider({ children }) { const theme = 'dark'; return ( <ThemeContext.Provider value={theme}> {children} </ThemeContext.Provider> ); } function DisplayTheme() { const theme = React.useContext(ThemeContext); return <div>Current theme: {theme}</div>; } correctly creates context with default "light" using createContext('light').

2. Step 2: Verify provider and consumer usage

   The provider passes "dark" as value, and consumer uses useContext(ThemeContext) correctly. const ThemeContext = React.createContext('light'); function ThemeProvider({ children }) { const [theme, setTheme] = React.useState('dark'); return ( <ThemeContext.Provider value={theme}> {children} </ThemeContext.Provider> ); } function DisplayTheme() { const theme = React.useContext(ThemeContext); return <div>Current theme: {theme}</div>; } attempts to use state but misses the React. prefix on useState, causing ReferenceError. const ThemeContext = React.useContext('light'); function ThemeProvider({ children }) { const theme = 'dark'; return ( <ThemeContext.Provider value={theme}> {children} </ThemeContext.Provider> ); } function DisplayTheme() { const theme = React.useContext(ThemeContext); return <div>Current theme: {theme}</div>; } incorrectly calls React.useContext('light') instead of createContext(). const ThemeContext = React.createContext(); function ThemeProvider({ children }) { const theme = 'dark'; return ( <ThemeContext.Provider value={theme}> {children} </ThemeContext.Provider> ); } function DisplayTheme() { const theme = React.useContext(); return <div>Current theme: {theme}</div>; } calls useContext() without argument, causing error.

3. Final Answer:

   Correctly creates and uses context with provider and consumer -> Option A

4. Quick Check:

   Correct createContext and useContext with provider = const ThemeContext = React.createContext('light'); function ThemeProvider({ children }) { const theme = 'dark'; return ( <ThemeContext.Provider value={theme}> {children} </ThemeContext.Provider> ); } function DisplayTheme() { const theme = React.useContext(ThemeContext); return <div>Current theme: {theme}</div>; } [OK]

Hint: createContext with default, provider passes value, useContext consumes [OK]

Common Mistakes:

• Using useContext instead of createContext to create context
• Calling useContext without argument
• Not passing provider value or missing provider