¿Cuáles son las definiciones de tipo para React Hooks en TypeScript?

¡Hola! Como proveedor de ganchos, últimamente he recibido muchas preguntas sobre las definiciones de tipos para React Hooks en TypeScript. Entonces, pensé en sentarme y escribir una publicación de blog para compartir lo que sé.

En primer lugar, hablemos de por qué las definiciones de tipos son tan importantes cuando se trabaja con React Hooks en TypeScript. TypeScript es un superconjunto escrito de JavaScript que agrega escritura estática al lenguaje. Esto significa que puede detectar errores en las primeras etapas del proceso de desarrollo definiendo explícitamente los tipos de variables, parámetros de función y valores de retorno. Cuando se utilizan React Hooks, que son una característica relativamente nueva y poderosa de React, tener definiciones de tipos adecuadas puede hacer que su código sea más sólido, más fácil de entender y menos propenso a errores.

utilizar gancho de estado

Empecemos con elusoEstadogancho, que es uno de los ganchos más utilizados en React. ElusoEstadoEl gancho le permite agregar estado a un componente funcional. Así es como puede definir los tipos deusoEstadoen mecanografiado:

importar React, {useState} de 'react'; // Definir el tipo de estado tipo CounterState = número; const Counter: React.FC = () => { // Usa el tipo definido para el estado const [count, setCount] = useState<CounterState>(0); incremento constante = () => { setCount(cuenta + 1); }; return ( <div> <p>Contar: {count}</p> <button onClick={increment}>Increment</button> </div> ); }; exportar contador predeterminado;

En este ejemplo, primero definimos un tipoContraestadoque representa el tipo de estado que queremos usar. Luego, al llamar alusoEstadogancho, especificamos el parámetro de tipo<Contraestado>. Esto le dice a TypeScript que elcontarla variable será de tiponúmero, y elestablecerContarLa función aceptará unnúmerocomo argumento.

utilizar gancho de efecto

ElusoEfectoEl gancho se utiliza para realizar efectos secundarios en componentes funcionales. Al usarusoEfectoen TypeScript, no es necesario especificar ninguna definición de tipo para el gancho en sí. Sin embargo, es posible que necesite definir los tipos de variables y funciones utilizadas dentro delusoEfectollamar de vuelta.

importar React, {useState, useEffect} de 'react'; tipo Datos = { nombre: cadena; edad: número; }; const DataFetcher: React.FC = () => { const [datos, setData] = useState<Datos | nulo>(nulo); useEffect(() => { const fetchData = async () => { const respuesta = esperar fetch('https://example.com/api/data'); resultado constante: Datos = esperar respuesta.json(); setData(resultado); }; fetchData(); }, []); if (!data) { return <p>Cargando...</p>; } return ( <div> <p>Nombre: {data.name}</p> <p>Edad: {data.age}</p> </div> ); }; exportar DataFetcher predeterminado;

En este ejemplo, definimos un tipoDatosque representa la forma de los datos que esperamos recuperar. Usamos este tipo al definir el estado.datosusando elusoEstadogancho. Dentro delusoEfectodevolución de llamada, también utilizamos elDatostipo para especificar el tipo deresultadovariable al analizar la respuesta JSON.

gancho useContext

ElutilizarContextoEl gancho se utiliza para acceder al contexto en un componente funcional. Al usarutilizarContextoen TypeScript, debe definir el tipo de contexto.

importar React, {createContext, useContext} desde 'react'; // Definir el tipo de valor de contexto tipo ThemeContextType = 'light' | 'oscuro'; // Crea el contexto con el tipo definido const ThemeContext = createContext<ThemeContextType>('light'); const ThemeProvider = ThemeContext.Provider; const ThemeDisplay: React.FC = () => { const tema = useContext(ThemeContext); return <p>Tema actual: {tema}</p>; }; Aplicación constante: React.FC = () => { return ( <ThemeProvider value="dark"> <ThemeDisplay /> </ThemeProvider> ); }; exportar la aplicación predeterminada;

En este ejemplo, primero definimos un tipoTipo de contexto de temaque representa los posibles valores del contexto. Luego, al crear el contexto usandocrear contexto, especificamos el parámetro de tipo<Tipo de contexto de tema>. Esto asegura que el valor proporcionado alProveedor de temasy el valor al que se accede usandoutilizarContextoson del tipo correcto.

utilizar gancho reductor

ElutilizarReductorEl gancho es una alternativa ausoEstadopara gestionar una lógica de estado más compleja. Al usarutilizarReductoren TypeScript, debe definir los tipos para el estado, la acción y la función reductora.

importar React, {useReducer} de 'react'; // Definir el tipo de estado tipo CounterState = { count: number; }; // Definir el tipo de acción CounterAction = | { tipo: 'incremento' } | { tipo: 'decremento' }; // Definir la función reductora con tipos const counterReducer = ( estado: CounterState, acción: CounterAction ): CounterState => { switch (action.type) { case 'increment': return { count: state.count + 1 }; caso 'decremento': retorno {recuento: estado.recuento - 1}; predeterminado: estado de retorno; } }; Contador constante: React.FC = () => { const [estado, envío] = useReducer(counterReducer, { recuento: 0 }); return ( <div> <p>Contar: {state.count}</p> <button onClick={() => despacho({ tipo: 'incremento' })}>Incremento</button> <boton onClick={() => despacho({ tipo: 'decremento' })}>Decremento</boton> </div> ); }; exportar contador predeterminado;

En este ejemplo, definimos un tipoContraestadoque representa la forma del estado, y un tipoNeutralizaciónque representa las posibles acciones que se pueden despachar. ElcontadorReductorLa función toma el estado actual y una acción como argumentos y devuelve un nuevo estado. Al definir estos tipos, nos aseguramos de que elutilizarReductorHook y las funciones que interactúan con él utilizan los tipos correctos.

Ganchos personalizados y definiciones de tipos

Al crear enlaces personalizados en TypeScript, también es importante definir las definiciones de tipo apropiadas. Digamos que tenemos un gancho personalizado para manejar las entradas del formulario:

importar React, {useState} de 'react'; // Definir el tipo de formulario tipo de entrada FormInput = { valor: cadena; error: cadena | nulo; }; // Definir el gancho personalizado con tipos const useFormInput = (initialValue: string): FormInput => { const [value, setValue] = useState(initialValue); const [error, setError] = useState<cadena | nulo>(nulo); const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => { setValue(e.target.value); if (e.target.value.length < 3) { setError('La entrada debe tener al menos 3 caracteres'); } más { setError(nulo); } }; devolver {valor, error}; }; Forma constante: React.FC = () => {const {valor, error} = useFormInput(''); return ( <form> <input type="text" value={value} onChange={handleChange} /> {error && <p style={{ color: 'red' }}>{error}</p>} <button type="submit">Enviar</button> </form> ); }; exportar formulario predeterminado;

En este ejemplo, definimos un tipoEntrada de formularioque representa la forma de los datos devueltos por el gancho personalizado. El gancho personalizadoutilizarFormInputtoma un valor inicial como argumento y devuelve un objeto de tipoEntrada de formulario. Esto garantiza que el componente que utiliza el enlace personalizado pueda manejar correctamente los datos devueltos.

Conclusión

En conclusión, utilizar definiciones de tipos adecuadas para React Hooks en TypeScript es esencial para escribir código limpio, fácil de mantener y sin errores. Ya sea que estés usando ganchos incorporados comousoEstado,usoEfecto,utilizarContexto,utilizarReductor, o crear sus propios ganchos personalizados, tomarse el tiempo para definir los tipos correctos puede ahorrarle muchos dolores de cabeza a largo plazo.

Como proveedor de ganchos, entiendo la importancia de ofrecer productos confiables y de alta calidad. Ofrecemos una amplia gama de ganchos para las necesidades de equipamiento de su supermercado, incluidosGanchos para tablero perforadoyGanchos para listones. Estos ganchos están diseñados para ser duraderos, funcionales y fáciles de instalar, lo que los convierte en una excelente opción para cualquier supermercado o tienda minorista.

Si está interesado en obtener más información sobre nuestros ganchos o tiene alguna pregunta sobre las definiciones de tipos para React Hooks en TypeScript, no dude en comunicarse con nosotros para una charla amistosa y una discusión sobre adquisiciones.

Referencias

• Reaccionar documentación oficial
• Documentación oficial de TypeScript