Why shouldn't JSX props use arrow functions or bind?

Question

I'm running lint with my React app, and I receive this error:

error    JSX props should not use arrow functions        react/jsx-no-bind

And this is where I'm running the arrow function (inside onClick ):

{this.state.photos.map(tile => (
  <span key={tile.img}>
    <Checkbox
      defaultChecked={tile.checked}
      onCheck={() => this.selectPicture(tile)}
      style={{position: 'absolute', zIndex: 99, padding: 5, backgroundColor: 'rgba(255, 255, 255, 0.72)'}}
    />
    <GridTile
      title={tile.title}
      subtitle={<span>by <b>{tile.author}</b></span>}
      actionIcon={<IconButton onClick={() => this.handleDelete(tile)}><Delete color="white"/></IconButton>}
    >
      <img onClick={() => this.handleOpen(tile.img)} src={tile.img} style={{cursor: 'pointer'}}/>
    </GridTile>
  </span>
))}

Is this a bad practice that should be avoided? And what's the best way to do it?

Answer 1

Why you shouldn't use inline arrow functions in JSX props

Using arrow functions or binding in JSX is a bad practice that hurts performance, because the function is recreated on each render.

1. Whenever a function is created, the previous function is garbage collected. Rerendering many elements might create jank in animations.

2. Using an inline arrow function will cause PureComponent s, and components that use shallowCompare in the shouldComponentUpdate method to rerender anyway. Since the arrow function prop is recreated each time, the shallow compare will identify it as a change to a prop, and the component will rerender.

As you can see in the following 2 examples - when we use inline arrow function, the <Button> component is rerendered each time (the console shows the 'render button' text).

Example 1 - PureComponent without inline handler

 class Button extends React.PureComponent { render() { const { onClick } = this.props; console.log('render button'); return ( <button onClick={ onClick }>Click</button> ); } } class Parent extends React.Component { state = { counter: 0 } onClick = () => this.setState((prevState) => ({ counter: prevState.counter + 1 })); render() { const { counter } = this.state; return ( <div> <Button onClick={ this.onClick } /> <div>{ counter }</div> </div> ); } } ReactDOM.render( <Parent />, document.getElementById('root') );

 <script crossorigin src="https://unpkg.com/react@16/umd/react.production.min.js"></script> <script crossorigin src="https://unpkg.com/react-dom@16/umd/react-dom.production.min.js"></script> <div id="root"></div>

Example 2 - PureComponent with inline handler

 class Button extends React.PureComponent { render() { const { onClick } = this.props; console.log('render button'); return ( <button onClick={ onClick }>Click</button> ); } } class Parent extends React.Component { state = { counter: 0 } render() { const { counter } = this.state; return ( <div> <Button onClick={ () => this.setState((prevState) => ({ counter: prevState.counter + 1 })) } /> <div>{ counter }</div> </div> ); } } ReactDOM.render( <Parent />, document.getElementById('root') );

 <script crossorigin src="https://unpkg.com/react@16/umd/react.production.min.js"></script> <script crossorigin src="https://unpkg.com/react-dom@16/umd/react-dom.production.min.js"></script> <div id="root"></div>

Binding methods to this without inlining arrow functions

1. Binding the method manually in the constructor:

    class Button extends React.Component { constructor(props, context) { super(props, context); this.cb = this.cb.bind(this); } cb() { } render() { return ( <button onClick={ this.cb }>Click</button> ); } }

2. Binding a method using the proposal-class-fields with an arrow function. As this is a stage 3 proposal, you'll need to add the Stage 3 preset or the Class properties transform to your babel configuration.

    class Button extends React.Component { cb = () => { // the class property is initialized with an arrow function that binds this to the class } render() { return ( <button onClick={ this.cb }>Click</button> ); } }

Function Components with inner callbacks

When we create an inner function (event handler for example) inside a function component, the function will be recreated every time the component is rendered. If the function is passed as props (or via context) to a child component ( Button in this case), that child will re-render as well.

Example 1 - Function Component with an inner callback:

 const { memo, useState } = React; const Button = memo(({ onClick }) => console.log('render button') || ( <button onClick={onClick}>Click</button> )); const Parent = () => { const [counter, setCounter] = useState(0); const increment = () => setCounter(counter => counter + 1); // the function is recreated all the time return ( <div> <Button onClick={increment} /> <div>{counter}</div> </div> ); } ReactDOM.render( <Parent />, document.getElementById('root') );

 <script crossorigin src="https://unpkg.com/react@16/umd/react.development.js"></script> <script crossorigin src="https://unpkg.com/react-dom@16/umd/react-dom.development.js"></script> <div id="root"></div>

To solve this problem, we can wrap the callback with theuseCallback() hook , and set the dependencies to an empty array.

Note: the useState generated function accepts an updater function, that provides the current state. In this way, we don't need to set the current state a dependency of useCallback .

Example 2 - Function Component with an inner callback wrapped with useCallback:

 const { memo, useState, useCallback } = React; const Button = memo(({ onClick }) => console.log('render button') || ( <button onClick={onClick}>Click</button> )); const Parent = () => { const [counter, setCounter] = useState(0); const increment = useCallback(() => setCounter(counter => counter + 1), []); return ( <div> <Button onClick={increment} /> <div>{counter}</div> </div> ); } ReactDOM.render( <Parent />, document.getElementById('root') );

 <script crossorigin src="https://unpkg.com/react@16/umd/react.development.js"></script> <script crossorigin src="https://unpkg.com/react-dom@16/umd/react-dom.development.js"></script> <div id="root"></div>

Answer 2

This is because an arrow function apparently will create a new instance of the function on each render if used in a JSX property. This might create a huge strain on the garbage collector and will also hinder the browser from optimizing any "hot paths" since functions will be thrown away instead of reused.

You can see the whole explanation and some more info at https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/jsx-no-bind.md

Answer 3

Why shouldn't JSX props use arrow functions or bind?

Mostly, because inline functions can break memoization of optimized components:

Traditionally, performance concerns around inline functions in React have been related to how passing new callbacks on each render breaks shouldComponentUpdate optimizations in child components. ( docs )

It is less about additional function creation cost:

Performance issues with Function.prototype.bind got fixed here and arrow functions are either a native thing or are transpiled by babel to plain functions; in both cases we can assume it's not slow. ( React Training )

I believe people claiming function creation is expensive have always been misinformed (React team never said this). ( Tweet )

When is the react/jsx-no-bind rule useful?

You want to ensure, that memoized components work as intended:

• React.memo (for function components)
• PureComponent or custom shouldComponentUpdate (for class components)

By obeying to this rule, stable function object references are passed. So above components can optimize performance by preventing re-renders, when previous props have not changed.

How to solve the ESLint error?

Classes: Define the handler as method, or class property for this binding.
Hooks: Use useCallback .

Middleground

In many cases, inline functions are very convenient to use and absolutely fine in terms of performance requirements. Unfortunately, this rule cannot be limited to only memoized component types. If you still want to use it across-the-board, you could eg disable it for simple DOM nodes:

rules: {
  "react/jsx-no-bind": [ "error", { "ignoreDOMComponents": true } ],
}

const Comp = () => <span onClick={() => console.log("Hello!")} />; // no warning

Answer 4

Using inline functions like this is perfectly fine. The linting rule is outdated.

This rule is from a time when arrow functions were not as common and people used .bind(this), which used to be slow. The performance issue has been fixed in Chrome 49.

Do pay attention that you do not pass inline functions as props to a child component.

Ryan Florence, the author of React Router, has written a great piece about this:

https://cdb.reacttraining.com/react-inline-functions-and-performance-bdff784f5578

Answer 5

为避免创建具有相同参数的新函数，您可以记住函数绑定结果，这是一个名为memobind的简单实用程序： https ://github.com/supnate/memobind

Answer 6

You can use arrow functions using react-cached-handler library, no need to be worried about re-rendering performance :

Note : Internally it caches your arrow functions by the specified key, no need to be worried about re-rendering!

render() {
    return (
        <div>
            {this.props.photos.map((photo) => (
                <Photo
                    key={photo.url}
                    onClick={this.handler(photo.url, (url) => {
                        console.log(url);
                    })}
                />
            ))}
        </div>
    );
}

Other features:

• Named handlers
• Handle events by arrow functions
• Access to the key, custom arguments and the original event
• Component rendering performace
• Custom context for handlers

Answer 7

For those wondering when you need to pass data in the callback. Ex.:

const list = todos.map((todo, index) => (
  <Todo
    onClick={() => { onTodoClick(todo.id, todo.title, index) }
  />
));

Solution

According to the official documentation , you should do:

1. Move the function arguments into the children component:

const list = todos.map((todo, index) => (
  <Todo
    onClick={onTodoClick}
    todoId={todo.id}
    todoTitle={todo.title}
    indexOnList={index}
  />
));

2. In the children component ( <Todo /> ), pass the arguments in the call:

function Todo(props) {
  // component properties
  const { onClick, todoId, todoTitle, indexOnList } = props;

  // we move the call from the parent to the children
  const handleClick = useCallback(() => {
    onClick(todoId, todoTitle, indexOnList);
  }, [todoId, todoTitle, indexOnList]);

  return (
    <div onClick={handleClick}>
    {/* the rest of the component remains the same */}
    </div>
  );
}

Is this the best solution?

I dislike this solution. You end up with parent's data and logic in the children component. This makes the children component dependent on the parent component, breaking the dependency rule.

That's a big no-no for me.

What I do is just disable this rule. According to Ryan Florence (React Router author), this is not a big deal anyway: https://medium.com/@ryanflorence/react-inline-functions-and-performance-bdff784f5578

---

Answer 8

You can remove this error by wrapping the function inside useCallback.

Answer 9

The new (in beta, jan 2023) React tutorial uses both functions and arrow functions as JSX props. This hints strongly at this not being a major concern.

Answer 10

You may also see this this error if the function you are using in your onClick handler is a regular (non-inline) function defined outside of the render method but using the function keyword.

Declare your handler function as an arrow function using const, outside of you render method, and React will stop complaining...