Comment partager la logique entre les composants à l'aide de crochets personnalisés?

Le partage de la logique entre les composants est un aspect crucial de la construction d'applications de réaction évolutives et maintenables. En tant que fournisseur de crochets, j'ai été témoin de première main la puissance des crochets personnalisés pour atteindre cet objectif. Dans cet article de blog, je vais me plonger sur la façon de partager la logique entre les composants à l'aide de crochets personnalisés, offrant des informations pratiques et des exemples réels.

Comprendre les crochets personnalisés

Avant d'explorer comment partager la logique, comprenons brièvement ce que sont les crochets personnalisés. Les crochets personnalisés sont des fonctions JavaScript qui commencent par le mot «utiliser» et peuvent appeler d'autres crochets. Ils vous permettent d'extraire la logique des composants en fonctions réutilisables. Par exemple, considérons un scénario où plusieurs composants doivent gérer la validation d'entrée du formulaire. Au lieu de dupliquer la logique de validation dans chaque composant, nous pouvons créer un crochet personnalisé.

import {useState} de'Rect '; const useInputValidation = (initialValue = '') => {const [valeur, setValue] = usEstate (initialValue); const [isvalid, setisValid] = useState (true); const handleChange = (e) => {const inputvalue = e.target.value; setValue (inputValue); // Exemple de validation simple: vérifiez si l'entrée n'est pas vide setisValid (inputValue.trim ()! == ''); }; return {value, isvalid, handlechange}; }; Exporter par défaut useInputValidation;

Dans ce crochet personnalisé, nous encapsulons la logique de gestion de l'état et de validation des entrées. Tout composant qui doit gérer la validation d'entrée peut désormais utiliser ce crochet au lieu d'implémenter la logique à partir de zéro.

Partage de logique avec état

L'un des principaux cas d'utilisation pour les crochets personnalisés est le partage de logique avec état entre les composants. La logique avec état implique de gérer l'état dans un composant. Jetons un coup d'œil à la façon dont nous pouvons partager la logique avec état en utilisant des crochets personnalisés.

Imaginez que nous ayons plusieurs composants qui doivent gérer la visibilité d'un modal. Nous pouvons créer un crochet personnalisé pour gérer cette logique.

import {useState} de'Rect '; const usemodalvisibilité = () => {const [isvisible, setisVisible] = useState (false); const showModal = () => {setisVisible (true); }; const HideModal = () => {setSisIble (false); }; return {isVisible, showModal, HideModal}; }; Exporter par défaut UsemodalVisibilité;

Maintenant, tout composant qui doit gérer la visibilité d'un modal peut utiliser ce crochet personnalisé.

importer réagir de'react '; importer usemodalvisibilité à partir de «./usemodalvisibilité»; const modalComponent = () => {const {isVisible, showModal, HideModal} = useModalVisibility (); return (<div> <bouton onClick = {showModal}> afficher modal </ftont> {isVisible && (<div classname = "modal"> <p> Le contenu modal va ici </p> <button onClick = {HideModal}> Fermer Modal </utton> </v>)} </v>); }; exporter par défaut modalComponent;

En utilisant le crochet personnalisé, nous avons partagé avec succès la logique avec état de gérer la visibilité du modal entre les composants.

Partage côté - Logique d'effet

Les crochets personnalisés sont également excellents pour le partage de la logique des effets. Les effets latéraux incluent des choses comme la récupération des données, les abonnements et les manipulations DOM.

Disons que nous avons plusieurs composants qui doivent récupérer les données d'une API. Nous pouvons créer un crochet personnalisé pour gérer la logique de récupération des données.

import {useState, useEffecte} from'React '; const usageDataFetching = (url) => {const [data, setData] = useState (null); const [IsoLinging, setSoLing] = USESTATE (true); const [error, setError] = useState (null); useEFFECT (() => {const fetchData = async () => {try {const {const Response = wait fetch (url); if (! réponse.ok) {throw new error ('le réseau n'a pas été ok');} const result = wait réponse.json (); setData (résultat);} catch (err) {SetError (err);} enfin {set);}};};}; fetchData ();}, [url]); return {data, isLoading, error}; }; Exporter par défaut usedataFetching;

Maintenant, tout composant qui doit récupérer les données d'une API peut utiliser ce crochet personnalisé.

importer réagir de'react '; importer usedatafetching à partir de './usedatafetching'; const dataComponent = () => {const {data, isloading, error} = usedatafetching ('https://api.example.com/data'); if (isLoading) {return <p> chargement ... </p>; } if (error) {return <p> error: {error.Message} </p>; } return (<div> {data && <pre> {JSON.StRingify (data, null, 2)} </ Pre>} </div>); }; Exporter DataComponent par défaut;

Applications pratiques dans l'industrie des accessoires de salle de bain

En tant que fournisseur de crochets, je comprends l'importance des applications pratiques. Par exemple, dans l'industrie des accessoires de salle de bain, nous pouvons utiliser des crochets personnalisés pour gérer l'état des listes de produits.

Disons que nous avons un composant qui affiche une liste deCrochets de serviettes accessoires de salle de bainet un autre composant qui afficheCrochets de salle de bain en or. Nous pouvons créer un crochet personnalisé pour gérer le filtrage et le tri de ces produits.

import {useState} de'Rect '; const useproductFiltering = (initialProducts) => {const [produits, setProducts] = USESTate (InitialProducts); const [filtre, setFilter] = useState (''); const handleFilterChange = (e) => {const filterValue = e.target.value; setFilter (filterValue); const FilteredProducts = initialProducts.filter (produit => product.name.tolowercase (). inclut (filterValue.tolowerCase ())); SetProducts (Produits filtrés); }; return {Products, filtre, manchefilterchange}; }; Exporter par défaut useProductFiltering;

Désormais, les crochets de serviette et les composants de crochets de salle de bain en or peuvent utiliser ce crochet personnalisé pour gérer le filtrage des produits.

Conclusion et appel à l'action

En conclusion, les crochets personnalisés sont un outil puissant pour partager la logique entre les composants. Ils améliorent la réutilisabilité du code, la maintenabilité et rendent nos applications REACT plus évolutives. En tant que fournisseur de crochets, je m'engage à fournir des solutions de haute qualité pour partager la logique dans vos projets.

Si vous souhaitez en savoir plus sur la façon dont nos crochets personnalisés peuvent bénéficier à votre entreprise, ou si vous cherchez à commencer une discussion sur les achats, n'hésitez pas à vous contacter. Nous sommes ici pour vous aider à créer de meilleures applications réagi avec un partage logique efficace.

Références

• React Documentation officielle sur les crochets personnalisés
• "React: Running" par Stoyan Stefanov et Eve Porcello