Htykuut

Instead of writing my components inside a class, since they are dumb, I mostly write these inside a function.

But how do I override componentDidMount, componentWillMount inside functional components? Is it even possible?

const grid = (props) => {

    console.log(props);

    let {skuRules} = props;



    const componentDidMount = () => {

        if(!props.fetched) {

            props.fetchRules();

        }

        console.log('mount it!');

    };

    return(

        <Content title="Promotions" breadcrumbs={breadcrumbs} fetched={skuRules.fetched}>

            <Box title="Sku Promotion">

                <ActionButtons buttons={actionButtons} />

                <SkuRuleGrid 

                    data={skuRules.payload}

                    fetch={props.fetchSkuRules}

                />

            </Box>      

        </Content>  

    )

}

You can use react-pure-lifecycle to add lifecycle functions to functional components.

Example:

import React, { Component } from 'react';

import lifecycle from 'react-pure-lifecycle';



const methods = {

  componentDidMount(props) {

    console.log('I mounted! Here are my props: ', props);

  }

};



const Channels = props => (

<h1>Hello</h1>

)



export default lifecycle(methods)(Channels);

Edit: With the introduction of Hooks its possible to implement lifecycle kind of behaviour as well as state in functional Component. Currently

Hooks are a new feature proposal that lets you use state and other
React features without writing a class. They’re currently in React
v16.7.0-alpha

useEffect hook can be used to replicate lifecycle behaviour, and useState can be used to store state in a functional component.

You can implement your use case in hooks like

const grid = (props) => {

    console.log(props);

    let {skuRules} = props;



    useEffect(() => {

        if(!props.fetched) {

            props.fetchRules();

        }

        console.log('mount it!');

    }, ); // passing an empty array as second argument triggers the callback in useEffect only after the initial render thus replicating `componentDidMount` lifecycle behaviour



    return(

        <Content title="Promotions" breadcrumbs={breadcrumbs} fetched={skuRules.fetched}>

            <Box title="Sku Promotion">

                <ActionButtons buttons={actionButtons} />

                <SkuRuleGrid 

                    data={skuRules.payload}

                    fetch={props.fetchSkuRules}

                />

            </Box>      

        </Content>  

    )

}

useEffect can also return a function that will be run when the component is unmounted. This can be used to unsubscribe to listeners. An can be used to replicate the componentWillUnmount behaviour

Eg: componentWillUnmount

useEffect(() => {

    window.addEventListener('unhandledRejection', handler);

    return () => {

       window.removeEventListener('unhandledRejection', handler);

    }

}, )

As the second argument if you provide values, these will be compared before triggering the callback if these is any change in any of the following

Eg: componentDidUpdate

componentDidUpdate(prevProps, prevState) {

     const { counter } = this.props;

     if (this.props.counter !== nextProps.counter) {

      // some action here

     }

}

Hooks Equivalent

useEffect(() => {

     // action here

}, [props.counter]);

Before v16.7.0

The property of functional components is that they don't have access to Reacts lifecycle functions or the this keyword. You need to extend the React.Component class if you want to use the lifecycle function.

class Grid extends React.Component  {

    constructor(props) {

       super(props)

    }



    componentDidMount () {

        if(!this.props.fetched) {

            this.props.fetchRules();

        }

        console.log('mount it!');

    }

    render() {

    return(

        <Content title="Promotions" breadcrumbs={breadcrumbs} fetched={skuRules.fetched}>

            <Box title="Sku Promotion">

                <ActionButtons buttons={actionButtons} />

                <SkuRuleGrid 

                    data={skuRules.payload}

                    fetch={props.fetchSkuRules}

                />

            </Box>      

        </Content>  

    )

  }

}

Functional components are useful when you only want to render your Component without the need of extra logic.

Solution One:
You can use new react HOOKS API. Currently in React v16.7.0-alpha

Hooks let you use more of React’s features without classes.
Hooks provide a more direct API to the React concepts you already know: props, state, context, refs, and lifecycle.
Hooks solves all the problems addressed with Recompose.

A Note from the Author of recompose (acdlite, Oct 25 2018):

Hi! I created Recompose about three years ago. About a year after
that, I joined the React team. Today, we announced a proposal for
Hooks. Hooks solves all the problems I attempted to address with
Recompose three years ago, and more on top of that. I will be
discontinuing active maintenance of this package (excluding perhaps
bugfixes or patches for compatibility with future React releases), and
recommending that people use Hooks instead. Your existing code with
Recompose will still work, just don't expect any new features.

Solution Two:

If you are using react version that does not support hooks, no worries, use recompose(A React utility belt for function components and higher-order components.) instead. You can use recompose for attaching lifecycle hooks, state, handlers etc to a functional component.

Here’s a render-less component that attaches lifecycle methods via the lifecycle HOC (from recompose).

// taken from https://gist.github.com/tsnieman/056af4bb9e87748c514d#file-auth-js-L33



function RenderlessComponent() {

  return null; 

}



export default lifecycle({



  componentDidMount() {

    const { checkIfAuthed } = this.props;

    // Do they have an active session? ("Remember me")

    checkIfAuthed();

  },



  componentWillReceiveProps(nextProps) {

    const {

      loadUser,

    } = this.props;



    // Various 'indicators'..

    const becameAuthed = (!(this.props.auth) && nextProps.auth);

    const isCurrentUser = (this.props.currentUser !== null);



    if (becameAuthed) {

      loadUser(nextProps.auth.uid);

    }



    const shouldSetCurrentUser = (!isCurrentUser && nextProps.auth);

    if (shouldSetCurrentUser) {

      const currentUser = nextProps.users[nextProps.auth.uid];

      if (currentUser) {

        this.props.setCurrentUser({

          'id': nextProps.auth.uid,

          ...currentUser,

        });

      }

    }

  }

})(RenderlessComponent);

If you need use React LifeCycle, you need use Class.

Sample:

import React, { Component } from 'react';



class Grid extends Component {



 constructor(props){

  super(props)

 }



 componentDidMount () { /* do something */ }



 render () { 

   return <h1>Hello</h1>

 }



}