M

MLOG

Español

Aprenda a aprovechar los custom hooks de React para extraer y reutilizar la lógica de los componentes, mejorando la mantenibilidad, la capacidad de prueba y la arquitectura general de la aplicación.

React Custom Hooks: Extrayendo la Lógica del Componente para la Reutilización

Los hooks de React han revolucionado la forma en que escribimos componentes de React, ofreciendo una manera más elegante y eficiente de gestionar el estado y los efectos secundarios. Entre los diversos hooks disponibles, los custom hooks destacan como una herramienta poderosa para extraer y reutilizar la lógica del componente. Este artículo proporciona una guía completa para comprender e implementar custom hooks de React, lo que le permite construir aplicaciones más mantenibles, testeables y escalables.

¿Qué son los Custom Hooks de React?

En esencia, un custom hook es una función de JavaScript cuyo nombre comienza con "use" y puede llamar a otros hooks. Le permite extraer la lógica del componente en funciones reutilizables, eliminando así la duplicación de código y promoviendo una estructura de componente más limpia. A diferencia de los componentes React regulares, los custom hooks no renderizan ninguna interfaz de usuario; simplemente encapsulan la lógica.

Piense en ellos como funciones reutilizables que pueden acceder al estado y las características del ciclo de vida de React. Son una forma fantástica de compartir la lógica con estado entre diferentes componentes sin recurrir a componentes de orden superior o render props, lo que a menudo puede conducir a un código que es difícil de leer y mantener.

¿Por qué usar Custom Hooks?

Los beneficios de usar custom hooks son numerosos:

Creando su Primer Custom Hook

Ilustremos la creación y el uso de un custom hook con un ejemplo práctico: la obtención de datos de una API.

Ejemplo: useFetch - Un Hook para la Obtención de Datos

Imagine que necesita frecuentemente obtener datos de diferentes API en su aplicación React. En lugar de repetir la lógica de obtención en cada componente, puede crear un hook useFetch.


import { useState, useEffect } from 'react';

function useFetch(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const abortController = new AbortController();
    const signal = abortController.signal;

    const fetchData = async () => {
      setLoading(true);
      try {
        const response = await fetch(url, { signal: signal });
        if (!response.ok) {
          throw new Error(`Error HTTP! Estado: ${response.status}`);
        }
        const json = await response.json();
        setData(json);
        setError(null); // Borrar cualquier error previo
      } catch (error) {
        if (error.name === 'AbortError') {
          console.log('Obtención abortada');
        } else {
          setError(error);
        }
        setData(null); // Borrar cualquier dato previo
      } finally {
        setLoading(false);
      }
    };

    fetchData();

    return () => {
      abortController.abort(); // Función de limpieza para abortar la obtención al desmontar o cambiar la URL
    };
  }, [url]); // Re-ejecutar el efecto cuando la URL cambia

  return { data, loading, error };
}

export default useFetch;

Explicación:

Usando el Hook useFetch en un Componente

Ahora, veamos cómo usar este custom hook en un componente de React:


import React from 'react';
import useFetch from './useFetch';

function UserList() {
  const { data: users, loading, error } = useFetch('https://jsonplaceholder.typicode.com/users');

  if (loading) return <p>Cargando usuarios...</p>;
  if (error) return <p>Error: {error.message}</p>;
  if (!users) return <p>No se encontraron usuarios.</p>;

  return (
    <ul>
      {users.map(user => (
        <li key={user.id}>{user.name} ({user.email})</li>
      ))}
    </ul>
  );
}

export default UserList;

Explicación:

Patrones Avanzados de Custom Hooks

Más allá de la simple obtención de datos, los custom hooks se pueden usar para encapsular una lógica más compleja. Aquí hay algunos patrones avanzados:

1. Gestión de Estado con useReducer

Para escenarios de gestión de estado más complejos, puede combinar custom hooks con useReducer. Esto le permite gestionar las transiciones de estado de una manera más predecible y organizada.


import { useReducer } from 'react';

const initialState = { count: 0 };

function reducer(state, action) {
  switch (action.type) {
    case 'increment':
      return { count: state.count + 1 };
    case 'decrement':
      return { count: state.count - 1 };
    default:
      throw new Error();
  }
}

function useCounter() {
  const [state, dispatch] = useReducer(reducer, initialState);

  const increment = () => dispatch({ type: 'increment' });
  const decrement = () => dispatch({ type: 'decrement' });

  return { count: state.count, increment, decrement };
}

export default useCounter;

Uso:


import React from 'react';
import useCounter from './useCounter';

function Counter() {
  const { count, increment, decrement } = useCounter();

  return (
    <div>
      <p>Contador: {count}</p>
      <button onClick={increment}>Incrementar</button>
      <button onClick={decrement}>Decrementar</button>
    </div>
  );
}

export default Counter;

2. Integración de Contexto con useContext

Los custom hooks también se pueden usar para simplificar el acceso al Contexto de React. En lugar de usar useContext directamente en sus componentes, puede crear un custom hook que encapsule la lógica de acceso al contexto.


import { useContext } from 'react';
import { ThemeContext } from './ThemeContext'; // Asumiendo que tiene un ThemeContext

function useTheme() {
  return useContext(ThemeContext);
}

export default useTheme;

Uso:


import React from 'react';
import useTheme from './useTheme';

function MyComponent() {
  const { theme, toggleTheme } = useTheme();

  return (
    <div style={{ backgroundColor: theme.background, color: theme.color }}>
      <p>Este es mi componente.</p>
      <button onClick={toggleTheme}>Alternar Tema</button>
    </div>
  );
}

export default MyComponent;

3. Debouncing y Throttling

Debouncing y throttling son técnicas utilizadas para controlar la velocidad a la que se ejecuta una función. Los custom hooks se pueden usar para encapsular esta lógica, facilitando la aplicación de estas técnicas a los manejadores de eventos.


import { useState, useEffect, useRef } from 'react';

function useDebounce(value, delay) {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const handler = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    return () => {
      clearTimeout(handler);
    };
  }, [value, delay]);

  return debouncedValue;
}

export default useDebounce;

Uso:


import React, { useState } from 'react';
import useDebounce from './useDebounce';

function SearchInput() {
  const [searchValue, setSearchValue] = useState('');
  const debouncedSearchValue = useDebounce(searchValue, 500); // Debounce por 500ms

  useEffect(() => {
    // Realizar la búsqueda con debouncedSearchValue
    console.log('Buscando por:', debouncedSearchValue);
    // Reemplace console.log con su lógica de búsqueda real
  }, [debouncedSearchValue]);

  const handleChange = (event) => {
    setSearchValue(event.target.value);
  };

  return (
    <input
      type="text"
      value={searchValue}
      onChange={handleChange}
      placeholder="Buscar..."
    />
  );
}

export default SearchInput;

Mejores Prácticas para Escribir Custom Hooks

Para asegurar que sus custom hooks sean efectivos y mantenibles, siga estas mejores prácticas:

Consideraciones Globales

Al desarrollar aplicaciones para una audiencia global, tenga en cuenta lo siguiente:

Ejemplo: Formato de Fecha Internacionalizado con un Custom Hook


import { useState, useEffect } from 'react';
import { DateTimeFormat } from 'intl';

function useFormattedDate(date, locale) {
  const [formattedDate, setFormattedDate] = useState('');

  useEffect(() => {
    try {
      const formatter = new DateTimeFormat(locale, {
        year: 'numeric',
        month: 'long',
        day: 'numeric',
      });
      setFormattedDate(formatter.format(date));
    } catch (error) {
      console.error('Error formateando la fecha:', error);
      setFormattedDate('Fecha Inválida');
    }
  }, [date, locale]);

  return formattedDate;
}

export default useFormattedDate;

Uso:


import React from 'react';
import useFormattedDate from './useFormattedDate';

function MyComponent() {
  const today = new Date();
  const enDate = useFormattedDate(today, 'en-US');
  const frDate = useFormattedDate(today, 'fr-FR');
  const deDate = useFormattedDate(today, 'de-DE');

  return (
    <div>
      <p>Fecha en EE.UU.: {enDate}</p>
      <p>Fecha en Francés: {frDate}</p>
      <p>Fecha en Alemán: {deDate}</p>
    </div>
  );
}

export default MyComponent;

Conclusión

Los custom hooks de React son un mecanismo poderoso para extraer y reutilizar la lógica del componente. Al aprovechar los custom hooks, puede escribir código más limpio, más mantenible y testeable. A medida que se vuelve más proficiente con React, dominar los custom hooks mejorará significativamente su capacidad para construir aplicaciones complejas y escalables. Recuerde seguir las mejores prácticas y considerar los factores globales al desarrollar custom hooks para asegurar que sean efectivos y accesibles para una audiencia diversa. ¡Abrace el poder de los custom hooks y eleve sus habilidades de desarrollo en React!

React Custom Hooks: Extrayendo la Lógica del Componente para la Reutilización | MLOG