useCallback is not working when using with child component of same type

Question

So I have a parent Component and a child component. And I use the child component twice in my parent component. I pass them two different state values as props and two different events as props. I have tried to memoize both the callbacks , but both the child are re-rendered even if one child callback is triggred. Why is useCallback not working.

Parent Component:

import { useState, useCallback, useEffect, useMemo } from 'react';
    import './App.css'
    import List from "./components/list";
    import LocalList from "./components/localList";

function App() {
  const itemsToBuy = [
    'Baby Shoes',
    'Grinder',
    'Car'
  ]
 
 
  const [buyList, updateBuyList] = useState(itemsToBuy);
  const [sellList, updateSellList] = useState([
    'Bed',
    'Sofa'
  ]);
  
  /** code to check the re-rendering of the componnet  */
  useEffect(() => {
    console.log(`parent is being rendered`)
  })

  /**trying to update the state from internal method to be passed as props */

  const updateBuyClick = useCallback(val => {
    updateBuyList(prev => [...prev, val])
  }, [buyList])

  const updateSellClick = useCallback(val => {
    console.log('memo of sell is called')
    updateSellList(prev => [...prev, val])
  }, [sellList])


  return (
    <>
      
        
          Items To Buy
          
        
        
          Items to Sell
          
        
        {/* 
          List that is not re-rendere
          
         */}
      
    
  );
}

export default App;

Child Component:

import { useState , useEffect} from "react";
import './list.css'

function List({ itemsArray = [], buttonText, onUpdateClick, idx }) {
    let currentSell = '';

    useEffect(() => {
        console.log(`${idx} is being rendered`)
    })
    const updateCurrentSell = (val) => {
        currentSell = val;
    }
    return (
        <>
            
                {itemsArray.map((value, index) => {
                    return {value}
                })}
            

            

                 { updateCurrentSell(e.target.value) }}>
                
            
        
    )
}

export default List;

T.J. Crowder · Accepted Answer

There are two reasons that's not working:

You're telling useCallback to throw away the stored copy of your function when the buyList or sellList changes by including those in your dependencies array. You don't need those dependencies, because you're (correctly) using the callback version of the state setters. So you aren't using buyList or sellList in the callbacks. Just remove them from the arrays.
```
const updateBuyClick = useCallback(val => {
  updateBuyList(prev => [...prev, val])
}, [])
// ^^−−− empty

const updateSellClick = useCallback(val => {
  console.log('memo of sell is called')
  updateSellList(prev => [...prev, val])
}, [])
// ^^−−− empty
```
useCallback only does half the necessary work: making sure the functions don't change unnecessarily. But your List component has to do the other half of the work: not re-rendering if its props don't change. With a function component, you do that with React.memo:
```
const List = React.memo(function List({ itemsArray = [], buttonText, onUpdateClick, idx }) {
    // ...
});
```
React.memo memoizes the component and reuses its last rendering if its props don't change. (You can customize that by providing a callback as its second argument, see the documentation for details.)

Between those two changes, you'll see only the appropriate instances of List re-render when things change.

Live Example:

const { useState, useCallback, useEffect, useMemo } = React;

function App() {
    const itemsToBuy = [
        "Baby Shoes",
        "Grinder",
        "Car"
    ];

    const [buyList, updateBuyList] = useState(itemsToBuy);
    const [sellList, updateSellList] = useState([
        "Bed",
        "Sofa"
    ]);

    // *** Note: No need for this to be in `useEffect`
    console.log(`parent is being rendered`)

    const updateBuyClick = useCallback(val => {
        updateBuyList(prev => [...prev, val]);
    }, []);

    const updateSellClick = useCallback(val => {
        updateSellList(prev => [...prev, val])
    }, []);

    return (
        
            
                Items To Buy
                
            
            
                Items to Sell
                
            
        
    );
}

const List = React.memo(function List({ itemsArray = [], buttonText, onUpdateClick, idx }) {
    // *** `currentSell` stuff should be in state, not a local variable
    const [currentSell, setCurrentSell] = useState("");

    console.log(`${idx} is being rendered`);

    return (  // <>... is fine, I had to change it because the
            // version of Babel Stack Snippets use is out of date
        
            
                {itemsArray.map((value, index) => {
                    return {value}
                })}
            

            
                 { setCurrentSell(e.target.value); }}>
                
            
        
    );
});

ReactDOM.render(, document.getElementById("root"));

useCallback is not working when using with child component of same type

Answers (1)

Related Questions