# State: A Component's Memory

Components often need to change what’s on the screen as a result of an interaction. Typing into the form should update the input field, clicking “next” on an image carousel should change which image is displayed, clicking “buy” should put a product in the shopping cart. Components need to “remember” things: the current input value, the current image, the shopping cart. In React, this kind of component-specific memory is called *state*.

### When a regular variable isn’t enough  <a href="#when-a-regular-variable-isnt-enough" id="when-a-regular-variable-isnt-enough"></a>

Here’s a component that renders a sculpture image. Clicking the “Next” button should show the next sculpture by changing the `index` to `1`, then `2`, and so on. However, this **won’t work** (you can try it!):

{% embed url="<https://codesandbox.io/embed/compassionate-chaplygin-tejhuy?fontsize=14&hidenavigation=1&module=/App.js&theme=dark>" fullWidth="true" %}

The `handleClick` event handler is updating a local variable, `index`. But two things prevent that change from being visible:

1. **Local variables don’t persist between renders.** When React renders this component a second time, it renders it from scratch—it doesn’t consider any changes to the local variables.
2. **Changes to local variables won’t trigger renders.** React doesn’t realize it needs to render the component again with the new data.

To update a component with new data, two things need to happen:

1. **Retain** the data between renders.
2. **Trigger** React to render the component with new data (re-rendering).

The [`useState`](https://react.dev/reference/react/useState) Hook provides those two things:

1. A **state variable** to retain the data between renders.
2. A **state setter function** to update the variable and trigger React to render the component again.

### Adding a state variable  <a href="#adding-a-state-variable" id="adding-a-state-variable"></a>

To add a state variable, import `useState` from React at the top of the file:

```jsx
import { useState } from 'react';
```

Then, replace this line:

```jsx
let index = 0;
```

with

```jsx
const [index, setIndex] = useState(0);
```

`index` is a state variable and `setIndex` is the setter function.

> The `[` and `]` syntax here is called [array destructuring](https://javascript.info/destructuring-assignment) and it lets you read values from an array. The array returned by `useState` always has exactly two items.

This is how they work together in `handleClick`:

```jsx
function handleClick() {
  setIndex(index + 1);
}
```

Now clicking the “Next” button switches the current sculpture:

{% embed url="<https://codesandbox.io/embed/upbeat-keldysh-0efc0f?fontsize=14&hidenavigation=1&module=/App.js&theme=dark>" fullWidth="true" %}

### Meet your first Hook  <a href="#meet-your-first-hook" id="meet-your-first-hook"></a>

In React, `useState`, as well as any other function starting with ”`use`”, is called a Hook.

*Hooks* are special functions that are only available while React is [rendering](https://react.dev/learn/render-and-commit#step-1-trigger-a-render) (which we’ll get into in more detail on the next page). They let you “hook into” different React features.

State is just one of those features, but you will meet the other Hooks later.

#### Pitfall

**Hooks—functions starting with `use`—can only be called at the top level of your components or** [**your own Hooks.**](https://react.dev/learn/reusing-logic-with-custom-hooks) You can’t call Hooks inside conditions, loops, or other nested functions. Hooks are functions, but it’s helpful to think of them as unconditional declarations about your component’s needs. You “use” React features at the top of your component similar to how you “import” modules at the top of your file.

#### Anatomy of `useState`  <a href="#anatomy-of-usestate" id="anatomy-of-usestate"></a>

When you call [`useState`](https://react.dev/reference/react/useState), you are telling React that you want this component to remember something:

```jsx
const [index, setIndex] = useState(0);
```

In this case, you want React to remember `index`.

#### Note

The convention is to name this pair like `const [something, setSomething]`. You could name it anything you like, but conventions make things easier to understand across projects.

The only argument to `useState` is the **initial value** of your state variable. In this example, the `index`’s initial value is set to `0` with `useState(0)`.

Every time your component renders, `useState` gives you an array containing two values:

1. The **state variable** (`index`) with the value you stored.
2. The **state setter function** (`setIndex`) which can update the state variable and trigger React to render the component again.

Here’s how that happens in action:

```jsx
const [index, setIndex] = useState(0);
```

1. **Your component renders the first time.** Because you passed `0` to `useState` as the initial value for `index`, it will return `[0, setIndex]`. React remembers `0` is the latest state value.
2. **You update the state.** When a user clicks the button, it calls `setIndex(index + 1)`. `index` is `0`, so it’s `setIndex(1)`. This tells React to remember `index` is `1` now and triggers another render.
3. **Your component’s second render.** React still sees `useState(0)`, but because React *remembers* that you set `index` to `1`, it returns `[1, setIndex]` instead.
4. And so on!

### Giving a component multiple state variables  <a href="#giving-a-component-multiple-state-variables" id="giving-a-component-multiple-state-variables"></a>

You can have as many state variables of as many types as you like in one component. This component has two state variables, a number `index` and a boolean `showMore` that’s toggled when you click “Show details”:

{% embed url="<https://codesandbox.io/embed/agitated-burnell-jcnbsj?fontsize=14&hidenavigation=1&module=/App.js&theme=dark>" fullWidth="true" %}

It is a good idea to have multiple state variables if their state is unrelated, like `index` and `showMore` in this example. But if you find that you often change two state variables together, it might be easier to combine them into one. For example, if you have a form with many fields, it’s more convenient to have a single state variable that holds an object than state variable per field. Read [Choosing the State Structure](https://react.dev/learn/choosing-the-state-structure) for more tips.

### State is isolated and private  <a href="#state-is-isolated-and-private" id="state-is-isolated-and-private"></a>

State is local to a component instance on the screen. In other words, **if you render the same component twice, each copy will have completely isolated state!** Changing one of them will not affect the other.

In this example, the `Gallery` component from earlier is rendered twice with no changes to its logic. Try clicking the buttons inside each of the galleries. Notice that their state is independent:

{% embed url="<https://codesandbox.io/embed/divine-currying-rodp3h?fontsize=14&hidenavigation=1&module=/App.js&theme=dark>" fullWidth="true" %}

This is what makes state different from regular variables that you might declare at the top of your module. State is not tied to a particular function call or a place in the code, but it’s “local” to the specific place on the screen. You rendered two `<Gallery />` components, so their state is stored separately.

Also notice how the `Page` component doesn’t “know” anything about the `Gallery` state or even whether it has any. Unlike props, **state is fully private to the component declaring it.** The parent component can’t change it. This lets you add state to any component or remove it without impacting the rest of the components.

What if you wanted both galleries to keep their states in sync? The right way to do it in React is to *remove* state from child components and add it to their closest shared parent. The next few pages will focus on organizing state of a single component, but we will return to this topic in [Sharing State Between Components.](https://react.dev/learn/sharing-state-between-components)

### Recap <a href="#recap" id="recap"></a>

* Use a state variable when a component needs to “remember” some information between renders.
* State variables are declared by calling the `useState` Hook.
* Hooks are special functions that start with `use`. They let you “hook into” React features like state.
* Hooks might remind you of imports: they need to be called unconditionally. Calling Hooks, including `useState`, is only valid at the top level of a component or another Hook.
* The `useState` Hook returns a pair of values: the current state and the function to update it.
* You can have more than one state variable. Internally, React matches them up by their order.
* State is private to the component. If you render it in two places, each copy gets its own state.