Transitioning from React class components to function components with hooks
Tags: react
Published: 2020-03-11 02:09:51

---
title: Transitioning from React class components to function components with hooks
published: true
date: 2020-03-10 23:53:50 UTC
tags: react 
canonical_url: https://labs.thisdot.co/blog/transitioning-from-react-class-components-to-function-components-with-hooks
---

It has been approximately one year since React v16.8 was released, marking the introduction of Hooks. Yet, there are still people used to React class components who still haven't experienced the full potential of this new feature, along with functional components, including myself. The aim of this article is to summarize and encompass the most distinguishable features of the class components, and respectively show their alternatives when using React hooks.

## Functional components

Before we start with Hooks examples, we will shortly discuss functional components in case you aren't familiar. They provide an easy way to create new units without the need of creating a new class and extending `React.Component`.

**Note:** Keep in mind that functional components have been part of React since it's creation.

Here is a very simple example of a functional component:

```
const Element = () => (
  <div className="element">
    My Element
  </div>
);
```

And just like class components, we can access the properties. They are provided as the first argument of the function.

```
const Element = ({ text }) => (
  <div className="element">
    {text}
  </div>
);
```

However, these type of components--while very convenient for simple UI elements--used to be very limited in terms of life cycle control, and usage of state. This is the main reason they had been neglected until React v16.8.

## Component state

Let's take a look at the familiar way of how we add state to our object-oriented components. The example will represent a component which renders a space scene with stars; they have the same color. We are going to use few utility functions for both functional and class components.

- `createStars(width: number): Star[]` - Creates an array with the star objects that are ready for rendering. The number of stars depends on the window width.
- `renderStars(stars: Star[], color: string): JSX.Element` - Builds and returns the actual stars markup.
- `logColorChange(color: string)` - Logs when the color of the space has been changed.

and some less important like `calculateDistancesAmongStars(stars: Star[]): Object`.

We won't implement these. Consider them as black boxes. The names should be sufficient enough to understand their purpose.

**Note:** You may find a lot of demonstrated things unnecesary. The main reason I included this is to showcase the hooks in a single component.

And the example:

### Class components

```
class Space extends React.Component {
  constructor(props) {
    super(props);

    this.state = {
      stars: createStars(window.innerWidth)
    };
  }

  render() {
    return (
      <div className="space">
        {renderStars(this.state.stars, this.props.color)}
      </div>
    );
  }
}
```

### Functional components

The same can be achieved with the help of the first React Hook that we are going to introduce--`useState`. The usage is as follows: `const [name, setName] = useState(INITIAL_VALUE)`. As you can see, it uses array destructuring in order to provide the value and the set function:

```
const Space = ({ color }) => {
  const [stars, setStars] = useState(createStars(window.innerWidth));

  return (
    <div className="space">
      {renderStars(stars, color)}
    </div>
  );
};
```

The usage of the property is trivial, while `setStars(stars)` will be equivalent to `this.setState({ stars })`.

## Component initialization

Another prominent limitation of functional components was the inability to hook to lifecycle events. Unlike class components, where you could simply define the `componentDidMount` method, if you want to execute code on component creation, you can't hook to lifecycle events. Let's extend our demo by adding a resize listener to `window` which will change the number of rendered stars in our space when the user changes the width of the browser:

### Class components

```
class Space extends React.Component {
  constructor(props) { ... }

  componentDidMount() {
    window.addEventListener('resize', () => {
      const stars = createStars(window.innerWidth, this.props.color);
      this.setState({ stars });
    });
  }

  render() { ... }
}
```

### Functional components

You may say: "We can attach the listener right above the return statement", and you will be partially correct. However, think about the functional component as the `render` method of a class component. Would you attach the event listener there? No. Just like `render`, the function of a functional component could be executed multiple times throughout the the lifecycle of the instance. This is why we are going to use the `useEffect` hook.

It is a bit different from `componentDidMount` though--it incorporates `componentDidUpdate`, and `componentDidUnmount` as well. In other words, the provided callback to `useEffect` is executed on every update. Anyhow, you can have certain control with the second argument of `useState` - it represents an array with the values/dependencies which are monitored for change. If they do, the hook is executed. In case the array is empty, the hook will be executed only once, during initialization, since after that there won't be any values to be observed for change.

```
const Space = ({ color }) => {
  const [stars, setStars] = useState(createStars(window.innerWidth));

  useEffect(() => {
    window.addEventListener('resize', () => {
      const stars = createStars(window.innerWidth, color);
      setStars(stars);
    });
  }, []); // <-- Note the empty array

  return (
    ...
  );
};
```

## Component destruction

We added an event listener to `window`, so we will have to remove it on component unmount in order to save us from memory leaks. Respectively, that'll require keeping a reference to the callback:

### Class components

```
class Space extends React.Component {
  constructor(props) { ... }

  componentDidMount() {
    window.addEventListener('resize', this.__resizeListenerCb = () => {
      const stars = createStars(window.innerWidth, this.props.color);
      this.setState({ stars });
    });
  }

  componentDidUnmount() {
    window.removeEventListener('resize', this.__resizeListenerCb);
  }

  render() { ... }
}
```

### Functional component

For the equivalent version of the class component, the `useEffect` hook will execute the returned function from the provided callback when the component is about to be destroyed. Here's the code:

```
const Space = ({ color }) => {
  const [stars, setStars] = useState(createStars(window.innerWidth));

  useEffect(() => {
    let resizeListenerCb;

    window.addEventListener('resize', resizeListenerCb = () => {
      const stars = createStars(window.innerWidth, color);
      setStars(stars);
    });

    return () => window.removeEventListener('resize', resizeListenerCb);
  }, []); // <-- Note the empty array

  return (
    ...
  );
};
```

#### An important remark

It is worth mentioning that, when you work with event listeners or any other methods that defer the execution in the future of a callback/function, you should take into account that the state provided to them is not mutable.

Taking the `window` listener we use in our demo as an example; if we used the`stars` state inside the callback, we would get the exact value at the moment of the definition (callback), which means that, when the callback is executed, we risk having a stale state.

There are various ways to handle that, one of which is to re-register the listener every time the stars are changed, by providing the `stars` value to the observed dependency array of `useEffect`.

## Changed properties

We already went through `useEffect` in the sections above. Now, we will briefly show an example of `componentDidUpdate`. Let's say that we want to log the occurances of color change to the console:

### Class components

```
class Space extends React.Component {
  ...

  componentDidUpdate(prevProps) {
    if (this.props.color !== prevProps.color) {
      logColorChange(this.props.color);
    }
  }

  ...
}
```

### Functional components

We'll introduce another `useEffect` hook:

```
const Space = ({ color }) => {
  ...

  useEffect(() => {
    logColorChange(color);
  }, [color]); // <-- Note that this time we add `color` as observed dependency

  ...
};
```

Simple as that!

#### Changed properties and memoization

Just as an addition to the example above, we will quickly showcase `useMemo`; it provides an easy way to optimize your component when you have to perform a heavy calculation only when certain dependencies change:

```
const result = useMemo(() => expensiveCalculation(), [color]);
```

## References

Due to the nature of functional components, it becomes hard to keep a reference to an object between renders. With class components, we can simply save one with a class property, like:

```
class Space extends React.Component {
  ...

  methodThatIsCalledOnceInALifetime() {
    this.__distRef = calculateDistancesAmongStars(this.state.stars);
  }

  ...
}
```

However, here is an example with a functional component that might look correct but it isn't:

```
const Space = ({ color }) => {
  ...

  let distRef; // Declared on every render.

  function thatIsCalledOnceInALifetime() {
    distRef = caclulateDistancesAmongStars(stars);
  }

  ...
};
```

As you can see, we won't be able to preserve the output object with a simple variable. In order to do that, we will take a look at yet another hook named `useRef`, which will solve our problem:

```
const Space = ({ color }) => {
  ...
  const distRef = useRef();

  function thatIsCalledOnceInALifetime() {
    // `current` keeps the same reference
    // throughout the lifetime of the component instance
    distRef.current = caclulateDistancesAmongStars(stars);
  }

  ...
}
```

The same hook is used when we want to keep a reference to a DOM element.

## Conclusion

Hopefully this should give you a starting point when it comes to using React Hooks for the things that you are already used to doing with class components. Obviously, there are more hooks to explore, including the definition of custom ones. For all of that, you can head to the official docs. Give them a try and experience the potential of functional React!