" fullWidth="true" %}
Notice the sandbox above displays a console error:
ConsoleWarning: Each child in a list should have a unique “key” prop.
You’ll learn how to fix this error later on this page. Before we get to that, let’s add some structure to your data.
### Filtering arrays of items
This data can be structured even more.
```jsx
const people = [{
id: 0,
name: 'Creola Katherine Johnson',
profession: 'mathematician',
}, {
id: 1,
name: 'Mario José Molina-Pasquel Henríquez',
profession: 'chemist',
}, {
id: 2,
name: 'Mohammad Abdus Salam',
profession: 'physicist',
}, {
name: 'Percy Lavon Julian',
profession: 'chemist',
}, {
name: 'Subrahmanyan Chandrasekhar',
profession: 'astrophysicist',
}];
```
Let’s say you want a way to only show people whose profession is `'chemist'`. You can use JavaScript’s `filter()` method to return just those people. This method takes an array of items, passes them through a “test” (a function that returns `true` or `false`), and returns a new array of only those items that passed the test (returned `true`).
You only want the items where `profession` is `'chemist'`. The “test” function for this looks like `(person) => person.profession === 'chemist'`. Here’s how to put it together:
1. **Create** a new array of just “chemist” people, `chemists`, by calling `filter()` on the `people` filtering by `person.profession === 'chemist'`:
```jsx
const chemists = people.filter(person =>
person.profession === 'chemist'
);
```
2. Now **map** over `chemists`:
```jsx
const listItems = chemists.map(person =>
})
{person.name}:
{' ' + person.profession + ' '}
known for {person.accomplishment}
);
```
3. Lastly, **return** the `listItems` from your component:
```jsx
return ;
```
{% embed url="" fullWidth="true" %}
#### Pitfall
Arrow functions implicitly return the expression right after `=>`, so you didn’t need a `return` statement:
```jsx
const listItems = chemists.map(person =>
... // Implicit return!
);
```
However, **you must write `return` explicitly if your `=>` is followed by a `{` curly brace!**
```jsx
const listItems = chemists.map(person => { // Curly brace
return ...;
});
```
Arrow functions containing `=> {` are said to have a [“block body”.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#function_body) They let you write more than a single line of code, but you *have to* write a `return` statement yourself. If you forget it, nothing gets returned!
### Keeping list items in order with `key`
Notice that all the sandboxes above show an error in the console:
ConsoleWarning: Each child in a list should have a unique “key” prop.
You need to give each array item a `key` — a string or a number that uniquely identifies it among other items in that array:
```jsx
...
```
#### Note
JSX elements directly inside a `map()` call always need keys!
Keys tell React which array item each component corresponds to, so that it can match them up later. This becomes important if your array items can move (e.g. due to sorting), get inserted, or get deleted. A well-chosen `key` helps React infer what exactly has happened, and make the correct updates to the DOM tree.
Rather than generating keys on the fly, you should include them in your data:
{% embed url="" fullWidth="true" %}
#### Where to get your `key`
Different sources of data provide different sources of keys:
* **Data from a database:** If your data is coming from a database, you can use the database keys/IDs, which are unique by nature.
* **Locally generated data:** If your data is generated and persisted locally (e.g. notes in a note-taking app), use an incrementing counter, [`crypto.randomUUID()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID) or a package like [`uuid`](https://www.npmjs.com/package/uuid) when creating items.
#### Rules of keys
* **Keys must be unique among siblings.** However, it’s okay to use the same keys for JSX nodes in *different* arrays.
* **Keys must not change** or that defeats their purpose! Don’t generate them while rendering.
#### Why does React need keys?
Imagine that files on your desktop didn’t have names. Instead, you’d refer to them by their order — the first file, the second file, and so on. You could get used to it, but once you delete a file, it would get confusing. The second file would become the first file, the third file would be the second file, and so on.
File names in a folder and JSX keys in an array serve a similar purpose. They let us uniquely identify an item between its siblings. A well-chosen key provides more information than the position within the array. Even if the *position* changes due to reordering, the `key` lets React identify the item throughout its lifetime.
#### Pitfall
You might be tempted to use an item’s index in the array as its key. In fact, that’s what React will use if you don’t specify a `key` at all. But the order in which you render items will change over time if an item is inserted, deleted, or if the array gets reordered. Index as a key often leads to subtle and confusing bugs.
Similarly, do not generate keys on the fly, e.g. with `key={Math.random()}`. This will cause keys to never match up between renders, leading to all your components and DOM being recreated every time. Not only is this slow, but it will also lose any user input inside the list items. Instead, use a stable ID based on the data.
Note that your components won’t receive `key` as a prop. It’s only used as a hint by React itself. If your component needs an ID, you have to pass it as a separate prop: ``.
### Recap
On this page you learned:
* Why and how to set `key` on each component in a collection so React can keep track of each of them even if their position or data changes.