{"componentChunkName":"component---src-templates-docs-js","path":"/docs/hooks-rules.html","result":{"data":{"markdownRemark":{"html":"
\n
\n

These docs are old and won’t be updated. Go to react.dev for the new React docs.

\n

These new documentation pages teach modern React and include live examples:

\n\n
\n
\n

Hooks are a new addition in React 16.8. They let you use state and other React features without writing a class.

\n

Hooks are JavaScript functions, but you need to follow two rules when using them. We provide a linter plugin to enforce these rules automatically:

\n

Only Call Hooks at the Top Level

\n

Don’t call Hooks inside loops, conditions, or nested functions. Instead, always use Hooks at the top level of your React function, before any early returns. By following this rule, you ensure that Hooks are called in the same order each time a component renders. That’s what allows React to correctly preserve the state of Hooks between multiple useState and useEffect calls. (If you’re curious, we’ll explain this in depth below.)

\n

Only Call Hooks from React Functions

\n

Don’t call Hooks from regular JavaScript functions. Instead, you can:

\n\n

By following this rule, you ensure that all stateful logic in a component is clearly visible from its source code.

\n

ESLint Plugin

\n

We released an ESLint plugin called eslint-plugin-react-hooks that enforces these two rules. You can add this plugin to your project if you’d like to try it:

\n

This plugin is included by default in Create React App.

\n
npm install eslint-plugin-react-hooks --save-dev
\n
// Your ESLint configuration\n{\n  \"plugins\": [\n    // ...\n    \"react-hooks\"\n  ],\n  \"rules\": {\n    // ...\n    \"react-hooks/rules-of-hooks\": \"error\", // Checks rules of Hooks\n    \"react-hooks/exhaustive-deps\": \"warn\" // Checks effect dependencies\n  }\n}
\n

You can skip to the next page explaining how to write your own Hooks now. On this page, we’ll continue by explaining the reasoning behind these rules.

\n

Explanation

\n

As we learned earlier, we can use multiple State or Effect Hooks in a single component:

\n
function Form() {\n  // 1. Use the name state variable\n  const [name, setName] = useState('Mary');\n\n  // 2. Use an effect for persisting the form\n  useEffect(function persistForm() {\n    localStorage.setItem('formData', name);\n  });\n\n  // 3. Use the surname state variable\n  const [surname, setSurname] = useState('Poppins');\n\n  // 4. Use an effect for updating the title\n  useEffect(function updateTitle() {\n    document.title = name + ' ' + surname;\n  });\n\n  // ...\n}
\n

So how does React know which state corresponds to which useState call? The answer is that React relies on the order in which Hooks are called. Our example works because the order of the Hook calls is the same on every render:

\n
// ------------\n// First render\n// ------------\nuseState('Mary')           // 1. Initialize the name state variable with 'Mary'\nuseEffect(persistForm)     // 2. Add an effect for persisting the form\nuseState('Poppins')        // 3. Initialize the surname state variable with 'Poppins'\nuseEffect(updateTitle)     // 4. Add an effect for updating the title\n\n// -------------\n// Second render\n// -------------\nuseState('Mary')           // 1. Read the name state variable (argument is ignored)\nuseEffect(persistForm)     // 2. Replace the effect for persisting the form\nuseState('Poppins')        // 3. Read the surname state variable (argument is ignored)\nuseEffect(updateTitle)     // 4. Replace the effect for updating the title\n\n// ...
\n

As long as the order of the Hook calls is the same between renders, React can associate some local state with each of them. But what happens if we put a Hook call (for example, the persistForm effect) inside a condition?

\n
  // 🔴 We're breaking the first rule by using a Hook in a condition\n  if (name !== '') {\n    useEffect(function persistForm() {\n      localStorage.setItem('formData', name);\n    });\n  }
\n

The name !== '' condition is true on the first render, so we run this Hook. However, on the next render the user might clear the form, making the condition false. Now that we skip this Hook during rendering, the order of the Hook calls becomes different:

\n
useState('Mary')           // 1. Read the name state variable (argument is ignored)\n// useEffect(persistForm)  // 🔴 This Hook was skipped!\nuseState('Poppins')        // 🔴 2 (but was 3). Fail to read the surname state variable\nuseEffect(updateTitle)     // 🔴 3 (but was 4). Fail to replace the effect
\n

React wouldn’t know what to return for the second useState Hook call. React expected that the second Hook call in this component corresponds to the persistForm effect, just like during the previous render, but it doesn’t anymore. From that point, every next Hook call after the one we skipped would also shift by one, leading to bugs.

\n

This is why Hooks must be called on the top level of our components. If we want to run an effect conditionally, we can put that condition inside our Hook:

\n
  useEffect(function persistForm() {\n    // 👍 We're not breaking the first rule anymore\n    if (name !== '') {\n      localStorage.setItem('formData', name);\n    }\n  });
\n

Note that you don’t need to worry about this problem if you use the provided lint rule. But now you also know why Hooks work this way, and which issues the rule is preventing.

\n

Next Steps

\n

Finally, we’re ready to learn about writing your own Hooks! Custom Hooks let you combine Hooks provided by React into your own abstractions, and reuse common stateful logic between different components.

","frontmatter":{"title":"Rules of Hooks","next":"hooks-custom.html","prev":"hooks-effect.html"},"fields":{"path":"content/docs/hooks-rules.md","slug":"docs/hooks-rules.html"}}},"pageContext":{"slug":"docs/hooks-rules.html"}},"staticQueryHashes":[]}