Améliorez vos compétences React : comprendre et utiliser les hooks

Les hooks React sont des fonctions spéciales qui vous permettent d'utiliser les fonctionnalités de React, telles que les méthodes d'état et de cycle de vie, dans des composants fonctionnels. Ils ont été introduits dans React 16.8 pour simplifier le modèle de composant et faciliter le partage de logique avec état entre les composants.

Principales caractéristiques des crochets React :

Gestion de l'état : Des hooks comme useState vous permettent d'ajouter et de gérer l'état des composants fonctionnels sans avoir besoin de les convertir en composants de classe.

Effets secondaires : Le hook useEffect vous permet d'effectuer des effets secondaires, tels que la récupération de données, les abonnements ou la modification manuelle du DOM, similaires aux méthodes de cycle de vie dans les composants de classe.

Réutilisabilité : Les hooks personnalisés vous permettent d'encapsuler et de réutiliser la logique avec état dans différents composants.

Code du nettoyant : Les crochets aident à maintenir les composants en place

Crochets intégrés

1 useState

• Description : Vous permet d'ajouter un état aux composants fonctionnels.
• Exemple :

   import React, { useState } from 'react';

   const Counter = () => {
     const [count, setCount] = useState(0);
     return (
       <div>
         <p>Count: {count}</p>
         <button onClick={() => setCount(count + 1)}>Increment</button>
       </div>
     );
   };

2 useEffect

• Description : Gère les effets secondaires, tels que la récupération de données ou les abonnements, dans les composants fonctionnels.
• Exemple :

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

   const DataFetcher = () => {
     const [data, setData] = useState(null);
     useEffect(() => {
       fetch('https://api.example.com/data')
         .then(response => response.json())
         .then(setData);
     }, []);
     return <div>{data ? JSON.stringify(data) : 'Loading...'}</div>;
   };

3 useContext

• Description : Fournit un accès aux valeurs contextuelles sans avoir besoin d'un consommateur.
• Exemple :

   import React, { useContext } from 'react';

   const ThemeContext = React.createContext('light');

   const ThemedComponent = () => {
     const theme = useContext(ThemeContext);
     return <div className={`theme-${theme}`}>Current theme: {theme}</div>;
   };

4 useReducer

• Description : Gère la logique d'état complexe dans les composants, similaire à Redux.
• Exemple :

   import React, { useReducer } from 'react';

   const initialState = { count: 0 };
   const reducer = (state, action) => {
     switch (action.type) {
       case 'increment':
         return { count: state.count + 1 };
       case 'decrement':
         return { count: state.count - 1 };
       default:
         return state;
     }
   };

   const Counter = () => {
     const [state, dispatch] = useReducer(reducer, initialState);
     return (
       <div>
         <p>Count: {state.count}</p>
         <button onClick={() => dispatch({ type: 'increment' })}>Increment</button>
         <button onClick={() => dispatch({ type: 'decrement' })}>Decrement</button>
       </div>
     );
   };

5 useMemo

• Description : Mémorise une valeur calculée pour optimiser les performances, en évitant les recalculs inutiles.
• Exemple :

   import React, { useMemo, useState } from 'react';

   const ExpensiveComputation = ({ number }) => {
     const compute = (num) => {
       return num * 1000; // Simulate an expensive computation
     };
     const result = useMemo(() => compute(number), [number]);
     return <div>Computed Result: {result}</div>;
   };

6 useCallback

• Description : Renvoie une version mémorisée d'une fonction de rappel qui ne change que si l'une des dépendances a changé.
• Exemple :

   import React, { useCallback, useState } from 'react';

   const Button = React.memo(({ onClick, children }) => {
     console.log('Button rendered');
     return <button onClick={onClick}>{children}</button>;
   });

   const App = () => {
     const [count, setCount] = useState(0);
     const increment = useCallback(() => setCount(c => c + 1), []);
     return (
       <div>
         <p>Count: {count}</p>
         <Button onClick={increment}>Increment</Button>
       </div>
     );
   };

7 useRef

• Description : Renvoie un objet ref mutable qui persiste pendant toute la durée de vie du composant, utile pour accéder directement aux éléments DOM.
• Exemple :

   import React, { useRef } from 'react';

   const FocusInput = () => {
     const inputRef = useRef(null);
     const focusInput = () => {
       inputRef.current.focus();
     };
     return (
       <div>
         <input ref={inputRef} type="text" />
         <button onClick={focusInput}>Focus Input</button>
       </div>
     );
   };

8 useLayoutEffect

• Description : Similaire à useEffect, mais s'exécute de manière synchrone après toutes les mutations du DOM, permettant de mesurer la disposition du DOM.
• Exemple :

   import React, { useLayoutEffect, useRef } from 'react';

   const LayoutEffectExample = () => {
     const divRef = useRef();
     useLayoutEffect(() => {
       console.log('Height:', divRef.current.clientHeight);
     }, []);
     return <div ref={divRef}>This is a div</div>;
   };

9 useImperativeHandle

• Description : Personnalise la valeur d'instance exposée lors de l'utilisation de ref dans les composants parents.
• Exemple :

   import React, { useState } from 'react';

   const Counter = () => {
     const [count, setCount] = useState(0);
     return (
       <div>
         <p>Count: {count}</p>
         <button onClick={() => setCount(count + 1)}>Increment</button>
       </div>
     );
   };

10 useDebugValue
- Description : Affiche une étiquette pour les hooks personnalisés dans React DevTools pour un débogage plus facile.
- Exemple :

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

   const DataFetcher = () => {
     const [data, setData] = useState(null);
     useEffect(() => {
       fetch('https://api.example.com/data')
         .then(response => response.json())
         .then(setData);
     }, []);
     return <div>{data ? JSON.stringify(data) : 'Loading...'}</div>;
   };

Crochets personnalisés

11 useFetch
- Description : Un hook personnalisé pour récupérer des données à partir d'une API.
- Exemple :

   import React, { useContext } from 'react';

   const ThemeContext = React.createContext('light');

   const ThemedComponent = () => {
     const theme = useContext(ThemeContext);
     return <div className={`theme-${theme}`}>Current theme: {theme}</div>;
   };

12 useLocalStorage
- Description : Synchronise l'état avec le stockage local pour conserver les données d'une session à l'autre.
- Exemple :

   import React, { useReducer } from 'react';

   const initialState = { count: 0 };
   const reducer = (state, action) => {
     switch (action.type) {
       case 'increment':
         return { count: state.count + 1 };
       case 'decrement':
         return { count: state.count - 1 };
       default:
         return state;
     }
   };

   const Counter = () => {
     const [state, dispatch] = useReducer(reducer, initialState);
     return (
       <div>
         <p>Count: {state.count}</p>
         <button onClick={() => dispatch({ type: 'increment' })}>Increment</button>
         <button onClick={() => dispatch({ type: 'decrement' })}>Decrement</button>
       </div>
     );
   };

13 utiliserPrécédent
- Description : Renvoie la valeur précédente d'un état ou d'un accessoire.
- Exemple :

   import React, { useMemo, useState } from 'react';

   const ExpensiveComputation = ({ number }) => {
     const compute = (num) => {
       return num * 1000; // Simulate an expensive computation
     };
     const result = useMemo(() => compute(number), [number]);
     return <div>Computed Result: {result}</div>;
   };

14 useDebounce
- Description : Anti-rebond d'un appel de valeur ou de fonction, retardant l'exécution jusqu'après un délai spécifié.
- Exemple :

   import React, { useCallback, useState } from 'react';

   const Button = React.memo(({ onClick, children }) => {
     console.log('Button rendered');
     return <button onClick={onClick}>{children}</button>;
   });

   const App = () => {
     const [count, setCount] = useState(0);
     const increment = useCallback(() => setCount(c => c + 1), []);
     return (
       <div>
         <p>Count: {count}</p>
         <Button onClick={increment}>Increment</Button>
       </div>
     );
   };

15 useOnClickOutside
- Description : Détecte les clics en dehors d'un élément spécifié, utile pour fermer des fenêtres contextuelles ou des listes déroulantes.
- Exemple :

   import React, { useRef } from 'react';

   const FocusInput = () => {
     const inputRef = useRef(null);
     const focusInput = () => {
       inputRef.current.focus();
     };
     return (
       <div>
         <input ref={inputRef} type="text" />
         <button onClick={focusInput}>Focus Input</button>
       </div>
     );
   };

16 useInterval
- Description : Définit un intervalle pour exécuter une fonction à plusieurs reprises à des intervalles spécifiés.
- Exemple :

   import React, { useLayoutEffect, useRef } from 'react';

   const LayoutEffectExample = () => {
     const divRef = useRef();
     useLayoutEffect(() => {
       console.log('Height:', divRef.current.clientHeight);
     }, []);
     return <div ref={divRef}>This is a div</div>;
   };

17 useTimeout
- Description : Définit un délai d'attente pour exécuter une fonction après un délai spécifié.
- Exemple :

   import React, { useImperativeHandle, forwardRef, useRef } from 'react';

   const CustomInput = forwardRef((props, ref) => {
     const inputRef = useRef();
     useImperativeHandle(ref, () => ({
       focus: () => {
         inputRef.current.focus();
       }
     }));
     return <input ref={inputRef} type="text" />;
   });

   const Parent = () => {
     const ref = useRef();
     return (
       <div>
         <CustomInput ref={ref} />
         <button onClick={() => ref.current.focus()}>Focus Input</button>
       </div>
     );
   };

18 useMediaQuery
- Description : Vérifie si une requête multimédia correspond, permettant une logique de conception réactive.
- Exemple :

import { useDebugValue } from 'react';

    const useCustomHook = (value) => {
      useDebugValue(value ? 'Value is true' : 'Value is false');
      return value;
    };

    const DebugExample = () => {
      const isTrue = useCustomHook(true);
      return <div>Check the React DevTools</div>;
    };

19 useScrollPosition
- Description : Suit la position de défilement actuelle de la fenêtre.
- Exemple :

 import { useState, useEffect } from 'react';

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

      useEffect(() => {
        const fetchData = async () => {
          const response = await fetch(url);
          const result = await response.json();
          setData(result);
          setLoading(false);
        };
        fetchData();
      }, [url]);

      return { data, loading };
    };

20 useKeyPress
- Description : Détecte si une touche spécifique est enfoncée.
- Exemple :

import { useState, useEffect } from 'react';

    const useLocalStorage = (key, initialValue) => {
      const [storedValue, setStoredValue] = useState(() => {
        try {
          const item = window.localStorage.getItem(key);
          return item ? JSON.parse(item) : initialValue;
        } catch (error) {
          console.error(error);
          return initialValue;
        }
      });

      useEffect(() => {
        try {
          window.localStorage.setItem(key, JSON.stringify(storedValue));
        } catch (error) {
          console.error(error);
        }
      }, [key, storedValue]);

      return [storedValue, setStoredValue];
    };

Résumé

Cette liste comprend désormais des descriptions pour chaque hook, permettant une compréhension plus claire de leurs objectifs et de leurs cas d'utilisation. Si vous avez besoin de plus de détails ou d'exemples, n'hésitez pas à demander !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!