\\n );\\n}\\n\\nThis snippet is based on the counter example from the previous page, but we added a new feature to it: we set the document title to a custom message including the number of clicks.\\n\\nData fetching, setting up a subscription, and manually changing the DOM in React components are all examples of side effects. Whether or not you're used to calling these operations \\\"side effects\\\" (or just \\\"effects\\\"), you've likely performed them in your components before.\\n\\nTip\\n\\nIf you're familiar with React class lifecycle methods, you can think of useEffect Hook as componentDidMount, componentDidUpdate, and componentWillUnmount combined.\\n\\nThere are two common kinds of side effects in React components: those that don't require cleanup, and those that do. Let's look at this distinction in more detail.\\n\\nEffects Without Cleanup\\n\\nSometimes, we want to run some additional code after React has updated the DOM. Network requests, manual DOM mutations, and logging are common examples of effects that don't require a cleanup. We say that because we can run them and immediately forget about them. Let's compare how classes and Hooks let us express such side effects.\\n\\nExample Using Classes\\n\\nIn React class components, the render method itself shouldn't cause side effects. It would be too early — we typically want to perform our effects after React has updated the DOM.\\n\\nThis is why in React classes, we put side effects into componentDidMount and componentDidUpdate. Coming back to our example, here is a React counter class component that updates the document title right after React makes changes to the DOM:\\n\\nclass Example extends React.Component {\\n constructor(props) {\\n super(props);\\n this.state = {\\n count: 0\\n };\\n }\\n\\n componentDidMount() {\\n document.title = `You clicked ${this.state.count} times`;\\n }\\n componentDidUpdate() {\\n document.title = `You clicked ${this.state.count} times`;\\n }\\n\\n render() {\\n return (\\n
\\n
You clicked {this.state.count} times
\\n \\n
\\n );\\n }\\n}\\n\\nNote how we have to duplicate the code between these two lifecycle methods in class.\\n\\nThis is because in many cases we want to perform the same side effect regardless of whether the component just mounted, or if it has been updated. Conceptually, we want it to happen after every render — but React class components don't have a method like this. We could extract a separate method but we would still have to call it in two places.\\n\\nNow let's see how we can do the same with the useEffect Hook.\\n\\nExample Using Hooks\\n\\nWe've already seen this example at the top of this page, but let's take a closer look at it:\\n\\nimport React, { useState, useEffect } from 'react';\\nfunction Example() {\\n const [count, setCount] = useState(0);\\n\\n useEffect(() => {\\n document.title = `You clicked ${count} times`;\\n });\\n return (\\n
\\n
You clicked {count} times
\\n \\n
\\n );\\n}\\n\\nWhat does useEffect do? By using this Hook, you tell React that your component needs to do something after render. React will remember the function you passed (we'll refer to it as our \\\"effect\\\"), and call it later after performing the DOM updates. In this effect, we set the document title, but we could also perform data fetching or call some other imperative API.\\n\\nWhy is useEffect called inside a component? Placing useEffect inside the component lets us access the count state variable (or any props) right from the effect. We don't need a special API to read it — it's already in the function scope. Hooks embrace JavaScript closures and avoid introducing React-specific APIs where JavaScript already provides a solution.\\n\\nDoes useEffect run after every render? Yes! By default, it runs both after the first render and after every update. (We will later talk about how to customize this.) Instead of thinking in terms of \\\"mounting\\\" and \\\"updating\\\", you might find it easier to think that effects happen \\\"after render\\\". React guarantees the DOM has been updated by the time it runs the effects.\\n\\nDetailed Explanation\\n\\nNow that we know more about effects, these lines should make sense:\\n\\nfunction Example() {\\n const [count, setCount] = useState(0);\\n\\n useEffect(() => {\\n document.title = `You clicked ${count} times`;\\n });\\n}\\n\\nWe declare the count state variable, and then we tell React we need to use an effect. We pass a function to the useEffect Hook. This function we pass is our effect. Inside our effect, we set the document title using the document.title browser API. We can read the latest count inside the effect because it's in the scope of our function. When React renders our component, it will remember the effect we used, and then run our effect after updating the DOM. This happens for every render, including the first one.\\n\\nExperienced JavaScript developers might notice that the function passed to useEffect is going to be different on every render. This is intentional. In fact, this is what lets us read the count value from inside the effect without worrying about it getting stale. Every time we re-render, we schedule a different effect, replacing the previous one. In a way, this makes the effects behave more like a part of the render result — each effect \\\"belongs\\\" to a particular render. We will see more clearly why this is useful later on this page.\\n\\nTip\\n\\nUnlike componentDidMount or componentDidUpdate, effects scheduled with useEffect don't block the browser from updating the screen. This makes your app feel more responsive. The majority of effects don't need to happen synchronously. In the uncommon cases where they do (such as measuring the layout), there is a separate useLayoutEffect Hook with an API identical to useEffect.\\n\\nEffects with Cleanup\\n\\nEarlier, we looked at how to express side effects that don't require any cleanup. However, some effects do. For example, we might want to set up a subscription to some external data source. In that case, it is important to clean up so that we don't introduce a memory leak! Let's compare how we can do it with classes and with Hooks.\\n\\nExample Using Classes\\n\\nIn a React class, you would typically set up a subscription in componentDidMount, and clean it up in componentWillUnmount. For example, let's say we have a ChatAPI module that lets us subscribe to a friend's online status. Here's how we might subscribe and display that status using a class:\\n\\nclass FriendStatus extends React.Component {\\n constructor(props) {\\n super(props);\\n this.state = { isOnline: null };\\n this.handleStatusChange = this.handleStatusChange.bind(this);\\n }\\n\\n componentDidMount() {\\n ChatAPI.subscribeToFriendStatus(\\n this.props.friend.id,\\n this.handleStatusChange\\n );\\n }\\n componentWillUnmount() {\\n ChatAPI.unsubscribeFromFriendStatus(\\n this.props.friend.id,\\n this.handleStatusChange\\n );\\n }\\n handleStatusChange(status) {\\n this.setState({\\n isOnline: status.isOnline\\n });\\n }\\n\\n render() {\\n if (this.state.isOnline === null) {\\n return 'Loading...';\\n }\\n return this.state.isOnline ? 'Online' : 'Offline';\\n }\\n}\\n\\nNotice how componentDidMount and componentWillUnmount need to mirror each other. Lifecycle methods force us to split this logic even though conceptually code in both of them is related to the same effect.\\n\\nNote\\n\\nEagle-eyed readers may notice that this example also needs a componentDidUpdate method to be fully correct. We'll ignore this for now but will come back to it in a later section of this page.\\n\\nExample Using Hooks\\n\\nLet's see how we could write this component with Hooks.\\n\\nYou might be thinking that we'd need a separate effect to perform the cleanup. But code for adding and removing a subscription is so tightly related that useEffect is designed to keep it together. If your effect returns a function, React will run it when it is time to clean up:\\n\\nimport React, { useState, useEffect } from 'react';\\n\\nfunction FriendStatus(props) {\\n const [isOnline, setIsOnline] = useState(null);\\n\\n useEffect(() => {\\n function handleStatusChange(status) {\\n setIsOnline(status.isOnline);\\n }\\n ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);\\n return function cleanup() {\\n ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);\\n };\\n });\\n\\n if (isOnline === null) {\\n return 'Loading...';\\n }\\n return isOnline ? 'Online' : 'Offline';\\n}\\n\\nWhy did we return a function from our effect? This is the optional cleanup mechanism for effects. Every effect may return a function that cleans up after it. This lets us keep the logic for adding and removing subscriptions close to each other. They're part of the same effect!\\n\\nWhen exactly does React clean up an effect? React performs the cleanup when the component unmounts. However, as we learned earlier, effects run for every render and not just once. This is why React also cleans up effects from the previous render before running the effects next time. We'll discuss why this helps avoid bugs and how to opt out of this behavior in case it creates performance issues later below.\\n\\nNote\\n\\nWe don't have to return a named function from the effect. We called it cleanup here to clarify its purpose, but you could return an arrow function or call it something different.\\n\\nRecap\\n\\nWe've learned that useEffect lets us express different kinds of side effects after a component renders. Some effects might require cleanup so they return a function:\\n\\nuseEffect(() => {\\n function handleStatusChange(status) {\\n setIsOnline(status.isOnline);\\n }\\n\\n ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);\\n return () => {\\n ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);\\n };\\n});\\n\\nOther effects might not have a cleanup phase, and don't return anything.\\n\\nuseEffect(() => {\\n document.title = `You clicked ${count} times`;\\n});\\n\\nThe Effect Hook unifies both use cases with a single API.\\n\\nIf you feel like you have a decent grasp on how the Effect Hook works, or if you feel overwhelmed, you can jump to the next page about Rules of Hooks now.\\n\\nTips for Using Effects\\n\\nWe'll continue this page with an in-depth look at some aspects of useEffect that experienced React users will likely be curious about. Don't feel obligated to dig into them now. You can always come back to this page to learn more details about the Effect Hook.\\n\\nTip: Use Multiple Effects to Separate Concerns\\n\\nOne of the problems we outlined in the Motivation for Hooks is that class lifecycle methods often contain unrelated logic, but related logic gets broken up into several methods. Here is a component that combines the counter and the friend status indicator logic from the previous examples:\\n\\nclass FriendStatusWithCounter extends React.Component {\\n constructor(props) {\\n super(props);\\n this.state = { count: 0, isOnline: null };\\n this.handleStatusChange = this.handleStatusChange.bind(this);\\n }\\n\\n componentDidMount() {\\n document.title = `You clicked ${this.state.count} times`;\\n ChatAPI.subscribeToFriendStatus(\\n this.props.friend.id,\\n this.handleStatusChange\\n );\\n }\\n\\n componentDidUpdate() {\\n document.title = `You clicked ${this.state.count} times`;\\n }\\n\\n componentWillUnmount() {\\n ChatAPI.unsubscribeFromFriendStatus(\\n this.props.friend.id,\\n this.handleStatusChange\\n );\\n }\\n\\n handleStatusChange(status) {\\n this.setState({\\n isOnline: status.isOnline\\n });\\n }\\n\\n render() {\\n return (\\n