Quelles sont les définitions de type pour React Hooks dans TypeScript ?

Salut! En tant que fournisseur de hooks, j'ai reçu récemment beaucoup de questions sur les définitions de type pour React Hooks dans TypeScript. J'ai donc pensé m'asseoir et écrire un article de blog pour partager ce que je sais.

Tout d'abord, parlons des raisons pour lesquelles les définitions de types sont si importantes lorsque vous travaillez avec React Hooks dans TypeScript. TypeScript est un sur-ensemble typé de JavaScript qui ajoute un typage statique au langage. Cela signifie que vous pouvez détecter les erreurs dès le début du processus de développement en définissant explicitement les types de variables, les paramètres de fonction et les valeurs de retour. Lorsque vous utilisez React Hooks, qui sont une fonctionnalité relativement nouvelle et puissante de React, disposer de définitions de type appropriées peut rendre votre code plus robuste, plus facile à comprendre et moins sujet aux erreurs.

useState Hook

Commençons par leutiliserÉtathook, qui est l’un des hooks les plus couramment utilisés dans React. LeutiliserÉtathook vous permet d’ajouter un état à un composant fonctionnel. Voici comment définir les types pourutiliserÉtaten TypeScript :

importer React, {useState} depuis 'react' ; // Définit le type du type d'état CounterState = number; const Counter : React.FC = () => { // Utiliser le type défini pour l'état const [count, setCount] = useState<CounterState>(0); const incrément = () => { setCount(count + 1); } ; return ( <div> <p>Count : {count}</p> <button onClick={increment}>Incrément</button> </div> ); } ; exporter le compteur par défaut ;

Dans cet exemple, nous définissons d'abord un typeContre-étatqui représente le type d’état que nous voulons utiliser. Ensuite, en appelant leutiliserÉtathook, nous spécifions le paramètre type<ÉtatContre>. Cela indique à TypeScript que lecompterla variable sera de typenombre, et lesetCountla fonction acceptera unnombrecomme argument.

utiliser le crochet d'effet

LeutiliserEffetLe crochet est utilisé pour effectuer des effets secondaires dans les composants fonctionnels. Lors de l'utilisationutiliserEffetdans TypeScript, vous n'avez pas besoin de spécifier de définitions de type pour le hook lui-même. Cependant, vous devrez peut-être définir les types des variables et des fonctions utilisées dans leutiliserEffetrappel.

importer React, { useState, useEffect } depuis 'react' ; tapez Data = { nom : chaîne ; âge : nombre ; } ; const DataFetcher : React.FC = () => { const [data, setData] = useState<Data | nul>(nul); useEffect(() => { const fetchData = async () => { const réponse = wait fetch('https://example.com/api/data'); résultat const : Data = wait réponse.json(); setData(result); }; fetchData(); }, []); if (!data) { return <p>Chargement...</p>; } return ( <div> <p>Nom : {data.name}</p> <p>Âge : {data.age}</p> </div> ); } ; exporter le DataFetcher par défaut ;

Dans cet exemple, nous définissons un typeDonnéesqui représente la forme des données que nous espérons récupérer. Nous utilisons ce type lors de la définition de l'étatdonnéesen utilisant leutiliserÉtatcrochet. À l'intérieur duutiliserEffetrappel, nous utilisons également leDonnéestype pour spécifier le type durésultatvariable lors de l'analyse de la réponse JSON.

useContext Hook

LeutiliserContextle hook est utilisé pour accéder au contexte dans un composant fonctionnel. Lors de l'utilisationutiliserContextdans TypeScript, vous devez définir le type du contexte.

importer React, { createContext, useContext } depuis 'react' ; // Définit le type de valeur de contexte ThemeContextType = 'light' | 'sombre'; // Crée le contexte avec le type défini const ThemeContext = createContext<ThemeContextType>('light'); const ThemeProvider = ThemeContext.Provider; const ThemeDisplay : React.FC = () => { const theme = useContext(ThemeContext); return <p>Thème actuel : {theme}</p> ; } ; const App : React.FC = () => { return ( <ThemeProvider value="dark"> <ThemeDisplay /> </ThemeProvider> ); } ; exporter l'application par défaut ;

Dans cet exemple, nous définissons d'abord un typeThèmeContextTypequi représente les valeurs possibles du contexte. Ensuite, lors de la création du contexte en utilisantcréerContext, nous précisons le paramètre type<ThèmeContextType>. Cela garantit que la valeur fournie auFournisseur de thèmeet la valeur accessible en utilisantutiliserContextsont du bon type.

utiliser le crochet réducteur

LeutiliserRéducteurle crochet est une alternative àutiliserÉtatpour gérer une logique d’état plus complexe. Lors de l'utilisationutiliserRéducteurdans TypeScript, vous devez définir les types de l'état, de l'action et de la fonction de réduction.

importer React, {useReducer} depuis 'react' ; // Définit le type du type d'état CounterState = { count: number; } ; // Définir le type du type d'action CounterAction = | { tapez : 'incrément' } | { tapez : 'décrémenter' } ; // Définissez la fonction réductrice avec les types const counterReducer = ( state: CounterState, action: CounterAction ): CounterState => { switch (action.type) { case 'increment': return { count: state.count + 1 }; case 'décrément' : return { count: state.count - 1 } ; par défaut : état de retour ; } } ; const Compteur : React.FC = () => { const [state, dispatch] = useReducer(counterReducer, { count: 0 }); return ( <div> <p>Count : {state.count}</p> <button onClick={() => dispatch({ type: 'increment' })}>Increment</button> <button onClick={() => dispatch({ type: 'decrement' })}>Décrément</button> </div> ); } ; exporter le compteur par défaut ;

Dans cet exemple, nous définissons un typeContre-étatqui représente la forme de l'État, et un typeNeutralisationqui représente les actions possibles qui peuvent être envoyées. LecompteurRéducteurLa fonction prend l'état actuel et une action comme arguments et renvoie un nouvel état. En définissant ces types, nous nous assurons que leutiliserRéducteurhook et les fonctions qui interagissent avec lui utilisent les types corrects.

Crochets personnalisés et définitions de types

Lors de la création de hooks personnalisés dans TypeScript, il est également important de définir les définitions de type appropriées. Disons que nous avons un hook personnalisé pour gérer les entrées de formulaire :

importer React, {useState} depuis 'react' ; // Définit le type du type d'entrée du formulaire FormInput = { value: string; erreur : chaîne | nul; } ; // Définissez le hook personnalisé avec les types const useFormInput = (initialValue : string) : FormInput => { const [value, setValue] = useState(initialValue); const [erreur, setError] = useState<string | nul>(nul); const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => { setValue(e.target.value); if (e.target.value.length < 3) { setError('L'entrée doit contenir au moins 3 caractères'); } autre { setError(null); } } ; return {valeur, erreur} ; } ; Forme const : React.FC = () => { const { valeur, erreur } = useFormInput(''); return ( <form> <input type="text" value={value} onChange={handleChange} /> {error && <p style={{ color: 'red' }}>{error}</p>} <button type="submit">Soumettre</button> </form> ); } ; exporter le formulaire par défaut ;

Dans cet exemple, nous définissons un typeEntrée de formulairequi représente la forme des données renvoyées par le hook personnalisé. Le crochet personnaliséutiliserFormInputprend une valeur initiale comme argument et renvoie un objet de typeEntrée de formulaire. Cela garantit que le composant utilisant le hook personnalisé peut gérer correctement les données renvoyées.

Conclusion

En conclusion, l'utilisation de définitions de type appropriées pour React Hooks dans TypeScript est essentielle pour écrire du code propre, maintenable et sans erreur. Que vous utilisiez des hooks intégrés commeutiliserÉtat,utiliserEffet,utiliserContext,utiliserRéducteur, ou en créant vos propres hooks personnalisés, prendre le temps de définir les types corrects peut vous éviter bien des maux de tête à long terme.

En tant que fournisseur de crochets, je comprends l'importance de fournir des produits fiables et de haute qualité. Nous proposons une large gamme de crochets pour vos besoins en équipement de supermarché, notammentCrochets pour panneaux perforésetCrochets à lattes. Ces crochets sont conçus pour être durables, fonctionnels et faciles à installer, ce qui en fait un excellent choix pour tout supermarché ou magasin de détail.

Si vous souhaitez en savoir plus sur nos hooks ou si vous avez des questions sur les définitions de type pour React Hooks dans TypeScript, n'hésitez pas à nous contacter pour une discussion amicale et une discussion sur l'approvisionnement.

Références

• Réagissez à la documentation officielle
• Documentation officielle de TypeScript