CODEWITHSUNDEEP
javascriptreactjs
Brett DeWoody
Brett DeWoody

Reputation: 62743

Understanding unique keys for array children in React.js

I'm building a React component that accepts a JSON data source and creates a sortable table.
Each of the dynamic data rows has a unique key assigned to it but I'm still getting an error of:

Each child in an array should have a unique "key" prop.
Check the render method of TableComponent.

My TableComponent render method returns:

<table>
  <thead key="thead">
    <TableHeader columns={columnNames}/>
  </thead>
  <tbody key="tbody">
    { rows }
  </tbody>
</table>

The TableHeader component is a single row and also has a unique key assigned to it.

Each row in rows is built from a component with a unique key:

<TableRowItem key={item.id} data={item} columns={columnNames}/>

And the TableRowItem looks like this:

var TableRowItem = React.createClass({
  render: function() {

    var td = function() {
        return this.props.columns.map(function(c) {
          return <td key={this.props.data[c]}>{this.props.data[c]}</td>;
        }, this);
      }.bind(this);

    return (
      <tr>{ td(this.props.item) }</tr>
    )
  }
});

What is causing the unique key prop error?

Upvotes: 1089

Views: 1388929

Answers (30)

Chris
Chris

Reputation: 59491

Be careful when iterating over arrays!!

It is a common misconception that using the index of the element in the array is an acceptable way of suppressing the error you are probably familiar with:

Each child in an array should have a unique "key" prop.

However, in many cases it is not! This is anti-pattern that can in some situations lead to unwanted behavior.


Understanding the key prop

React uses the key prop to understand the component-to-DOM Element relation, which is then used for the reconciliation process. It is therefore very important that the key always remains unique, otherwise there is a good chance React will mix up the elements and mutate the incorrect one. It is also important that these keys remain static throughout all re-renders in order to maintain best performance.

That being said, one does not always need to apply the above, provided it is known that the array is completely static. However, applying best practices is encouraged whenever possible.

A React developer said in this GitHub issue:

  • key is not really about performance, it's more about identity (which in turn leads to better performance). randomly assigned and changing values are not identity
  • We can't realistically provide keys [automatically] without knowing how your data is modeled. I would suggest maybe using some sort of hashing function if you don't have ids
  • We already have internal keys when we use arrays, but they are the index in the array. When you insert a new element, those keys are wrong.

In short, a key should be:

  • Unique - A key cannot be identical to that of a sibling component.
  • Static - A key should not ever change between renders.

Using the key prop

As per the explanation above, carefully study the following samples and try to implement, when possible, the recommended approach.

Bad (Potentially)

    <tbody>
        {rows.map((row, i) => {
            return <ObjectRow key={i} />;
        })}
    </tbody>

This is arguably the most common mistake seen when iterating over an array in React. This approach isn't technically "wrong", it's just... "dangerous" if you don't know what you are doing. If you are iterating through a static array then this is a perfectly valid approach (e.g. an array of links in your navigation menu). However, if you are adding, removing, reordering or filtering items, then you need to be careful. Take a look at this detailed explanation in the official documentation.

class MyApp extends React.Component {
  constructor() {
    super();
    this.state = {
      arr: ["Item 1"]
    }
  }
  
  click = () => {
    this.setState({
      arr: ['Item ' + (this.state.arr.length+1)].concat(this.state.arr),
    });
  }
  
  render() {
    return(
      <div>
        <button onClick={this.click}>Add</button>
        <ul>
          {this.state.arr.map(
            (item, i) => <Item key={i} text={"Item " + i}>{item + " "}</Item>
          )}
        </ul>
      </div>
    );
  }
}

const Item = (props) => {
  return (
    <li>
      <label>{props.children}</label>
      <input value={props.text} />
    </li>
  );
}

ReactDOM.render(<MyApp />, document.getElementById("app"));
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js"></script>
<div id="app"></div>

In this snippet we are using a non-static array and we are not restricting ourselves to using it as a stack. This is an unsafe approach (you'll see why). Note how as we add items to the beginning of the array (basically unshift), the value for each <input> remains in place. Why? Because the key doesn't uniquely identify each item.

In other words, at first Item 1 has key={0}. When we add the second item, the top item becomes Item 2, followed by Item 1 as the second item. However, now Item 1 has key={1} and not key={0} anymore. Instead, Item 2 now has key={0}!!

As such, React thinks the <input> elements have not changed, because the Item with key 0 is always at the top!

So why is this approach only sometimes bad?

This approach is only risky if the array is somehow filtered, rearranged, or items are added/removed. If it is always static, then it's perfectly safe to use. For example, a navigation menu like ["Home", "Products", "Contact us"] can safely be iterated through with this method because you'll probably never add new links or rearrange them.

In short, here's when you can safely use the index as key:

  • The array is static and will never change.
  • The array is never filtered (display a subset of the array).
  • The array is never reordered.
  • The array is used as a stack or LIFO (last in, first out). In other words, adding can only be done at the end of the array (i.e push), and only the last item can ever be removed (i.e pop).

Had we instead, in the snippet above, pushed the added item to the end of the array, the order for each existing item would always be correct.

Very bad

    <tbody>
        {rows.map((row) => {
            return <ObjectRow key={Math.random()} />;
        })}
    </tbody>

While this approach will probably guarantee uniqueness of the keys, it will always force react to re-mount each item in the list, even when this is not required. This a very bad solution as it greatly impacts performance and resets state and focus. Not to mention that one cannot exclude the possibility of a key collision in the event that Math.random() produces the same number twice.

Unstable keys (like those produced by Math.random()) will cause many component instances and DOM nodes to be unnecessarily recreated, which can cause performance degradation and lost state in child components.

Very good

    <tbody>
        {rows.map((row) => {
            return <ObjectRow key={row.uniqueId} />;
        })}
    </tbody>

This is arguably the best approach because it uses a property that is unique for each item in the dataset. For example, if rows contains data fetched from a database, one could use the table's Primary Key (which typically is an auto-incrementing number).

The best way to pick a key is to use a string that uniquely identifies a list item among its siblings. Most often you would use IDs from your data as keys

Good

    componentWillMount() {
      let rows = this.props.rows.map(item => { 
        return {uid: SomeLibrary.generateUniqueID(), value: item};
      });
    }
    
    ...
    
    <tbody>
        {rows.map((row) => {
            return <ObjectRow key={row.uid} />;
        })}
    </tbody>

This is also a good approach. If your dataset does not contain any data that guarantees uniqueness (e.g. an array of arbitrary numbers), there is a chance of a key collision. In such cases, it is best to manually generate a unique identifier for each item in the dataset before iterating over it. Preferably when mounting the component or when the dataset is received (e.g. from props or from an async API call), in order to do this only once, and not each time the component re-renders. There are already a handful of libraries out there that can provide you such keys. Here is one example: react-key-index.

Upvotes: 928

Eran Betzalel
Eran Betzalel

Reputation: 4193

I've created a react hook to solve such occasions once and for all. It simply creates a temporary copy of the array items with ID and removes the ID when it's written back to the store.

import {useState} from 'react';

import {nanoid} from 'nanoid';

export type ItemWithId<T> = T & { id: string };

export const useIdGeneratedItems = <T>(items: T[]): [ItemWithId<T>[], (items: ItemWithId<T>[]) => void] => {
    const [itemsWithId, setItemsWithId] = useState(() => items.map(item => ({...item, id: nanoid()})));

    return [itemsWithId, setItemsWithId];
};

Usage example:

const [optionsWithId, setOptionsWithId] = useIdGeneratedItems(options);

<ContentWheelOptionSettings
    title="Options"
    description="Customize the discount win options"
    value={optionsWithId}
    onChange={(value) => {
        const optionsWithoutIds = value.map(option => omit(option, 'id'));

        setInitialState({wheel: {options: optionsWithoutIds}});

        setOptionsWithId(value);
    }}
/>

Source: https://gist.github.com/eranbetzalel/edf4ec006f6b09a5fbd0f33a1f1a9791

Upvotes: 0

jmingov
jmingov

Reputation: 14003

You should add a key to each child as well as each element inside children.

This way React can handle the minimal DOM change.

In your code, each <TableRowItem key={item.id} data={item} columns={columnNames}/> is trying to render some children inside them without a key.

Check this example.

Try removing the key={i} from the <b></b> element inside the div's (and check the console).

In the sample, if we don't give a key to the <b> element and we want to update only the object.city, React needs to re-render the whole row vs just the element.

Here is the code:

const data = [
  { name: "Nuri", age: 28, city: "HO" },
  { name: "Talib", age: 82, city: "HN" },
  { name: "Jenny", age: 41, city: "IT" },
];

const ExampleComponent = React.createClass({
  render: function () {
    const infoData = this.props.info;
    return (
      <div>
        {infoData.map((object, i) => {
          return (
            <div className={"row"} key={i}>
              {[
                object.name,
                // remove the key
                <b className="fosfo" key={i}>
                  {" "}
                  {object.city}{" "}
                </b>,
                object.age,
              ]}
            </div>
          );
        })}
      </div>
    );
  },
});

React.render(<ExampleComponent info={data} />, document.body);

The answer posted by @Chris at the bottom goes into much more detail than this answer.

React documentation on the importance and usage of keys: Keys

Upvotes: 949

leo
leo

Reputation: 1275

I was puzzled by this until I looked very carefully at my code - so this is what I had - spot the bug:

{
  items.map(
    (item) => {
      
      return (<>
         <IonItem key={item.id}>
             <p>{ item.name }</p>
         </IonItem>
      </>);
    }
  )
}

So, I had a key attribute on my "item" component (<IonItem>) - still React complained about a lack of a unique key on my list items ...

The bug of course was that I erroneously wrapped the whole thing in <> and </> which do NOT have a key property ... once I removed this (unnecessary) <>...</> wrapper, the error disappeared.

Maybe this is obvious, but it's VERY easy to overlook ... it had me puzzled for a while.

Upvotes: 2

Islam Murtazaev
Islam Murtazaev

Reputation: 1778

I also had to deal with deletion and addition of children with no unique keys.

So I ended up using UUID as keys and wrapped them in useMemo based on the number of elements.

  const uniqueKeys = useMemo(() =>
    data.map(_ => uuidv4()),
    [data.length]
  );

  // in render
  {data.map((item, index) => (
     <Tr key={uniqueKeys[index]}>

Upvotes: 1

jam j
jam j

Reputation: 538

Here is sample code (App.jsx), just use it to your file

const ListItem = (props) => (
  <li>
    <input type="checkbox" />
    <p> {props.title} </p>
  </li>
);

const productList = [
  {
    id: 1,
    title: 'Shirt',
    checked: false
  },
  {
    id: 2,
    title: 'Pant',
    checked: false
  },
  {
    id: 3,
    title: 'Cap',
    checked: false
  },
]

function App(props) {
  return (
    <>
      <div>
        <ul>
          {productList.map((item) => (
            <ListItem key={item.id} title={item.title} />
          ))}
        </ul>
      </div>
    </>
  )
}

export default App

Upvotes: 0

Susobhan Das
Susobhan Das

Reputation: 1144

For React official docs

The key should be inside <li key={person}>{person}</li>


const people = [
  'Creola Katherine Johnson: mathematician',
  'Mario José Molina-Pasquel Henríquez: chemist',
  'Mohammad Abdus Salam: physicist',
  'Percy Lavon Julian: chemist',
  'Subrahmanyan Chandrasekhar: astrophysicist'
];

export default function List() {
  const listItems = people.map(person =>
    <li key={person}>{person}</li>
  );
  return <ul>{listItems}</ul>;
}

Upvotes: 0

Micael Mota
Micael Mota

Reputation: 580

I've seen many times people rendering fragments <></> and it generates this issue. Try to change the fragments to null or a component with a unique key

Upvotes: 0

Dila Gurung
Dila Gurung

Reputation: 1764

I don't go with the detail explanation but the key to this answer is "key" just put the key attribute in your tag and ensure that every-time you iterate you give unique value to it

#ensure that the key's value is not clashing with others

Example

<div>
        {conversation.map(item => (
          <div key={item.id  } id={item.id}>
          </div>
        ))}
      </div>

where the conversation is an array of something like below :

  const conversation = [{id:"unique"+0,label:"OPEN"},{id:"unique"+1,label:"RESOLVED"},{id:"unique"+2,label:"ARCHIVED"},
   ]

Upvotes: 0

Yilmaz
Yilmaz

Reputation: 49182

I think when working with tables (or in similar examples), creating a unique key should be passed to the child component from the parent component for the sake of REUSABILITY.

Because if you are creating a table, that means you are passing data from the parent. If you assign key={row.name} maybe currently data has name property but if you want to use this table component somewhere else you assume that in each row of data that you have passed, you have name property.

Since the engineer will be preparing the data in the parent component, the engineer should create a key function based on the data.

const keyFunc = (student) => {
    return student.id;
  };

In this case, the engineer knows what data it is sending, it knows that each row has an id property that is unique. Maybe in the different data set, the data set is stock prices and it does not have "id" property but "symbol"

 const keyFunc = (stock) => {
        return stock.symbol;
      };

this keyFunc should be passed to the child component as a prop to guarantee reusability and uniqueness.

Upvotes: 0

I.sh.
I.sh.

Reputation: 1935

According to React docs, each row/item should have a unique key.

Keys help React identify which items have changed, are added, or are removed.

Personally, I prefer using the crypto interface to generate a random UUID:
(crypto is built-in in vanilla-js)

const numbers = [1, 2, 3, 4, 5];

const listItems = numbers.map((number) =>
  <li key={crypto.randomUUID()}>item {number}
  </li>
);

Upvotes: 1

Niloy dey
Niloy dey

Reputation: 31

If we have array object data . then we map to show the data . and pass the unique id (key = {product.id} ) because browser can select the unique data.

example : [
    {
        "id": "1",
        "name": "walton glass door",
        "suplier": "walton group",
        "price": "50000",
        "quantity": "25",
        "description":"Walton Refrigerator is the Best Refrigerator brand in bv 
         Bangladesh "
    },
    {
        
        "id": "2",
        "name": "walton glass door",
        "suplier": "walton group",
        "price": "40000",
        "quantity": "5",
        "description":"Walton Refrigerator is the Best Refrigerator brand in 
         Bangladesh "
    },
}

now we are mapping the data and pass the unique id:

{
    products.map(product => <product product={product} key={product.id} 
    </product>)
}

Upvotes: 3

user1917528
user1917528

Reputation: 311

A visual explanation.

  1. The incorrect way key=index (of an array)

enter image description here

As you can see, label 3, label 2, and label 1 ALL got re-rendered (flashing in the Elements panel).

  1. The correct way key=uniqueId enter image description here

Only the top new element flashes (gets re-rendered).

Upvotes: 2

Basurp Patil
Basurp Patil

Reputation: 151

Here are the React docs that explain well using the Key property, the key should be defined at the parent component it should not be used inside the child component.React Docs

enter image description here

enter image description here

Upvotes: 11

Atish Barua
Atish Barua

Reputation: 11

your key should be unique.like an unique id.And your code should be like this

<div>
 {products.map(product => (
   <Product key={product.id}>
    </Product>
    ))}
  </div>

Upvotes: 1

thinkerBOB
thinkerBOB

Reputation: 176

If you are struggling with this error Each child in a list should have a unique "key" prop.

Solve by declaring index value to the key attribute inside the rendering element.

App.js component

import Map1 from './Map1';

const arr = [1,2,3,4,5];

const App = () => {
  return (
    <>
     
     <Map1 numb={arr} />     

    </>
  )
}

export default App

Map.js component

const Map1 = (props) => {

    let itemTwo = props.numb;
    let itemlist = itemTwo.map((item,index) => <li key={index}>{item}</li>)

    return (
        <>        
        <ul>
            <li style={liStyle}>{itemlist}</li>
        </ul>
        </>
    )
}

export default Map1

Upvotes: -1

Vinci
Vinci

Reputation: 1286

This is a simple example,I have used a react condition with && first then map, in the I have added the key the user id to be sure that it's unique

 <tbody>
                                    {users &&
                                    users.map((user) => {
                                        return <tr key={user._id}>
                                            <td>{user.username}</td>
                                            <td><input
                                                name="isGoing"
                                                type="checkbox"
                                                checked={user.isEnabled}
                                                onChange={handleInputChangeNew}/></td>
                                            <td>{user.role.roleTitle} - {user.role.department.departmentName}</td>
                                            {/*<td className="text-right">
                                                    <Button>
                                                        ACTION
                                                    </Button>
                                                </td>*/}
                                        </tr>
                                    })
                                    }


                                    </tbody>

Upvotes: 1

A K M Intisar Islam
A K M Intisar Islam

Reputation: 55

I faced a similar problem but not exact. Tried every possible solution and couldn't get rid of that error

Each child in an array should have a unique "key" prop.

Then I tried opening it in a different local host. I don't know how, but it worked!

Upvotes: -4

Foyez
Foyez

Reputation: 464

You should use a unique value for each children key of tbody where

  • the value cannot not be identical (same) to its sibling
  • should not change between renders

For example, the key value can be database id or UUID (Universal Unique Identifier).

Here the keys are handling manually:

<tbody>
  {rows.map((row) => <ObjectRow key={row.uuid} />)}
</tbody>

You can also let React handle the keys using React.Children.toArray

<tbody>
  {React.Children.toArray(rows.map((row) => <ObjectRow />))}
</tbody>

Upvotes: 8

Vik2696
Vik2696

Reputation: 367

If you are getting error like :

> index.js:1 Warning: Each child in a list should have a unique "key" prop.

Check the render method of `Home`. See https://reactjs.org/link/warning-keys for more information.

Then Use inside map function like:

  {classes.map((user, index) => (
              <Card  **key={user.id}**></Card>
  ))}`enter code here`

Upvotes: 1

superup
superup

Reputation: 2167

In my case, set id to tag

<tbody key={i}>

The problem is solved.

Upvotes: 2

Nasreen Ustad
Nasreen Ustad

Reputation: 1702

When you don’t have stable IDs for rendered items, you may use the item index as a key as a last resort:

const todoItems = todos.map((todo, index) =>
// Only do this if items have no stable IDs
   <li key={index}>
      {todo.text}
   </li>
);

Please refer to List and Keys - React

Upvotes: 5

Arvind
Arvind

Reputation: 93

I had a unique key, just had to pass it as a prop like this:

<CompName key={msg._id} message={msg} />

This page was helpful:

https://reactjs.org/docs/lists-and-keys.html#keys

Upvotes: 2

Supun Praneeth
Supun Praneeth

Reputation: 3150

In ReactJS if you are rendering an array of elements you should have a unique key for each those elements. Normally those kinda situations are creating a list.

Example:

function List() {
  const numbers = [0,1,2,3];
 
  return (
    <ul>{numbers.map((n) => <li> {n} </li>)}</ul>
  );
}

 ReactDOM.render(
  <List />,
  document.getElementById('root')
);

In the above example, it creates a dynamic list using li tag, so since li tag does not have a unique key it shows an error.

After fixed:

function List() {
  const numbers = [0,1,2,3];
 
  return (
    <ul>{numbers.map((n) => <li key={n}> {n} </li>)}</ul>
  );
}

 ReactDOM.render(
  <List />,
  document.getElementById('root')
);

Alternative solution when use map when you don't have a unique key (this is not recommended by react eslint ):

function List() {
  const numbers = [0,1,2,3,4,4];
 
  return (
    <ul>{numbers.map((n,i) => <li key={i}> {n} </li>)}</ul>
  );
}

 ReactDOM.render(
  <List />,
  document.getElementById('root')
);

Live example: https://codepen.io/spmsupun/pen/wvWdGwG

Upvotes: 4

apil.tamang
apil.tamang

Reputation: 2725

This may or not help someone, but it might be a quick reference. This is also similar to all the answers presented above.

I have a lot of locations that generate list using the structure below:

return (
    {myList.map(item => (
       <>
          <div class="some class"> 
             {item.someProperty} 
              ....
          </div>
       </>
     )}
 )

After a little trial and error (and some frustrations), adding a key property to the outermost block resolved it. Also, note that the <> tag is now replaced with the <div> tag now.

return (
  
    {myList.map((item, index) => (
       <div key={index}>
          <div class="some class"> 
             {item.someProperty} 
              ....
          </div>
       </div>
     )}
 )

Of course, I've been naively using the iterating index (index) to populate the key value in the above example. Ideally, you'd use something which is unique to the list item.

Upvotes: 69

Felipe
Felipe

Reputation: 173

I was running into this error message because of <></> being returned for some items in the array when instead null needs to be returned.

Upvotes: 2

Khadim H.
Khadim H.

Reputation: 645

Best solution of define unique key in react: inside the map you initialized the name post then key define by key={post.id} or in my code you see i define the name item then i define key by key={item.id}:

<div className="container">
                {posts.map(item =>(

                    <div className="card border-primary mb-3" key={item.id}>
                        <div className="card-header">{item.name}</div>
                    <div className="card-body" >
                <h4 className="card-title">{item.username}</h4>
                <p className="card-text">{item.email}</p>
                    </div>
                  </div>
                ))}
            </div>

Upvotes: 4

Ramesh
Ramesh

Reputation: 1887

var TableRowItem = React.createClass({
  render: function() {

    var td = function() {
        return this.props.columns.map(function(c, i) {
          return <td key={i}>{this.props.data[c]}</td>;
        }, this);
      }.bind(this);

    return (
      <tr>{ td(this.props.item) }</tr>
    )
  }
});

This will sove the problem.

Upvotes: 1

Gerd
Gerd

Reputation: 2603

Check: key = undef !!!

You got also the warn message:

Each child in a list should have a unique "key" prop.

if your code is complete right, but if on

<ObjectRow key={someValue} />

someValue is undefined!!! Please check this first. You can save hours.

Upvotes: 17

prime
prime

Reputation: 15564

This is a warning, But addressing this will make Reacts rendering much FASTER,

This is because React needs to uniquely identify each items in the list. Lets say if the state of an element of that list changes in Reacts Virtual DOM then React needs to figure out which element got changed and where in the DOM it needs to change so that browser DOM will be in sync with the Reacts Virtual DOM.

As a solution just introduce a key attribute to each li tag. This key should be a unique value to each element.

Upvotes: 1

Related Questions