Breaking News: Grepper is joining You.com. Read the official announcement!

React context API tutorial

Add Answer

M Hassan khan answered on January 4, 2021 Popularity 10/10 Helpfulness 1/10

answer React context API tutorial

related setup context api

related React Context API

related react context api

related context api react

related React Context API

related Context Api in react

related react context api

related Context Api in react

related Context_api

related Context Api in react

React context API tutorial

Comment

/*
Context is a feature of React that allows us to create a piece of
state that any component within an area of your 
application can subscribe to.

------------- Why prop drilling is not ideal?----------

When props only have to be drilled through 1-2 components, 
prop drilling is a good strategy for making data available. 
However, when there are more layers to drill through, there may 
end up being many components that take in drilled props and pass 
down those props without ever using them. 
This can be a negative for two reasons:

1) It bloats your code and makes it harder to understand or 
use the middle components.
2) It causes middle components to re-render for changes 
to drilled props even if they don’t use those props themselves.
*/

/*
How do we use React Context API?
Create a new file then we start by creating a React context object, 
a named object created by the React.createContext() function. you
can import from react at the top.
*/

export const MyContext = createContext();

/*
Context objects include a .Provider property that is a 
React component. It takes in a 'value' prop to be stored in the context.
*/

<MyContext.Provider value="Hello world!"> 
   <ChildComponent />
</MyContext.Provider>


/*
That 'value' is available to all its 
descendent components (ChildComponet).

-----How ChildComponent can retrieve the context's value?-----

ChildComponent — can then retrieve the context’s value with 
React’s useContext() hook.

*/

import { useContext } from 'react';
import { MyContext } from './MyContext.js'
 
const ChildComponent = () => {
  const value = useContext(MyContext);
  return <p>{value}</p>;
}
// Renders <p>Hello, world!</p>

/*
The useContext() hook accepts the context object as an 
argument and returns the current value of the context. 
Rejoice — prop drilling that value is no longer needed!
*/

/*
---------What if we want to reuse the same context multiple times 
with different values????----------

Answer: A .Provider component may be reused with the same 
context multiple times in an application with different values. 
 For example, a component might render two .Provider 
 components that each receive a different value:
*/


const GreetingContext = React.createContext();
 
const ChildComponent = () => {
  const greeting = useContext(GreetingContext);
  return <h2>{greeting}</h2>
}
 
const MyComponent = () => {
  return (
    <>
      <GreetingContext.Provider value="bonjour le monde!">
        <ChildComponent />
      </GreetingContext.Provider>
      <GreetingContext.Provider value="hallo welt!">
        <ChildComponent />
      </GreetingContext.Provider>
    </>
  );
};




/*
----------- .Provider Wrappers -------------------

It’s common coding pattern for React applications to
create a “wrapper” component around a .Provider component.

 The wrapper component can provide a value  of its choosing,
 often one of its props or a string literal, 
 to the .Provider component.
 
 */


const ThemeContext = React.createContext();
 
const ThemedMessage = ({ children, theme }) => { //takes two props children and theme
  return (
    <ThemeContext.Provider value={theme}>
      This content is in {theme} mode!
      {children}
    </ThemeContext.Provider>
  );
};

/*
Wrapper components like ThemedMessage can then be used in 
place of a .Provider component to wrap children, means replace any 
calls to ContextName.Provider with this wrapper component.
*/

const MyComponent = () => {
  return (
    <ThemedMessage theme="dark"> // *Important*
    /*
     Make sure to use the *theme* prop rather than the 
     *value* prop of the .Provider.
    */
      Hooray!
    </ThemedMessage>
  )
};

/*
---------Updating Context----------------------

Now we have setup a wrapper component around a Context .Provider
component. Now we’re going to make use of that wrapper 
component by working with React state.

*/

/*
		------prop drilling method------
*/

const CounterApp = () => {
  const [count, setCount] = useState(0);
 
  return (
    <Counter count={count} setCount={setCount} />
  );
};

/*
		-------React Context method-------
        
 One common pattern is to have the context provide an object 
 containing both of those values. Child components that 
 consume the context can then use both (or either of) 
 the state and the state updater function.
*/

const CounterContext = React.createContext();
 
const CounterArea = ({ children, numProp }) => {
  const [count, setCount] = useState(numProp);
 
  return (
    <CounterContext.Provider value={{ count, setCount }}>
      {children}
    </CounterContext.Provider>
  );
};
 
const Counter = () => {
   //  destructuring to use those values from the object 
  //   returned by useContext().
  const { count, setCount } = useContext(CounterContext);

  return (
    <button onClick={() => setCount(count => count+1)}>
      {count}
    </button>
  );
};
 
const CounterApp = () => {
  return (
    <CounterArea>
      <Counter />
    </CounterArea>
  )
}

Popularity 10/10 Helpfulness 1/10 Language javascript

Source: Grepper

Tags: api javascript react-context

Link to this answer
Share Copy Link

Contributed on Dec 31 2022

M Hassan khan

0 Answers Avg Quality 2/10

Closely Related Answers

setup context api

Comment

//# Contect.js 
import { useEffect, useState, createContext } from "react";

export const CharityContext = createContext();

export const CharityContextProvider = ({ children }) => {
  const loki = "chaulagain";
  return <CharityContext.Provider value={{ loki }}>{children}</CharityContext.Provider>;
};

//# app.js
import { CharityContextProvider } from "../context/Context";

function MyApp({ Component, pageProps }: AppProps) {
  return (
    <CharityContextProvider>
      <Component {...pageProps} />
    </CharityContextProvider>
  );
}

export default MyApp;

//# fetch data in any file
import React, { useContext } from "react";
import { CharityContext } from "../context/Context";

function Index() {
  const { loki } = useContext(CharityContext);
  console.log(loki); //-->Result:Chaulagain
  return <div>Index</div>;
}

export default Index;

Popularity 10/10 Helpfulness 3/10 Language typescript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Oct 29 2022

Loki Chaulagain

0 Answers Avg Quality 2/10

React Context API

Comment

/*
The React Context API uses a Provider and Consumer pattern to 
share data throughout an application. The provider role 
is played by a React componentthat makes data available to 
its descendant components. 

When one of those descendants accesses the shared data, 
it becomes a consumer.

To use the React Context API, we start by creating a React 
context object, a named object created by the
React.createContext() function.
*/

const MyContext = React.createContext();

/*
Context objects include a .Provider property that is 
a React component. It takes in a value prop to be stored
in the context.
*/

<MyContext.Provider value="Hello world!">
   <ChildComponent />
</MyContext.Provider>
/*
That value — in this case, the string "Hello world!" — is 
available to all its descendent components. Descendent 
components — in this case, ChildComponent — can then retrieve 
the context’s value with React’s useContext() hook.
*/

import { useContext } from 'react';
import { MyContext } from './MyContext.js'
 
const ChildComponent = () => {
  const value = useContext(MyContext);
  return <p>{value}</p>;
}
// Renders <p>Hello, world!</p>

/*
The useContext() hook accepts the context object as an 
argument and returns the current value 
of the context. Rejoice — prop drilling that value is 
no longer needed!

Note: If a component attempts to use a context that 
isn’t provided by one of its ancestors, useContext() will return null.
*/

Popularity 10/10 Helpfulness 3/10 Language javascript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Dec 30 2022

M Hassan khan

0 Answers Avg Quality 2/10

react context api

Comment

DEFINITION::::::
Context provide a way to pass data through the component tree without 
having to pass down manually at every level

HOW TO USE::::::
DECLARATION:::
	const MyContext = React.createContext()
Creating a new Context for each unique piece of data that needs to be available
throughout your component data
	const LocaleContext = React.createContext()
Properties of LocaleContext --------
	LocaleContext.Provider
    LocaleContext.Consumer

What is a Provider 
	Allows us to "declare the data that we want available throughout our
	component tree"

What is a Consumer
	Allows "any component in the tree that needs that data to be able to 
    subscibe to it"

How to use Provider	
	<MyContext.Provider value={data}>
      <App />
    </MyContext.Provider>

Popularity 10/10 Helpfulness 3/10 Language javascript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Jan 04 2021

KROTUS

0 Answers Avg Quality 2/10

context api react

Comment

import React from "react";
// 1. Create context - storing values
export const CartContext = React.createContext();
// CartContext.Provider
// this is you create that context box
// Provider

export function CartContextProvider({ children }) {
  const [cartCount, setCartCount] = React.useState(0);
  const handleCartUpdate = (val) => {
    setCartCount(cartCount + val);
  };
  const handleDec=(val)=>{

    setCartCount(cartCount + val);
  }

  return (
    <CartContext.Provider value={{ cartCount, handleCartUpdate,handleDec }}>
      {children}
    </CartContext.Provider>
  );
}

=====================navbar.jsx
import React from "react";
import { CartContext } from "../Context/CardContexr";

const Navbar = () => {
  const { cartCount } = React.useContext(CartContext);
  const{handleCartUpdate}= React.useContext(CartContext)
//   const { theme } = React.useContext(ThemeContext);

  return <>
  
  <h1 >Cart Count : {cartCount}</h1>

  <button onClick={()=>{handleCartUpdate(1)}} >change</button>
  </>
};

export default Navbar;

Popularity 10/10 Helpfulness 3/10 Language javascript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Aug 26 2022

Binod Nayak

0 Answers Avg Quality 2/10

React Context API

Comment

import React, { useState } from 'react'

const GlobalStateContext = React.createContext({ })

export const GlobalStateProvider = ({ children }) => {
    const [config, setConfig] = useState({
        projectInfo: ''
    })
    const [projectFile, setProjectFile] = useState('./test.cpp')
    const [executionState, setExecutionState] = useState("NoProject")

    return (
        <GlobalStateContext.Provider
            value={{
                executionState,
                config,
                projectFile,
                setExecutionState,
                setConfig,
                setProjectFile,
            }}
        >
            {children}
        </GlobalStateContext.Provider>
    )
}

export default GlobalStateContext

Popularity 10/10 Helpfulness 3/10 Language javascript

Source: stackoverflow.com

Tags: api

Link to this answer
Share Copy Link

Contributed on Jan 10 2022

Noob Learner

0 Answers Avg Quality 2/10

Context Api in react

Comment

// In App.js 
<NoteState>
	components where you want to use this context which you created    
</NoteState>

// In NoteContext.js 
import { createContext } from "react";

const NoteContext = createContext();

export default NoteContext;

// In NoteState.js or whatever name you want to give
import NoteContext from "./NoteContext";

const NoteState = (props)=>{
  // you can also pass state here also or functions also 
    const user = {
        name: "Gourav Khurana",
        age: 19,
        caast: "General"
    }
    return (
        <NoteContext.Provider value={user}>
            {props.children}
        </NoteContext.Provider>
    )
}
export default NoteState;


This is all about Context API how to create it and add it to Components 

Now how to use it in the Components :- 
  
import React, { useContext } from 'react';
import NoteContext from "../contexts/notes/NoteContext";

const About = () => {
    const contextValue = useContext(NoteContext);
    return (
       you can simply use here. 
    )
}

export default About

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Jan 12 2022

Coding is fun

0 Answers Avg Quality 2/10

react context api

Comment

import { createContext, useContext, useReducer } from "react";

const Actions = {
	SET_ITEMS: "SET_ITEMS",
};

const reducer = (state, action) => {
	if (action.type === Actions.SET_ITEMS) {
		return { ...state, items: action.payload };
    }

	return state;
};

const initialState = {
	items: []
};

const SimpleContext = createContext(initialState);
export const useSimpleContext = () => useContext(SimpleContext);
export const SimpleProvider = ({ children }) => {
	const [state, dispatch] = useReducer(reducer, initialState);

	function setItems(items) {
		dispatch({ type: Actions.SET_ITEMS, payload: items });
	}

	return <SimpleContext.Provider value={{ state, setItems }}>{children}</SimpleContext.Provider>;
};

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Mar 19 2022

Red Team

0 Answers Avg Quality 2/10

Context Api in react

Comment

// In App.js 
<NoteState>
	components where you want to use this context which you created    
</NoteState>

// In NoteContext.js 
import { createContext } from "react";

const NoteContext = createContext();

export default NoteContext;

// In NoteState.js or whatever name you want to give
import NoteContext from "./NoteContext";

const NoteState = (props)=>{
  // you can also pass state here also or functions also 
    const user = {
        name: "Gourav Khurana",
        age: 19,
        caast: "General"
    }
    return (
        <NoteContext.Provider value={user}>
            {props.children}
        </NoteContext.Provider>
    )
}
export default NoteState;


This is all about Context API how to create it and add it to Components 

Now how to use it in the Components :- 
  
import React, { useContext } from 'react';
import NoteContext from "../contexts/notes/NoteContext";

const About = () => {
    const contextValue = useContext(NoteContext);
    return (
       you can simply use here. 
    )
}

export default About

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Jan 12 2022

Coding is fun

0 Answers Avg Quality 2/10

Context_api

Comment

import React, { useContext } from "react";
import CountContext from "./context";

const Child = () => {
  const context = useContext(CountContext);
  const { countHandler } = context;

  return (
    <div>
      <button onClick={countHandler}>Increment</button>
    </div>
  );
};
export default Child;

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: hackernoon.com

Tags: whatever whateve

Link to this answer
Share Copy Link

Contributed on Dec 19 2022

Grumpy Goose

0 Answers Avg Quality 2/10

Context Api in react

Comment

// In App.js 
<NoteState>
	components where you want to use this context which you created    
</NoteState>

// In NoteContext.js 
import { createContext } from "react";

const NoteContext = createContext();

export default NoteContext;

// In NoteState.js or whatever name you want to give
import NoteContext from "./NoteContext";

const NoteState = (props)=>{
  // you can also pass state here also or functions also 
    const user = {
        name: "Gourav Khurana",
        age: 19,
        caast: "General"
    }
    return (
        <NoteContext.Provider value={user}>
            {props.children}
        </NoteContext.Provider>
    )
}
export default NoteState;


This is all about Context API how to create it and add it to Components 

Now how to use it in the Components :- 
  
import React, { useContext } from 'react';
import NoteContext from "../contexts/notes/NoteContext";

const About = () => {
    const contextValue = useContext(NoteContext);
    return (
       you can simply use here. 
    )
}

export default About

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: api

Link to this answer
Share Copy Link

Contributed on Jan 12 2022

Coding is fun

0 Answers Avg Quality 2/10

React context API tutorial

Contents

More Related Answers

React context API tutorial

Closely Related Answers

setup context api

React Context API

react context api

context api react

React Context API

Context Api in react

react context api

Context Api in react

Context_api

Context Api in react

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.