Streamline Array Management in React with the useList Custom Hook


Efficient array management is crucial for building robust applications, including those developed with React. By leveraging the power of custom hooks and vanilla JavaScript, we can streamline and simplify array operations in React. In this article, we'll explore the useList custom hook, a versatile tool that empowers React developers by allowing them to manage and manipulate arrays effortlessly. With the useList custom hook, you can enhance code readability, optimize your development workflow, and gain precise control over array operations in your React applications.

Understanding the useList Custom Hook

The useList custom hook is designed to provide a set of utility functions for managing arrays. It abstracts away the complexities of directly manipulating arrays in React components and offers a cleaner and more intuitive interface.

Let's take a closer look at the core functions provided by the useList hook:

  • list: The array itself, managed by the hook.
  • set: A function to update the entire array with a new value.
  • push: A function to add one or more items to the end of the array.
  • update: A function to update an item at a specific index in the array.
  • remove: A function to remove an item at a specific index from the array.
  • insert: A function to insert an item at a specific index in the array.
  • clear: A function to remove all items from the array.

With these utility functions, the useList hook simplifies the process of working with arrays in React components, improving code readability and maintainability.

Creating the useList Hook

To create the useList hook, we'll combine React's useState and useCallback hooks. Here's the implementation:

import { useState, useCallback } from 'react';

const useList = (initialValue = []) => {
  const [list, setList] = useState(initialValue);

  const set = useCallback((newList) => {
  }, []);

  const push = useCallback((item) => {
    setList((prevList) => [...prevList, item]);
  }, []);

  const update = useCallback((index, newItem) => {
    setList((prevList) => {
      const newList = [...prevList];
      newList[index] = newItem;
      return newList;
  }, []);

  const remove = useCallback((index) => {
    setList((prevList) => {
      const newList = [...prevList];
      newList.splice(index, 1);
      return newList;
  }, []);

  const insert = useCallback((index, item) => {
    setList((prevList) => {
      const newList = [...prevList];
      newList.splice(index, 0, item);
      return newList;
  }, []);

  const clear = useCallback(() => {
  }, []);

  return { list, set, push, update, remove, insert, clear };

In this implementation, the useList hook initializes the state with an initial array value. It provides the necessary utility functions to manipulate the array state. Each utility function uses the setList function from useState to update the array with the desired changes.

Using the useList Hook

Once we've created the useList hook, we can easily use it in our React components. Let's see an example:

import useList from './useList';

function App() {
  const { list, push, update, remove } = useList(['Apple', 'Banana', 'Cherry']);

  const handleAdd = () => {

  const handleUpdate = () => {
    update(1, 'Blueberry');

  const handleRemove = () => {

  return (
        {, index) => (
          <li key={index}>{item}</li>
      <button onClick={handleAdd}>Add</button>
      <button onClick={handleUpdate}>Update</button>
      <button onClick={handleRemove}>Remove</button>

In this example, we create an App component that uses the useList hook to manage an array of fruits. We can add items with the push function, update items with the update function, and remove items with the remove function. The current state of the array is accessed through the list property.

Potential Use Cases

The useList hook can be incredibly useful in various scenarios, including:

  1. Image Gallery: The useList hook can aid in managing an image gallery, allowing users to add or remove images from the list. You can use the push function to add new images and the remove function to delete selected images from the gallery.
  2. Sortable Lists: Implementing drag-and-drop functionality to reorder items in a list.
  3. Dynamic Data Rendering: Handling dynamic data fetching and rendering, where the list can be dynamically updated.

Utilizing the useList hook allows for streamlined array manipulation, enhancing the functionality and user experience of your React applications.

Unit Testing the useList Hook

Writing unit tests for your custom hooks is crucial to ensure their correctness and maintainability. Let's explore how we can write unit tests for the useList hook using popular testing libraries such as React Testing Library and Jest.

import { renderHook, act } from '@testing-library/react-hooks';
import useList from './useList';

describe('useList', () => {
  it('should initialize with an empty list', () => {
    const { result } = renderHook(() => useList());


  it('should add items to the list using push', () => {
    const { result } = renderHook(() => useList());

    act(() => {

    expect(result.current.list).toEqual(['Apple', 'Banana']);

  it('should update an item at a specific index', () => {
    const { result } = renderHook(() => useList(['Apple', 'Banana']));

    act(() => {
      result.current.update(1, 'Blueberry');

    expect(result.current.list).toEqual(['Apple', 'Blueberry']);

  it('should remove an item at a specific index', () => {
    const { result } = renderHook(() => useList(['Apple', 'Banana', 'Cherry']));

    act(() => {

    expect(result.current.list).toEqual(['Apple', 'Cherry']);

  // Add more test cases as needed


In the above example, we use the renderHook function from React Testing Library to render the useList hook. We then perform various actions using the act function to simulate the behavior of adding, updating, or removing items from the list. Finally, we assert the expected results using Jest's expect function.

By writing comprehensive unit tests for the useList hook, you can ensure that it behaves correctly and handles array operations as expected. Test cases can include scenarios such as initializing with an empty list, adding items using push, updating items using update, removing items using remove, and other specific use cases relevant to your application.

Remember to test both the expected behavior and edge cases to ensure the robustness of your custom hook.


In conclusion, the useList custom hook provides a powerful solution for managing arrays in React applications. By abstracting away the complexities of array manipulation, the useList hook simplifies the code and improves the readability and maintainability of your components.

Through the utility functions offered by the useList hook, you can effortlessly add, update, and remove items from an array. This makes it an invaluable tool for various scenarios, from managing to-do lists to implementing sortable lists and dynamic data rendering.

By leveraging custom hooks like useList, you can optimize your React development process, write cleaner and more efficient code, and enhance the overall user experience of your applications.

So go ahead, simplify your array manipulation in React with the useList custom hook and unlock a world of possibilities for your React applications.

If you have any further questions or need assistance with anything else, feel free to ask. Happy coding!