Why You Should Use Functional Components & Hooks in ReactJS
By hientd, at: Sept. 16, 2024, 5:43 p.m.
Why You Should Use Functional Components & Hooks in ReactJS
Recent years, React development has shifted significantly towards functional components and hooks. If you're still using class components in your projects, it's time to rethink your approach. Functional components paired with hooks make your code simpler, cleaner, and more efficient.
In this post, we’ll explore the benefits of functional components and hooks using a consistent example to illustrate how you can upgrade your React development process.
What Are Functional Components?
Functional components are just JavaScript functions that return JSX, which React uses to render elements on the screen. Unlike class components, functional components are more straightforward and don't have unnecessary overhead like lifecycle methods or the this keyword.
A quick comparison between the two approaches:
Class Component:
class SimpleComponent extends React.Component {
render() {
return < div >Welcome to the Glinteco! < / div >;
}
}
Functional Component:
const MyComponent = () => {
return < div >Welcome to the Glinteco!< / div >;
};
As you can see, the functional component is cleaner and easier to write. This makes it ideal for simple components where you don’t need to manage state or lifecycle events.
Why You Should Use Functional Components
1. Simpler and More Readable Code
One of the main reasons for switching to functional components is simplicity. Functional components are more concise, and they remove the need to manage this or lifecycle methods. This makes the code easier to follow and maintain.
Imagine you want to build a counter component. Here’s how it would look using functional components:
const Counter = () => {
return (
< div >
< p >You clicked 0 times
< button >Click me < / button >
< / div >
);
};
This component is already easier to understand than the class-based version, and we haven’t even added any logic yet.
2. Less Boilerplate
With functional components, you can avoid writing unnecessary code like the constructor, lifecycle methods, and this. This means less code to write, easy to maintain.
Let’s add some functionality to the counter using class components vs. functional components. Here's the class-based version:
class Counter extends React.Component {
constructor(props) {
super(props);
this.state = { count: 0 };
}
render() {
return (
< div >
< p >You clicked {this.state.count} times
< button onClick={() => this.setState({ count: this.state.count + 1 })}>
Click me
< /button >
< / div >
);
}
}
Compare that with the functional version using hooks:
import { useState } from 'react';
const Counter = () => {
const [count, setCount] = useState(0);
return (
< div >
< p >You clicked {count} times
< button onClick={() => setCount(count + 1)}>Click me
< / button >
< / div >
);
};
In the functional component, there’s less boilerplate, and the state logic is easier to follow with hooks like useState.
Introducing Hooks: What Makes Them Powerful
Before React introduced hooks, functional components couldn't manage state or perform side effects. Hooks changed that, allowing functional components to do everything class components can do—but in a more flexible and reusable way.
Let’s look at two common hooks: useState and useEffect.
1. Managing State with useState
In the example above, we used the useState hook to manage the count state. Hooks allow you to manage state directly within functional components, making it easier to add stateful behavior without switching to class components.
const [count, setCount] = useState(0)
The useState hook returns two values: the current state (count) and a function to update that state (setCount). You can use this hook as many times as needed within a single component.
2. Handling Side Effects with useEffect
Hooks also allow you to handle side effects like data fetching or DOM manipulation. This is done using the useEffect hook. For instance, let’s update the document title whenever the count changes:
import { useEffect } from 'react';
const Counter = () => {
const [count, setCount] = useState(0);
useEffect(() => {
document.title = `You clicked ${count} times`;
}, [count]);
return (
< div >
< p >You clicked {count} times
< button onClick={() => setCount(count + 1)}>Click me < / button >
< / div >
);
};
In this example, useEffect is triggered every time count changes, and it updates the document title accordingly. The second argument [count] ensures that the effect only runs when count updates.
Benefits of Using Functional Components and Hooks
1. Reusable Logic with Custom Hooks
One of the most powerful aspects of hooks is the ability to create custom hooks that encapsulate logic and can be reused across multiple components. This makes your code more modular and easier to maintain. For example, you could create a custom hook to handle a timer or fetch data from an API.
2. Easier to Test
Functional components are just JavaScript functions, so they are easier to test. There’s no need to worry about class methods or managing this. You can simply test the output of your component and verify the behavior of hooks.
3. Better Performance
Since functional components don’t have the overhead of managing lifecycle methods like class components do, they tend to perform better. Hooks give you more control over how and when components update, which can lead to fewer unnecessary renders and better optimization.
4. Future-Proof Your Code
The React team has been moving toward functional components and hooks as the default approach. Class components are still supported, but hooks represent the future of React. By adopting them now, you ensure that your code will remain modern and easier to upgrade as React continues to evolve.
Conclusion
Functional components and hooks are the future of React development. They simplify your code, make it easier to manage state and side effects, and offer better performance and reusability. By switching to functional components, you'll not only write more maintainable code but also future-proof your applications for upcoming React features.
If you haven’t already, it’s time to start refactoring those class components and embrace the power of hooks!
