Quais são as definições de tipo para React Hooks no TypeScript? - Blog

Ei! Como fornecedor de ganchos, tenho recebido muitas perguntas ultimamente sobre as definições de tipo para React Hooks no TypeScript. Então, pensei em sentar e escrever uma postagem no blog para compartilhar o que sei.

Primeiro, vamos falar sobre por que as definições de tipo são tão importantes ao trabalhar com React Hooks no TypeScript. TypeScript é um superconjunto digitado de JavaScript que adiciona digitação estática à linguagem. Isso significa que você pode detectar erros no início do processo de desenvolvimento definindo explicitamente os tipos de variáveis, parâmetros de função e valores de retorno. Ao usar React Hooks, que é um recurso relativamente novo e poderoso no React, ter definições de tipo adequadas pode tornar seu código mais robusto, mais fácil de entender e menos sujeito a erros.

useState Gancho

Vamos começar com ousarEstadohook, que é um dos ganchos mais comumente usados no React. OusarEstadohook permite adicionar estado a um componente funcional. Veja como você pode definir os tipos deusarEstadoem TypeScript:

importar React, {useState} de 'react'; // Define o tipo do estado type CounterState = number; const Counter: React.FC = () => { // Use o tipo definido para o estado const [count, setCount] = useState<CounterState>(0); const incremento = () => { setCount(contagem + 1); }; return ( <div> <p>Contagem: {count}</p> <button onClick={increment}>Incremento</button> </div> ); }; exportar contador padrão;

Neste exemplo, primeiro definimos um tipoContraEstadoque representa o tipo de estado que queremos usar. Então, ao ligar para ousarEstadohook, especificamos o parâmetro de tipo<ContraEstado>. Isso informa ao TypeScript que ocontarvariável será do tiponúmero, e odefinirContagemfunção aceitará umnúmerocomo argumento.

useEfeito Gancho

OuseEfeitohook é usado para realizar efeitos colaterais em componentes funcionais. Ao usaruseEfeitono TypeScript, você não precisa especificar nenhuma definição de tipo para o próprio gancho. No entanto, talvez seja necessário definir os tipos de variáveis e funções usadas dentro douseEfeitoligar de volta.

importar React, { useState, useEffect } de 'react'; tipo Dados = { nome: string; idade: número; }; const DataFetcher: React.FC = () => { const [dados, setData] = useState<Dados | nulo>(nulo); useEffect(() => { const fetchData = async () => { const response = await fetch('https://example.com/api/data'); resultado const: Data = await response.json(); setData(resultado); }; fetchData(); }, []); if (!data) { return <p>Carregando...</p>; } return ( <div> <p>Nome: {data.name}</p> <p>Idade: {data.age}</p> </div> ); }; exportar DataFetcher padrão;

Neste exemplo, definimos um tipoDadosque representa a forma dos dados que esperamos buscar. Usamos esse tipo ao definir o estadodadosusando ousarEstadogancho. Dentro douseEfeitoretorno de chamada, também usamos oDadostype para especificar o tipo doresultadovariável ao analisar a resposta JSON.

gancho useContext

OuseContexthook é usado para acessar o contexto em um componente funcional. Ao usaruseContextno TypeScript, você precisa definir o tipo de contexto.

importar React, {createContext, useContext} de 'react'; // Define o tipo do valor de contexto type ThemeContextType = 'light' | 'escuro'; // Cria o contexto com o tipo definido const ThemeContext = createContext<ThemeContextType>('light'); const ThemeProvider = ThemeContext.Provider; const ThemeDisplay: React.FC = () => { const tema = useContext(ThemeContext); return <p>Tema atual: {theme}</p>; }; aplicativo const: React.FC = () => { return ( <ThemeProvider value="dark"> <ThemeDisplay /> </ThemeProvider> ); }; exportar aplicativo padrão;

Neste exemplo, primeiro definimos um tipoTemaContextTypeque representa os valores possíveis do contexto. Então, ao criar o contexto usandocriarContexto, especificamos o parâmetro de tipo<TemaContextType>. Isso garante que o valor fornecido aoProvedor de temae o valor acessado usandouseContextsão do tipo correto.

0153_1 0154_1

useReducer Gancho

OusarRedutorgancho é uma alternativa parausarEstadopara gerenciar lógicas de estado mais complexas. Ao usarusarRedutorno TypeScript, você precisa definir os tipos de estado, ação e função redutora.

importar React, { useReducer } de 'react'; // Define o tipo do estado type CounterState = { count: number; }; // Define o tipo de ação tipo CounterAction = | { tipo: 'incremento' } | { tipo: 'decrementar' }; // Defina a função redutora com os tipos const counterReducer = ( state: CounterState, action: CounterAction ): CounterState => { switch (action.type) { case 'increment': return { count: state.count + 1 }; case 'decrement': return { contagem: state.count - 1 }; padrão: estado de retorno; } }; const Contador: React.FC = () => { const [estado, despacho] = useReducer (counterReducer, { contagem: 0 }); return ( <div> <p>Contagem: {state.count}</p> <button onClick={() => expedição({ type: 'increment' })}>Incremento</button> <button onClick={() => expedição({ type: 'decrement' })}>Decremento</button> </div> ); }; exportar contador padrão;

Neste exemplo, definimos um tipoContraEstadoque representa a forma do estado, e um tipoContra-açãoque representa as possíveis ações que podem ser despachadas. OcontadorRedutorA função recebe o estado atual e uma ação como argumentos e retorna um novo estado. Ao definir esses tipos, garantimos que ousarRedutorhook e as funções que interagem com ele usam os tipos corretos.

Ganchos personalizados e definições de tipo

Ao criar ganchos personalizados no TypeScript, também é importante definir as definições de tipo apropriadas. Digamos que temos um gancho personalizado para lidar com entradas de formulário:

importar React, {useState} de 'react'; // Define o tipo do formulário input type FormInput = { value: string; erro: string | nulo; }; // Defina o gancho personalizado com tipos const useFormInput = (initialValue: string): FormInput => { const [value, setValue] = useState(initialValue); const [erro, setError] = useState<string | nulo>(nulo); const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => { setValue(e.target.value); if (e.target.value.length <3) { setError('A entrada deve ter pelo menos 3 caracteres'); } else { setError(null); } }; return {valor, erro}; }; Formulário const: React.FC = () => { const { valor, erro } = useFormInput (''); return ( <form> <input type="text" value={value} onChange={handleChange} /> {error && <p style={{ color: 'red' }}>{error}</p>} <button type="submit">Enviar</button> </form> ); }; exportar formulário padrão;

Neste exemplo, definimos um tipoFormInputque representa a forma dos dados retornados pelo gancho personalizado. O gancho personalizadouseFormInputrecebe um valor inicial como argumento e retorna um objeto do tipoFormInput. Isso garante que o componente que usa o gancho personalizado possa manipular adequadamente os dados retornados.

Conclusão

Concluindo, usar definições de tipo adequadas para React Hooks no TypeScript é essencial para escrever código limpo, sustentável e livre de erros. Esteja você usando ganchos integrados comousarEstado,useEfeito,useContext,usarRedutor, ou criar seus próprios ganchos personalizados, reservar um tempo para definir os tipos corretos pode evitar muitas dores de cabeça no longo prazo.

Como fornecedor de ganchos, entendo a importância de fornecer produtos confiáveis e de alta qualidade. Oferecemos uma ampla variedade de ganchos para suas necessidades de equipamentos de supermercado, incluindoGanchos para pranchas de madeiraeGanchos de Slatwall. Esses ganchos são projetados para serem duráveis, funcionais e fáceis de instalar, o que os torna uma ótima opção para qualquer supermercado ou loja de varejo.

Se você estiver interessado em aprender mais sobre nossos ganchos ou tiver alguma dúvida sobre as definições de tipo para React Hooks no TypeScript, sinta-se à vontade para entrar em contato conosco para um bate-papo amigável e uma discussão sobre compras.

Referências

Documentação oficial do React
Documentação oficial do TypeScript