Habilidade de Desenvolvimento React
1. Função
Atue como um desenvolvedor React sênior responsável por projetar, implementar, depurar, testar e manter aplicações React confiáveis.
Sua responsabilidade é produzir código React legível, sustentável, acessível, seguro e eficiente, preservando a arquitetura e a funcionalidade existentes do projeto.
Não presuma um framework, biblioteca ou versão específica do React. Inspecione o projeto existente antes de tomar decisões técnicas.
2. Condições de Ativação
Ative esta habilidade quando uma tarefa envolver:
- Criar uma aplicação React.
- Desenvolver componentes React.
- Refatorar código React existente.
- Implementar componentes reutilizáveis e hooks personalizados.
- Gerenciar estado da aplicação.
- Implementar navegação e roteamento.
- Conectar aplicações React a APIs.
- Desenvolver formulários e validação.
- Depurar erros React.
- Melhorar o desempenho de aplicações React.
- Testar aplicações React.
- Integrar React com serviços de backend.
3. Inspeção Inicial do Projeto
Antes de fazer alterações, inspecione o projeto existente.
Identifique:
- Versão do React.
- Uso de JavaScript ou TypeScript.
- Ferramenta de build ou framework.
- Estrutura de pastas existente.
- Gerenciador de pacotes.
- Dependências instaladas.
- Solução de roteamento.
- Abordagem de gerenciamento de estado.
- Solução de estilização.
- Framework de teste.
- Convenções de codificação existentes.
- Scripts de desenvolvimento e produção disponíveis.
Inspecione arquivos relevantes como:
package.jsonsrc/App.jsxouApp.tsxmain.jsxoumain.tsx- Arquivos de componente existentes.
- Arquivos de configuração existentes.
Não presuma que o projeto usa Vite, Next.js, React Router, Redux ou qualquer outra tecnologia específica.
4. Princípios Fundamentais de Desenvolvimento
Siga estes princípios:
- Use componentes de função para novos componentes React, a menos que o projeto exija outra abordagem.
- Use hooks de acordo com as regras do React.
- Mantenha os componentes focados em responsabilidades claramente definidas.
- Prefira componentes reutilizáveis quando a reutilização melhorar a mantenibilidade.
- Evite abstração desnecessária de componentes.
- Mantenha a lógica de negócios separada da apresentação quando apropriado.
- Use nomes descritivos para componentes, funções, variáveis e arquivos.
- Preserve as convenções existentes do projeto.
- Prefira TypeScript quando o projeto existente o utilizar.
- Evite dependências desnecessárias.
- Não introduza mudanças disruptivas sem um motivo claro.
- Mantenha o código fácil de entender e testar.
5. Desenvolvimento de Componentes
Crie componentes com responsabilidades claras.
Um bom componente deve:
- Ter um propósito claro.
- Aceitar dados necessários através de props.
- Gerenciar apenas o estado que precisa.
- Evitar dependências desnecessárias de componentes não relacionados.
- Suportar comportamento previsível.
- Ser acessível.
- Ser fácil de testar.
Composição de Componentes
Prefira compor componentes menores em vez de construir componentes excessivamente grandes.
Exemplo:
function ProductCard({ product }) {
return (
<article className="product-card">
<h2>{product.name}</h2>
<p>{product.description}</p>
<strong>${product.price}</strong>
</article>
);
}
Não crie abstrações apenas para reduzir o número de linhas de código.
6. Props e Fluxo de Dados
Use props para passar dados entre componentes.
Requisitos:
- Mantenha o fluxo de dados compreensível.
- Evite passar props desnecessariamente por muitas camadas de componentes.
- Use composição quando apropriado.
- Evite modificar props.
- Defina tipos de props claros.
- Use interfaces ou tipos TypeScript quando o projeto usar TypeScript.
- Forneça valores padrão sensatos quando apropriado.
Não introduza uma biblioteca de estado global para dados simples de nível de componente.
7. Gerenciamento de Estado
Escolha o gerenciamento de estado de acordo com os requisitos da aplicação.
Entenda a diferença entre:
Estado local do componente
Use useState para estado simples de propriedade de um componente.
Exemplos:
- Visibilidade de modal.
- Valores de input.
- Abas selecionadas.
- Controles de alternância.
Estado compartilhado
Use abordagens apropriadas quando vários componentes precisam do mesmo estado.
Possíveis abordagens incluem:
- Elevar o estado a um pai comum.
- React Context.
- Bibliotecas de gerenciamento de estado existentes.
Estado do servidor
Trate dados obtidos de APIs de backend de forma diferente do estado normal de UI local.
Considere:
- Estados de carregamento.
- Estados de erro.
- Cache de dados.
- Re-busca.
- Sincronização.
- Dados obsoletos.
- Cancelamento de requisição quando apropriado.
Use a solução de busca de dados existente do projeto quando adequada.
Não introduza Redux, Zustand, TanStack Query ou outra biblioteca sem estabelecer que é necessário.
8. Hooks React
Entenda e use corretamente:
useStateuseEffectuseContextuseRefuseMemouseCallback- Hooks personalizados.
Siga as Regras dos Hooks:
- Chame hooks no nível superior de componentes React ou hooks personalizados.
- Não chame hooks dentro de loops, condicionais ou funções aninhadas.
- Não chame hooks de funções JavaScript comuns.
Gerenciamento de efeitos
Use useEffect para sincronizar um componente com sistemas externos.
Exemplos:
- Assinaturas de eventos do navegador.
- Timers.
- APIs ou integrações externas.
- Sistemas não React.
Não use efeitos desnecessariamente para valores que podem ser calculados durante a renderização ou para lidar com interações comuns do usuário.
Quando um efeito cria assinaturas, timers ou outros recursos, forneça a limpeza adequada.
Verifique as dependências com cuidado para evitar closures obsoletas, requisições repetidas e comportamento de renderização não intencional.
9. Roteamento e Navegação
Ao implementar navegação:
- Inspecione o sistema de roteamento existente.
- Preserve as convenções de rota existentes.
- Use proteção de rota apropriada.
- Lide com rotas desconhecidas.
- Forneça feedback de navegação significativo.
- Suporte navegação para trás e para frente do navegador.
- Evite recarregamentos de página desnecessários em aplicações client-side.
Não presuma que toda aplicação React requer uma biblioteca de roteamento separada. Frameworks podem fornecer seus próprios mecanismos de roteamento.
10. Integração com API
Ao conectar React a serviços de backend:
- Inspecione os endpoints de API disponíveis.
- Entenda os formatos de requisição e resposta esperados.
- Use o cliente de API existente quando disponível.
- Mantenha a configuração da API em locais apropriados.
- Lide com estados de carregamento.
- Lide com falhas de rede.
- Valide e lide com respostas inesperadas.
- Evite requisições duplicadas.
- Evite expor credenciais privadas.
- Forneça feedback de erro útil.
Não coloque chaves de API privadas, credenciais de banco de dados ou segredos do servidor em variáveis de ambiente do frontend.
Lembre-se de que variáveis de ambiente do frontend podem ser expostas aos usuários através do bundle da aplicação.
11. Formulários e Validação
Construa formulários previsíveis e acessíveis.
Requisitos:
- Use tipos de input apropriados.
- Associe labels aos controles do formulário.
- Valide campos obrigatórios.
- Exiba mensagens de validação úteis.
- Evite envios duplicados acidentais.
- Forneça feedback de carregamento e sucesso.
- Lide com erros de validação do servidor.
- Preserve a entrada do usuário quando apropriado.
- Use HTML semântico.
A validação client-side melhora a experiência do usuário, mas não substitui a validação do backend.
12. Tratamento de Erros
Lide com erros nos níveis apropriados.
Considere:
- Erros de renderização de componentes.
- Falhas de requisição de API.
- Entrada de usuário inválida.
- Falhas de autenticação.
- Falhas de autorização.
- Dados ausentes.
- Interrupções de rede.
- Estados de aplicação inesperados.
Use limites de erro quando apropriado.
Evite ignorar erros silenciosamente.
Não exponha stack traces internos, informações privadas ou detalhes sensíveis do servidor aos usuários.
13. Otimização de Desempenho
Otimize com base em problemas reais de desempenho.
Considere:
- Re-renderizações desnecessárias.
- Árvores de componentes grandes.
- Cálculos caros.
- Bundles JavaScript grandes.
- Imagens não otimizadas.
- Requisições de rede desnecessárias.
- Renderização de listas ineficiente.
- Divisão de código.
- Carregamento preguiçoso.
Use ferramentas de profiling React quando necessário.
Aplique useMemo, useCallback e React.memo apenas quando fornecerem um benefício significativo.
Não introduza memoização em todos os lugares.
Use keys estáveis e significativas ao renderizar listas. Evite índices de array como keys quando os itens da lista puderem ser reordenados, inseridos ou excluídos.
14. Acessibilidade
Toda interface React deve seguir princípios de acessibilidade.
Requisitos:
- Use HTML semântico.
- Forneça nomes acessíveis para controles.
- Suporte navegação por teclado.
- Mantenha indicadores de foco visíveis.
- Associe labels de formulário corretamente.
- Forneça texto alternativo para imagens significativas.
- Use hierarquia de cabeçalhos apropriada.
- Evite depender apenas de cor para comunicar informações.
- Garanta que elementos interativos tenham papéis e comportamento apropriados.
Use atributos ARIA quando necessário, não como substituto para HTML semântico.
15. Segurança
Siga os padrões de segurança do projeto.
Práticas importantes:
- Não exponha segredos no código frontend.
- Não confie na autorização client-side.
- Não armazene credenciais sensíveis de forma insegura.
- Evite renderização de HTML insegura.
- Sanitize conteúdo não confiável quando necessário.
- Valide a entrada do usuário no backend.
- Use práticas seguras de autenticação e sessão.
- Evite registrar informações sensíveis do usuário.
- Inspecione dependências de terceiros.
- Proteja rotas autenticadas enquanto impõe autorização no servidor.
Nunca presuma que esconder um botão no frontend fornece controle de acesso real.
16. Teste e Depuração
Teste a aplicação após fazer alterações.
Use o framework de teste existente do projeto.
Teste áreas relevantes:
- Renderização de componentes.
- Interações do usuário.
- Validação de formulários.
- Navegação.
- Integração com API.
- Estados de carregamento.
- Estados de erro.
- Comportamento de autenticação.
- Comportamento responsivo.
- Riscos de regressão.
Use níveis de teste apropriados:
- Testes unitários.
- Testes de componentes.
- Testes de integração.
- Testes ponta a ponta.
Ao depurar:
- Reproduza o erro.
- Leia a mensagem de erro completa.
- Identifique o componente ou dependência afetados.
- Rastreie a causa.
- Implemente a menor correção apropriada.
- Teste a correção.
- Verifique regressões.
Não esconda erros desabilitando verificações importantes ou removendo funcionalidades.
17. Arquitetura do Projeto
Respeite a estrutura de pastas existente.
Uma estrutura possível para uma nova aplicação React é:
src/
├── assets/
├── components/
├── features/
├── hooks/
├── layouts/
├── pages/
├── services/
├── context/
├── utils/
├── styles/
├── App.jsx
└── main.jsx
Esta é uma estrutura de referência, não um modelo obrigatório.
Para aplicações maiores, organize o código em torno de funcionalidades quando isso melhorar a mantenibilidade.
Evite criar pastas e arquivos desnecessários para aplicações pequenas.
18. Fluxo de Trabalho de Desenvolvimento
Siga este fluxo de trabalho para tarefas React.
Fase 1: Entender
- Leia os requisitos da tarefa.
- Inspecione o projeto existente.
- Identifique componentes afetados.
- Entenda dependências existentes.
- Identifique riscos potenciais.
Fase 2: Planejar
- Determine as alterações necessárias.
- Selecione uma abordagem de implementação apropriada.
- Identifique arquivos afetados.
- Considere acessibilidade e segurança.
- Identifique testes necessários.
Fase 3: Implementar
- Faça alterações focadas.
- Reutilize componentes existentes.
- Siga convenções estabelecidas.
- Evite modificações não relacionadas.
- Mantenha a estrutura de código clara.
Fase 4: Validar
- Execute os testes apropriados.
- Execute o comando de build do projeto.
- Verifique linting e erros de tipo onde configurados.
- Teste interações relevantes do usuário.
- Revise erros do console do navegador.
- Verifique se a funcionalidade existente ainda funciona.
Inspecione package.json antes de escolher comandos. Não presuma que scripts existem.
Fase 5: Relatar
Explique:
- O que foi implementado.
- Quais arquivos foram alterados.
- Decisões técnicas importantes.
- Testes e comandos executados.
- Quaisquer problemas não resolvidos.
- Qualquer trabalho adicional necessário.
Nunca afirme que um teste ou build foi bem-sucedido a menos que tenha sido realmente executado e aprovado.
19. Práticas Proibidas
Não:
- Reescreva toda a aplicação para uma pequena funcionalidade.
- Instale pacotes desnecessários.
- Ignore a arquitetura existente.
- Use padrões React desatualizados sem justificativa.
- Use efeitos para toda operação.
- Coloque toda a lógica da aplicação em um componente.
- Exponha segredos no código frontend.
- Confie na autorização frontend.
- Ignore acessibilidade.
- Desabilite linting ou testes apenas para fazer um build passar.
- Suprima erros sem entendê-los.
- Afirme que funcionalidades não verificadas funcionam.
- Realize migrações importantes sem explicar o impacto.
20. Definição de Concluído
Uma tarefa React está completa quando:
- A funcionalidade solicitada é implementada.
- A funcionalidade existente é preservada.
- Os componentes seguem princípios de design sustentável.
- O estado e o fluxo de dados são compreensíveis.
- As interações com a API lidam com falhas adequadamente.
- Os requisitos de acessibilidade são considerados.
- Os requisitos de segurança são seguidos.
- Os testes relevantes passam.
- O build de produção é bem-sucedido quando aplicável.
- As limitações conhecidas são documentadas.
- A implementação é claramente relatada.
21. Habilidades Relacionadas
Quando disponível, combine esta habilidade com:
frontend-engineeringpara arquitetura e engenharia frontend geral.ui-ux-designpara experiência do usuário e design de interface.frontend-securitypara segurança específica do frontend.frontend-testingpara práticas de teste frontend.backend-developmentpara integração com backend.api-engineeringpara design e integração de API.
Use habilidades relacionadas onde relevante sem duplicar suas responsabilidades.