Home » Reactjs » Understanding unique keys for array children in React.js

Understanding unique keys for array children in React.js

Posted by: admin November 29, 2017 Leave a comment


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:

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

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);

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

What is causing the unique key prop error?


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:

var data = [{name:'Jhon', age:28, city:'HO'},{name:'Onhj', age:82, city:'HN'},{name:'Nohj', age:41, city:'IT'}]

var Hello = React.createClass({

    render: function() {

      var _data = this.props.info;
            {_data.map(function(object, i){
               return <div className={"row"} key={i}> 
                          {[ object.name ,
                             <b className="fosfo" key={i}> {object.city} </b> , // remove the key 

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

React documentation on the importance of keys in reconciliation: Keys


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 everyone is familiar with:

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

However, 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 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)

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

This is arguably the most common mistake seen when iterating over an array in React. This approach will work fine unless an element is added to, or removed from, the rows array. If you are iterating through something that is static, then this is perfectly valid (e.g. an array of links in your navigation menu). Take a look at this detailed explanation in the official documentation.

Here’s a code snippet that demonstrates the risks of using the item index of the array as the key:

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

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

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>

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 the key 0. When we add the second item, the first item becomes Item 2, followed by Item 1 as the second item. However, now Item 1 has the key 1 and not 0 anymore. Instead, Item 2 now has the 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.

Even in certain cases where we do filter or rearrange the items, the above can still work (though it’s still discouraged). Had we, in the snippet above, pushed the added item to the end of the array instead, the order for each existing item would always be correct.

Very bad

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

While this approach will guarantee uniqueness of the keys, it will always force react to re-render each item in the list, even when this is not required. This a very bad solution as it greatly impacts performance. 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

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

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


componentWillMount() {
  let rows = this.props.rows.map(item => { 
    return {uid: SomeLibrary.generateUniqueID(), value: item};


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

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.