We Keep Coding

How can I correctly use the React context API in a class based component? [duplicate]

In this example, I have this react class:
class MyDiv extends React.component
constructor(){
this.state={sampleState:'hello world'}
}
render(){
return <div>{this.state.sampleState}
}
}
The question is if I can add React hooks to this. I understand that React-Hooks is alternative to React Class style. But if I wish to slowly migrate into React hooks, can I add useful hooks into Classes?

High order components are how we have been doing this type of thing until hooks came along. You can write a simple high order component wrapper for your hook.
function withMyHook(Component) {
return function WrappedComponent(props) {
const myHookValue = useMyHook();
return <Component {...props} myHookValue={myHookValue} />;
}
}
While this isn't truly using a hook directly from a class component, this will at least allow you to use the logic of your hook from a class component, without refactoring.
class MyComponent extends React.Component {
render(){
const myHookValue = this.props.myHookValue;
return <div>{myHookValue}</div>;
}
}
export default withMyHook(MyComponent);

Class components don't support hooks -
According to the Hooks-FAQ:
You can’t use Hooks inside of a class component, but you can definitely mix classes and function components with Hooks in a single tree. Whether a component is a class or a function that uses Hooks is an implementation detail of that component. In the longer term, we expect Hooks to be the primary way people write React components.

As other answers already explain, hooks API was designed to provide function components with functionality that currently is available only in class components. Hooks aren't supposed to used in class components.
Class components can be written to make easier a migration to function components.
With a single state:
class MyDiv extends Component {
state = {sampleState: 'hello world'};
render(){
const { state } = this;
const setState = state => this.setState(state);
return <div onClick={() => setState({sampleState: 1})}>{state.sampleState}</div>;
}
}
is converted to
const MyDiv = () => {
const [state, setState] = useState({sampleState: 'hello world'});
return <div onClick={() => setState({sampleState: 1})}>{state.sampleState}</div>;
}
Notice that useState state setter doesn't merge state properties automatically, this should be covered with setState(prevState => ({ ...prevState, foo: 1 }));
With multiple states:
class MyDiv extends Component {
state = {sampleState: 'hello world'};
render(){
const { sampleState } = this.state;
const setSampleState = sampleState => this.setState({ sampleState });
return <div onClick={() => setSampleState(1)}>{sampleState}</div>;
}
}
is converted to
const MyDiv = () => {
const [sampleState, setSampleState] = useState('hello world');
return <div onClick={() => setSampleState(1)}>{sampleState}</div>;
}

Complementing Joel Cox's good answer
Render Props also enable the usage of Hooks inside class components, if more flexibility is needed:
class MyDiv extends React.Component {
render() {
return (
<HookWrapper
// pass state/props from inside of MyDiv to Hook
someProp={42}
// process Hook return value
render={hookValue => <div>Hello World! {hookValue}</div>}
/>
);
}
}
function HookWrapper({ someProp, render }) {
const hookValue = useCustomHook(someProp);
return render(hookValue);
}
For side effect Hooks without return value:
function HookWrapper({ someProp }) {
useCustomHook(someProp);
return null;
}
// ... usage
<HookWrapper someProp={42} />
Source: React Training

you can achieve this by generic High order components
HOC
import React from 'react';
const withHook = (Component, useHook, hookName = 'hookvalue') => {
return function WrappedComponent(props) {
const hookValue = useHook();
return <Component {...props} {...{[hookName]: hookValue}} />;
};
};
export default withHook;
Usage
class MyComponent extends React.Component {
render(){
const myUseHookValue = this.props.myUseHookValue;
return <div>{myUseHookValue}</div>;
}
}
export default withHook(MyComponent, useHook, 'myUseHookValue');

Hooks are not meant to be used for classes but rather functions. If you wish to use hooks, you can start by writing new code as functional components with hooks
According to React FAQs
You can’t use Hooks inside of a class component, but you can
definitely mix classes and function components with Hooks in a single
tree. Whether a component is a class or a function that uses Hooks is
an implementation detail of that component. In the longer term, we
expect Hooks to be the primary way people write React components.
const MyDiv = () => {
const [sampleState, setState] = useState('hello world');
render(){
return <div>{sampleState}</div>
}
}

You can use the react-universal-hooks library. It lets you use the "useXXX" functions within the render function of class-components.
It's worked great for me so far. The only issue is that since it doesn't use the official hooks, the values don't show react-devtools.
To get around this, I created an equivalent by wrapping the hooks, and having them store their data (using object-mutation to prevent re-renders) on component.state.hookValues. (you can access the component by auto-wrapping the component render functions, to run set currentCompBeingRendered = this)
For more info on this issue (and details on the workaround), see here: https://github.com/salvoravida/react-universal-hooks/issues/7

Stateful components or containers or class-based components ever support the functions of React Hooks, so we don't need to React Hooks in Stateful components just in stateless components.
Some additional informations
What are React Hooks?
So what are hooks? Well hooks are a new way or offer us a new way of writing our components.
Thus far, of course we have functional and class-based components, right? Functional components receive props and you return some JSX code that should be rendered to the screen.
They are great for presentation, so for rendering the UI part, not so much about the business logic and they are typically focused on one or a few purposes per component.
Class-based components on the other hand also will receive props but they also have this internal state. Therefore class-based components are the components which actually hold the majority of our business logic, so with business logic, I mean things like we make an HTTP request and we need to handle the response and to change the internal state of the app or maybe even without HTTP. A user fills out the form and we want to show this somewhere on the screen, we need state for this, we need class-based components for this and therefore we also typically use class based components to orchestrate our other components and pass our state down as props to functional components for example.
Now one problem we have with this separation, with all the benefits it adds but one problem we have is that converting from one component form to the other is annoying. It's not really difficult but it is annoying.
If you ever found yourself in a situation where you needed to convert a functional component into a class-based one, it's a lot of typing and a lot of typing of always the same things, so it's annoying.
A bigger problem in quotation marks is that lifecycle hooks can be hard to use right.
Obviously, it's not hard to add componentDidMount and execute some code in there but knowing which lifecycle hook to use, when and how to use it correctly, that can be challenging especially in more complex applications and anyways, wouldn't it be nice if we had one way of creating components and that super component could then handle both state and side effects like HTTP requests and also render the user interface?
Well, this is exactly what hooks are all about. Hooks give us a new way of creating functional components and that is important.

React Hooks let you use react features and lifecycle without writing a class.
It's like the equivalent version of the class component with much smaller and readable form factor. You should migrate to React hooks because it's fun to write it.
But you can't write react hooks inside a class component, as it's introduced for functional component.
This can be easily converted to :
class MyDiv extends React.component
constructor(){
this.state={sampleState:'hello world'}
}
render(){
return <div>{this.state.sampleState}
}
}
const MyDiv = () => {
const [sampleState, setSampleState] = useState('hello world');
return <div>{sampleState}</div>
}

It won't be possible with your existing class components. You'll have to convert your class component into a functional component and then do something on the lines of -
function MyDiv() {
const [sampleState, setSampleState] = useState('hello world');
return (
<div>{sampleState}</div>
)
}

For me React.createRef() was helpful.
ex.:
constructor(props) {
super(props);
this.myRef = React.createRef();
}
...
<FunctionComponent ref={this.myRef} />
Origin post here.

I've made a library for this. React Hookable Component.
Usage is very simple. Replace extends Component or extends PureComponent with extends HookableComponent or extends HookablePureComponent. You can then use hooks in the render() method.
import { HookableComponent } from 'react-hookable-component';
// 👇👇👇👇👇👇👇👇
class ComponentThatUsesHook extends HookableComponent<Props, State> {
render() {
// 👇👇👇👇👇👇
const value = useSomeHook();
return <span>The value is {value}</span>;
}
}

if you didn't need to change your class component then create another functional component and do hook stuff and import it to class component

Doesn't work anymore in modern React Versions. Took me forever, but finally resulted going back to go ol' callbacks. Only thing that worked for me, all other's threw the know React Hook Call (outside functional component) error.
Non-React or React Context:
class WhateverClass {
private xyzHook: (XyzHookContextI) | undefined
public setHookAccessor (xyzHook: XyzHookContextI): void {
this.xyzHook = xyzHook
}
executeHook (): void {
const hookResult = this.xyzHook?.specificHookFunction()
...
}
}
export const Whatever = new WhateverClass() // singleton
Your hook (or your wrapper for an external Hook)
export interface XyzHookContextI {
specificHookFunction: () => Promise<string>
}
const XyzHookContext = createContext<XyzHookContextI>(undefined as any)
export function useXyzHook (): XyzHookContextI {
return useContext(XyzHookContextI)
}
export function XyzHook (props: PropsWithChildren<{}>): JSX.Element | null {
async function specificHookFunction (): Promise<void> {
...
}
const context: XyzHookContextI = {
specificHookFunction
}
// and here comes the magic in wiring that hook up with the non function component context via callback
Whatever.setHookAccessor(context)
return (
< XyzHookContext.Provider value={context}>
{props.children}
</XyzHookContext.Provider>
)
}
Voila, now you can use ANY react code (via hook) from any other context (class components, vanilla-js, …)!
(…hope I didn't make to many name change mistakes :P)

Yes, but not directly.
Try react-iifc, more details in its readme.
https://github.com/EnixCoda/react-iifc

Try with-component-hooks:
https://github.com/bplok20010/with-component-hooks
import withComponentHooks from 'with-component-hooks';
class MyComponent extends React.Component {
render(){
const props = this.props;
const [counter, set] = React.useState(0);
//TODO...
}
}
export default withComponentHooks(MyComponent)
2.Try react-iifc： https://github.com/EnixCoda/react-iifc

Separating the logic and the render() function from a component

I would like to be able to have a component whose rendering function is in another file in order to have a separation between the logic of my component and the rendering.
Naively, I tried to do just one file containing my component and which rendered a functional component of the same name to which I passed the necessary props so that everything was displayed correctly.
Something like that :
// MyComponent.render.jsx
export default MyComponentRender = (props) => {
return {
<View>
// render all components of my view
</View>
}
}
// MyComponent.js
class MyComponent extends Component {
// some logic
render() {
return (
<MyComponentRender
aLotOfProps=....
/>
)
}
}
But I soon found myself having to send, sometimes, a fairly large amount of props and +, I have for example textInputs that need to be focus() or blur() in reaction to some logic in my view but as a result, I couldn't control that just by sending props. It quickly became a mess!
I was wondering if there was a simple way to separate the logic of a component and its rendering function? Maybe there is a way to pass the context of my component to my rendering function/component so that it has direct access to all states and can also store references, etc.?
Thanks you,
Viktor

React HOC returns an anonymous _class

I'm using MaterialUI, more specifically the TextField component which I want to decorate somehow to handle validation state at a component level.
I know about the HOC in react, which is a pattern that seems to be perfect for this. But I have to return an anonymous class and therefore I cannot get the value of the TextField component as I should, because the type returned is _class instead of TextField.
Am I doing something wrong with the HOC pattern, or perhaps this is not the best way to reuse a component without modifying its prototype. Any help would be greatly appreciated.
The HOC declaration
export default function hocInputValidator( WrappedComponent ){
return class extends Component{
constructor(props){
super(props);
}
handleChange(){
console.log('Handling from HOC');
}
render(){
return <WrappedComponent {...this.props}/>
}
}
}
The invocation and exporting of the decorated component
export default hocInputValidator(TextField);
When I try to access the decorated component via refs, the type is _class instead of TextField.

HOCs are used mainly for cross cutting of concerns for an example Login. Many components in your app may require Login functionality, hence you can wrap them with an HOC dynamically. An HOC will merely wrap whatever the component that is passed into it. In your case I figured out few issues in your code. I have fixed them below.
export default function ( WrappedComponent ){
class HocInputValidator extends Component{
constructor(props){
super(props);
}
handleChange(){
console.log('Handling from HOC');
}
render(){
return <WrappedComponent {...this.props}/>
}
}
return HocInputValidator;
}
The invocation should be something like this.
import inputValidator from './components/input_validator';
inputvalidator(TextField);

Your HOC returns an anonymous class which is why it's being displayed as _class.
To work around this you can set the HOC's displayName to something descriptive which will override the _class display behaviour.
For instance, you can display the HOC as something like HigherOrderComponent(WrappedComponent) in the DOM which is more descriptive (and easier to debug). It's a convention followed by other libraries such as react-redux.

In reactjs how can I call a method from another component?

Just trying reactjs and came across the situation that I want to call a method on another component:
class MyComp extends React.Component {
callMe(){
...
}
}
So mycomp2:
import MyComp from 'myComp';
class MyComp2 extends React.Component {
test(){
MyComp.callMe();
}
}
How can I do this ?

If the method callMe doesn't use this, you can declear it as static to use it like that.
class MyComp extends React.Component {
static callMe(){
...
}
}
If not, you can use ref to make it work.
You may need:
https://facebook.github.io/react/docs/refs-and-the-dom.html

Cannot. You cannot do that in react component. The only way is to move that function to their common ancestor.
Of course, there is another way, why not consider redux? let's react component talk through redux state. that way, you will never have this puzzle.

It depends on how your components are related to one another. If one is a parent and the other is a child then the function can be passed as a prop from parent to child, e.g.
class Parent extends React.Component {
callMe() {
console.log('called');
}
render() {
return (
<Child doSomething={() => this.callMe()} />
);
}
}
class Child extends React.Component {
render() {
<button onClick={this.props.doSomething}>Calls the parent fn</button>
}
}
Alternatively if they are not a parent-child relationship, then you need to introduce a parent component in which the function can live, then pass it via props in the same way.
If neither of these approaches seems to fit, then let us know what behaviour you are trying to achieve that requires this, and there my well be a different way to structure your code.

Calling dynamic component in React JS

I am new in react JS. I am calling a react component from a HTML string which is coming from another javascript class. But the component is not rendering on the screen.
class Form extends Component {
render() {
var markup = '<Sections />';
return (<div className="content" dangerouslySetInnerHTML={{__html: markup}}></div>);
}
}
class Sections extends Component{
render(){
return (<div className='row'>Row1</div>);
}
}
Please help me where am i going wrong.
I think the reactjs is not recognizing the sections component as it is coming from the string. Is there any way, we can manually compile the jsx.

Remember that JSX isn't the same as HTML. When you write something like <Sections /> you are in fact writing React.createElement(Sections, null).
If you have "<Sections />" as a string and you want to resolve it to a call to React.createElement then you need to parse it as JSX. However, this happens at compile-time (not run-time) which would prevent you from using dynamic components.
If you want to work with a dynamic component, then your builder method must return a component class or a component instance.
function getDynamicComponent() {
return Sections;
}
function render() {
const Component = getDynamicComponent();
return <Component />;
}
// or
function getDynamicComponentInstance() {
return <Sections />;
}
function render() {
const component = getDynamicComponentInstance();
return component;
}
The only way to infer the correct component from "<Sections />" is to parse it manually and use eval to resolve the name to the appropriate variable. Parsing JSX is non-trivial and using eval is likely to open you up to a whole class of security vulnerabilities.
Unless your dynamic component name is coming from over the network, or from inside a separate worker, there's no reason why the function which returns your dynamic component can't be written like the example above.