Améliorez vos compétences React : comprendre et utiliser les hooks-js tutoriel-php.cn

Level Up Your React Skills: Understanding and Using 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>
     );
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>;
   };

Copier après la connexion

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>
     );
   };

Copier après la connexion

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>;
    };

Copier après la connexion

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 };
    };

Copier après la connexion

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];
    };

Copier après la connexion

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!