sk-react

Construisez et corrigez des composants React et TypeScript : placement de l'état, dépendances des effets, récupération de données, rendu de listes et les pièges de re-rendu qui provoquent des interfaces obsolètes ou en boucle. À utiliser lors de l'écriture ou de la modification d'un composant ou d'un hook React, du débogage de données obsolètes, d'une boucle de rendu infinie ou d'une saisie perdue, ou de la revue de code frontend.

Qu'est-ce que sk-react ?

Cette compétence fournit un guide structuré pour écrire du code React et TypeScript fiable en évitant les pièges courants. Elle couvre le placement correct de l'état – en privilégiant le calcul dérivé plutôt que le stockage redondant dans `useState` –, la gestion des effets avec des tableaux de dépendances complets et des fonctions de nettoyage, ainsi que les meilleures pratiques pour la récupération de données (gestion des quatre états : chargement, vide, erreur, succès). Elle traite également du rendu des listes avec des clés stables, de l'utilisation judicieuse de `memo`/`useMemo`/`useCallback`, et des règles des hooks. En TypeScript, elle recommande d'éviter `any` et les assertions de type non vérifiées, et de valider les données aux frontières (API, formulaires, paramètres URL). Enfin, elle insiste sur la vérification réelle du comportement des composants au-delà de la simple compilation réussie. Cible les développeurs utilisant React et TypeScript avec des outils comme Claude Code, Cursor ou Codex.

Compatible avec~Claude Code~Codex CLI~Cursor
Part ofReact
npx skills add https://github.com/vanhuydotcom/sk-skills/tree/HEAD/skills/sk-react

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

React et TypeScript

Placez l'état au même endroit

Chaque valeur doit avoir un seul propriétaire. La plupart des bugs React proviennent de deux copies d'un même fait qui divergent.

Dérivez plutôt que de stocker. Si une valeur peut être calculée à partir des props et de l'état pendant le rendu, calculez-la — ne la mettez pas en miroir dans useState, car la copie devient obsolète dès que sa source change. const total = items.reduce(...) n'a besoin d'aucun état et ne peut jamais être erroné.

Une état copié depuis une prop est le même bug avec une mèche plus longue : la valeur initiale de useState est lue une fois et ignorée pour toujours par la suite. Si le composant doit se réinitialiser lorsqu'une prop change, donnez-lui une key et laissez React le remonter.

Remontez l'état uniquement jusqu'au parent commun le plus proche qui en a besoin. Le remonter plus loin fait que chaque frère se re-rend à chaque frappe.

Effets

Un effet se synchronise avec quelque chose en dehors de React : un abonnement, une minuterie, le document, une bibliothèque impérative. Ce n'est pas l'endroit pour calculer des valeurs ou répondre à un clic — le gestionnaire d'événement l'est.

Le tableau de dépendances doit lister tout ce que l'effet lit. Omettre une valeur pour arrêter une boucle la fige à sa première valeur et produit le bug de fermeture obsolète. Si l'effet boucle parce qu'une dépendance est un objet ou une fonction reconstruit à chaque rendu, corrigez la dépendance — useCallback, useMemo, ou déplacez-la hors du composant — plutôt que de la supprimer du tableau.

Renvoie une fonction de nettoyage chaque fois que l'effet démarre quelque chose qui peut lui survivre. Les abonnements, minuteries et requêtes en vol doivent tous s'arrêter lorsque le composant se démonte ou que les dépendances changent, et sous le mode Strict en développement, l'effet s'exécute deux fois précisément pour exposer un nettoyage manquant.

Une fonction async ne peut pas être un corps d'effet — elle retourne une promesse, et React attend une fonction de nettoyage. Déclarez le travail asynchrone à l'intérieur et appelez-le.

Récupération de données

Préférez la bibliothèque de données du projet à une récupération artisanale dans un effet ; elle résout déjà la mise en cache, la déduplication, la nouvelle tentative et la condition de course que vous êtes sur le point d'écrire.

Lors de la récupération manuelle, gérez les quatre états — chargement, vide, erreur, succès — et annulez la requête lors du nettoyage. Deux requêtes démarrées dans l'ordre peuvent encore se résoudre dans le désordre, donc soit abandonnez la précédente, soit ignorez une réponse qui n'est plus actuelle.

N'avalez jamais un rejet. Un rejet non géré dans un gestionnaire ou un effet échoue silencieusement et l'interface arrête simplement de se mettre à jour.

Rendu

Cléfiez les listes avec une identité stable provenant des données. Les clés d'index ne sont correctes que pour une liste qui ne se réordonne, n'insère ni ne supprime jamais ; lorsqu'elle le fait, React réutilise le mauvais nœud DOM et les entrées conservent la valeur de la ligne précédente.

Utilisez memo, useMemo et useCallback après une mesure avec le profileur. Appliqués partout par défaut, ils ajoutent une allocation et des tableaux de dépendances qui se trompent, et ils ne résolvent rien quand le vrai coût est un parent qui re-rend tout l'arbre.

N'appelez jamais un hook conditionnellement, dans une boucle, ou après un retour précoce. L'ordre doit être identique à chaque rendu.

TypeScript

Considérez any et une assertion de type comme une question non résolue, pas une correction. Les deux font taire le compilateur exactement à l'endroit où il avait quelque chose d'utile à dire. Lorsqu'un type est véritablement inconnu, utilisez unknown et affinez-le.

Tapez ce qui traverse une frontière : réponses API, valeurs de formulaire, paramètres URL. Les données provenant du réseau ne sont pas du type que vous avez déclaré tant que quelque chose ne les vérifie pas, donc validez à la frontière et laissez le reste de l'application faire confiance au résultat.

Vérifiez

Une construction verte prouve moins qu'il n'y paraît. De nombreux projets configurent le framework pour ignorer les erreurs de lint et de type lors de la construction, alors vérifiez la configuration avant de considérer la construction comme une preuve, et exécutez la vérification de type et le linter explicitement.

Ensuite, utilisez le composant : l'état vide, l'état d'erreur, un réseau lent, et une deuxième interaction rapide avant que la première ne se termine.

Individual skills in this repo

This repo contains 5 individual skills — each has its own dedicated page.

sk-api

Design and change API contracts (REST, gRPC, protobuf, events) so existing callers keep working, covering resource and method shape, error models, pagination, versioning and the deploy order a breaking change requires. Use when adding or altering an endpoint, message or event, or when judging whether a proposed change breaks a consumer.

sk-code-review

Shows an agent how to design, debug, or review "sk code review" so the concrete output is a code change with a check. The procedure moves through Code review, Establish the diff first, What to look for, in priority order. Use it when a new assignment calls for this craft.

sk-go-service

Implement, extend or debug a handler, service or repository in a Go backend service, covering context propagation, error wrapping, transaction boundaries, tenancy scoping and table-driven tests. Use when writing or changing Go server code, adding an endpoint or gRPC method, touching a repository query, or diagnosing a panic, leak or flaky test in a Go service.

sk-python

Write and debug Python with attention to the traps that produce silent wrong behaviour — mutable defaults, late-binding closures, shallow copies, swallowed exceptions — plus typing, environment and packaging with uv or venv, and pytest structure. Use when writing a Python script, service or library, setting up a Python project, or debugging behaviour that looks impossible.

sk-system-design

Design or evaluate a distributed system from its constraints — service boundaries, synchronous versus event-driven communication, consistency, failure behaviour and capacity — and state the trade-off each choice buys. Use when splitting or merging services, choosing between a call and an event, deciding where data lives, reviewing an architecture proposal, or answering a system design question.

Skills associés