Accepted answer

In your case it doesn't really makes sense to memoize Child because if item changes, the child has to re-render. However if there is a case that props do not change , but still the child is re-rendering due to the functions getting recreated you would make use of useCallback hook to memoize the functions, on each render. Also since you have memoized the handler, you should make use of the callback method to update state since item inside the handler will only refer to the value it had when the function was initially created

function Parent() {
  const [item, setItem] = useState({ name: "item", value: 0 });

  const handleChangeItem = useCallback(() => {
    setItem(prevItem => ({ ...prevItem, value: prevItem.value + 1 }));
  }, []);

  return (
      Name: {} Value: {item.value}
      <Child changeItem={handleChangeItem} />

const Child = React.memo(function Child({ item, changeItem }) {
  function handleClick() {
  console.log("child render");
  return (
      <button onClick={handleClick}>change state in parent</button>

Working demo

P.S. Credit to @danAbramov for the direction


Shubham Khatri accurately answered the original question but I am adding this answer to point to the recommended way of avoiding this callback problem.

From the docs:

useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values. It also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.

From the FAQ:

In large component trees, an alternative we recommend is to pass down a dispatch function from useReducer via context...

The key to all of this is that dispatch never changes, unlike callbacks which are created every render.

Related Query

More Query from same tag