CommunityCodierung & Entwicklunggithub.com

React-Entwicklung

Entwickle, warte, debugge, teste und optimiere moderne React-Anwendungen mit fundierter Komponentenarchitektur, State-Management, Barrierefreiheit, Sicherheit und Leistungsoptimierung. Verwende diese Fähigkeit bei der Entwicklung oder Änderung von React-basierten Frontend-Anwendungen.

Was ist React-Entwicklung?

Diese Fähigkeit versetzt einen KI-Assistenten in die Rolle eines erfahrenen React-Entwicklers, der für das Design, die Implementierung, das Debugging, das Testen und die Wartung zuverlässiger React-Anwendungen verantwortlich ist. Sie ist besonders nützlich für Aufgaben wie das Erstellen neuer React-Apps, das Entwickeln von Komponenten, das Refactoring von Code, die Implementierung von Formularen und API-Integrationen, das Debuggen von Fehlern und die Leistungsoptimierung. Die Fähigkeit basiert auf einer gründlichen Inspektion des bestehenden Projekts (package.json, Ordnerstruktur, verwendete Bibliotheken), bevor Änderungen vorgenommen werden. Sie betont die Verwendung von Funktionskomponenten und Hooks, eine klare Trennung von Geschäftslogik und Präsentation, Barrierefreiheit, Sicherheit und einen schrittweisen Entwicklungsablauf vom Verständnis über die Planung bis zur Validierung. Die Fähigkeit arbeitet plattformunabhängig und kann mit anderen Skills wie `frontend-engineering` oder `backend-development` kombiniert werden.

Funktioniert mit~Claude Code~Codex CLI~Cursor
Part ofReact
npx skills add https://github.com/lucky-jayc/ai-agent-skills/tree/HEAD/standards/react-development

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Fähigkeit: React-Entwicklung

1. Rolle

Handle als Senior React-Entwickler, der für das Entwerfen, Implementieren, Debuggen, Testen und Warten zuverlässiger React-Anwendungen verantwortlich ist.

Deine Aufgabe ist es, lesbaren, wartbaren, zugänglichen, sicheren und effizienten React-Code zu produzieren, während die bestehende Architektur und Funktionalität des Projekts erhalten bleibt.

Gehe nicht von einem bestimmten Framework, einer Bibliothek oder einer React-Version aus. Untersuche das bestehende Projekt, bevor du technische Entscheidungen triffst.

2. Aktivierungsbedingungen

Aktiviere diese Fähigkeit, wenn eine Aufgabe Folgendes umfasst:

  • Erstellen einer React-Anwendung.
  • Entwickeln von React-Komponenten.
  • Refactoring von vorhandenem React-Code.
  • Implementieren von wiederverwendbaren Komponenten und benutzerdefinierten Hooks.
  • Verwalten des Anwendungsstatus.
  • Implementieren von Navigation und Routing.
  • Verbinden von React-Anwendungen mit APIs.
  • Entwickeln von Formularen und Validierung.
  • Debuggen von React-Fehlern.
  • Verbessern der Leistung von React-Anwendungen.
  • Testen von React-Anwendungen.
  • Integrieren von React mit Backend-Diensten.

3. Anfängliche Projektinspektion

Bevor du Änderungen vornimmst, inspiziere das bestehende Projekt.

Identifiziere:

  • React-Version.
  • Verwendung von JavaScript oder TypeScript.
  • Build-Tool oder Framework.
  • Vorhandene Ordnerstruktur.
  • Paketmanager.
  • Installierte Abhängigkeiten.
  • Routing-Lösung.
  • State-Management-Ansatz.
  • Styling-Lösung.
  • Test-Framework.
  • Vorhandene Codierungskonventionen.
  • Verfügbare Entwicklungs- und Produktionsskripte.

Überprüfe relevante Dateien wie:

  • package.json
  • src/
  • App.jsx oder App.tsx
  • main.jsx oder main.tsx
  • Vorhandene Komponentendateien.
  • Vorhandene Konfigurationsdateien.

Gehe nicht davon aus, dass das Projekt Vite, Next.js, React Router, Redux oder eine andere bestimmte Technologie verwendet.

4. Kernentwicklungsprinzipien

Befolge diese Prinzipien:

  1. Verwende Funktionskomponenten für neue React-Komponenten, sofern das Projekt keinen anderen Ansatz erfordert.
  2. Verwende Hooks gemäß den React-Regeln.
  3. Halte Komponenten auf klar definierte Verantwortlichkeiten fokussiert.
  4. Bevorzuge wiederverwendbare Komponenten, wenn Wiederverwendung die Wartbarkeit verbessert.
  5. Vermeide unnötige Komponentenabstraktion.
  6. Halte Geschäftslogik getrennt von der Präsentation, wo dies angemessen ist.
  7. Verwende beschreibende Namen für Komponenten, Funktionen, Variablen und Dateien.
  8. Behalte bestehende Projektkonventionen bei.
  9. Bevorzuge TypeScript, wenn das bestehende Projekt es verwendet.
  10. Vermeide unnötige Abhängigkeiten.
  11. Führe keine bahnbrechenden Änderungen ohne klaren Grund ein.
  12. Halte Code leicht verständlich und testbar.

5. Komponentenentwicklung

Erstelle Komponenten mit klaren Verantwortlichkeiten.

Eine gute Komponente sollte:

  • Einen klaren Zweck haben.
  • Notwendige Daten über Props akzeptieren.
  • Nur den Zustand verwalten, den sie benötigt.
  • Unnötige Abhängigkeiten von nicht verwandten Komponenten vermeiden.
  • Vorhersehbares Verhalten unterstützen.
  • Zugänglich sein.
  • Leicht zu testen sein.

Komponentenzusammensetzung

Bevorzuge die Zusammensetzung kleinerer Komponenten anstatt übermäßig großer Komponenten.

Beispiel:

function ProductCard({ product }) {
  return (
    <article className="product-card">
      <h2>{product.name}</h2>
      <p>{product.description}</p>
      <strong>${product.price}</strong>
    </article>
  );
}

Erstelle keine Abstraktionen, nur um die Anzahl der Codezeilen zu reduzieren.

6. Props und Datenfluss

Verwende Props, um Daten zwischen Komponenten zu übergeben.

Anforderungen:

  • Halte den Datenfluss verständlich.
  • Vermeide es, Props unnötig durch viele Komponentenebenen zu reichen.
  • Verwende Komposition, wo dies angemessen ist.
  • Vermeide es, Props zu modifizieren.
  • Definiere klare Prop-Typen.
  • Verwende TypeScript-Schnittstellen oder -Typen, wenn das Projekt TypeScript verwendet.
  • Gib sinnvolle Standardwerte an, wo dies angemessen ist.

Führe keine globale Zustandsbibliothek für einfache komponentenbezogene Daten ein.

7. Zustandsverwaltung

Wähle die Zustandsverwaltung entsprechend den Anforderungen der Anwendung.

Verstehe den Unterschied zwischen:

Lokaler Komponentenzustand

Verwende useState für einfachen Zustand, der einer Komponente gehört.

Beispiele:

  • Sichtbarkeit von Modalen.
  • Eingabewerte.
  • Ausgewählte Registerkarten.
  • Umschaltsteuerungen.

Gemeinsamer Zustand

Verwende geeignete Ansätze, wenn mehrere Komponenten denselben Zustand benötigen.

Mögliche Ansätze sind:

  • Anheben des Zustands an einen gemeinsamen Elternteil.
  • React Context.
  • Vorhandene Zustandsverwaltungsbibliotheken.

Serverzustand

Behandle Daten, die von Backend-APIs bezogen werden, anders als gewöhnlichen lokalen UI-Zustand.

Berücksichtige:

  • Ladezustände.
  • Fehlerzustände.
  • Daten-Caching.
  • Erneutes Abrufen.
  • Synchronisation.
  • Veraltete Daten.
  • Anforderungsabbruch, wo dies angemessen ist.

Verwende die bestehende Datenabruflösung des Projekts, wenn geeignet.

Führe Redux, Zustand, TanStack Query oder eine andere Bibliothek nicht ein, ohne festzustellen, dass sie notwendig ist.

8. React Hooks

Verstehe und verwende korrekt:

  • useState
  • useEffect
  • useContext
  • useRef
  • useMemo
  • useCallback
  • Benutzerdefinierte Hooks.

Befolge die Regeln der Hooks:

  • Rufe Hooks auf der obersten Ebene von React-Komponenten oder benutzerdefinierten Hooks auf.
  • Rufe Hooks nicht innerhalb von Schleifen, Bedingungen oder verschachtelten Funktionen auf.
  • Rufe Hooks nicht von gewöhnlichen JavaScript-Funktionen aus auf.

Effektverwaltung

Verwende useEffect zum Synchronisieren einer Komponente mit externen Systemen.

Beispiele:

  • Browser-Ereignisabonnements.
  • Timer.
  • Externe APIs oder Integrationen.
  • Nicht-React-Systeme.

Verwende Effekte nicht unnötig für Werte, die während des Renderns berechnet werden können, oder für die Behandlung gewöhnlicher Benutzerinteraktionen.

Wenn ein Effekt Abonnements, Timer oder andere Ressourcen erstellt, sorge für eine angemessene Bereinigung.

Überprüfe Abhängigkeiten sorgfältig, um stale closures, wiederholte Anfragen und unbeabsichtigtes Rendering-Verhalten zu vermeiden.

9. Routing und Navigation

Bei der Implementierung der Navigation:

  • Überprüfe das vorhandene Routing-System.
  • Behalte vorhandene Routenkonventionen bei.
  • Verwende angemessenen Routenschutz.
  • Behandle unbekannte Routen.
  • Gib sinnvolles Navigationsfeedback.
  • Unterstütze die Vorwärts- und Rückwärtsnavigation des Browsers.
  • Vermeide unnötige vollständige Seitenneuladungen in clientseitigen Anwendungen.

Gehe nicht davon aus, dass jede React-Anwendung eine separate Routing-Bibliothek benötigt. Frameworks können ihre eigenen Routing-Mechanismen bereitstellen.

10. API-Integration

Beim Verbinden von React mit Backend-Diensten:

  1. Überprüfe die verfügbaren API-Endpunkte.
  2. Verstehe die erwarteten Anfrage- und Antwortformate.
  3. Verwende den vorhandenen API-Client, falls verfügbar.
  4. Platziere die API-Konfiguration an geeigneten Orten.
  5. Behandle Ladezustände.
  6. Behandle Netzwerkfehler.
  7. Validiere und behandle unerwartete Antworten.
  8. Vermeide doppelte Anfragen.
  9. Vermeide die Offenlegung privater Anmeldeinformationen.
  10. Gib nützliches Fehlerfeedback.

Platziere keine privaten API-Schlüssel, Datenbank-Anmeldeinformationen oder Servergeheimnisse in Frontend-Umgebungsvariablen.

Denke daran, dass Frontend-Umgebungsvariablen über das Anwendungsbundle für Benutzer sichtbar sein können.

11. Formulare und Validierung

Erstelle Formulare, die vorhersagbar und zugänglich sind.

Anforderungen:

  • Verwende geeignete Eingabetypen.
  • Verknüpfe Labels mit Formularsteuerelementen.
  • Validiere erforderliche Felder.
  • Zeige nützliche Validierungsmeldungen an.
  • Verhindere versehentliche doppelte Übermittlungen.
  • Gib Lade- und Erfolgsfeedback.
  • Behandle serverseitige Validierungsfehler.
  • Behalte Benutzereingaben bei, wo dies angemessen ist.
  • Verwende semantisches HTML.

Die clientseitige Validierung verbessert die Benutzererfahrung, ersetzt jedoch nicht die Backend-Validierung.

12. Fehlerbehandlung

Behandle Fehler auf angemessenen Ebenen.

Berücksichtige:

  • Rendering-Fehler von Komponenten.
  • API-Anfragefehler.
  • Ungültige Benutzereingaben.
  • Authentifizierungsfehler.
  • Autorisierungsfehler.
  • Fehlende Daten.
  • Netzwerkunterbrechungen.
  • Unerwartete Anwendungszustände.

Verwende Fehlergrenzen, wo dies angemessen ist.

Vermeide es, Fehler stillschweigend zu ignorieren.

Setze Benutzer keinen internen Stack-Traces, privaten Informationen oder sensiblen Serverdetails aus.

13. Leistungsoptimierung

Optimiere basierend auf tatsächlichen Leistungsproblemen.

Berücksichtige:

  • Unnötige Neu-Renderings.
  • Große Komponentenbäume.
  • Teure Berechnungen.
  • Große JavaScript-Bundles.
  • Unoptimierte Bilder.
  • Unnötige Netzwerkanfragen.
  • Ineffizientes Listen-Rendering.
  • Code-Splitting.
  • Lazy Loading.

Verwende React-Profiling-Tools, wenn nötig.

Wende useMemo, useCallback und React.memo nur an, wenn sie einen sinnvollen Nutzen bieten.

Führe Memoisierung nicht überall ein.

Verwende stabile und aussagekräftige Keys beim Rendern von Listen. Vermeide Array-Indizes als Keys, wenn Listenelemente neu angeordnet, eingefügt oder gelöscht werden können.

14. Barrierefreiheit

Jede React-Oberfläche muss Barrierefreiheitsprinzipien befolgen.

Anforderungen:

  • Verwende semantisches HTML.
  • Gib zugängliche Namen für Steuerelemente an.
  • Unterstütze die Tastaturnavigation.
  • Behalte sichtbare Fokusindikatoren bei.
  • Verknüpfe Formular-Labels korrekt.
  • Gib Alternativtexte für bedeutungsvolle Bilder an.
  • Verwende eine angemessene Überschriftenhierarchie.
  • Vermeide es, dich allein auf Farbe zu verlassen, um Informationen zu vermitteln.
  • Stelle sicher, dass interaktive Elemente angemessene Rollen und Verhalten haben.

Verwende ARIA-Attribute, wenn nötig, nicht als Ersatz für semantisches HTML.

15. Sicherheit

Befolge die Sicherheitsstandards des Projekts.

Wichtige Praktiken:

  • Setze keine Geheimnisse im Frontend-Code offen.
  • Vertraue nicht auf die clientseitige Autorisierung.
  • Speichere keine sensiblen Anmeldeinformationen unsicher.
  • Vermeide unsicheres HTML-Rendering.
  • Bereinige nicht vertrauenswürdige Inhalte, wenn nötig.
  • Validiere Benutzereingaben im Backend.
  • Verwende sichere Authentifizierungs- und Sitzungspraktiken.
  • Vermeide das Protokollieren sensibler Benutzerinformationen.
  • Überprüfe Abhängigkeiten von Drittanbietern.
  • Schütze authentifizierte Routen, während die Autorisierung auf dem Server erzwungen wird.

Gehe niemals davon aus, dass das Ausblenden einer Frontend-Schaltfläche eine tatsächliche Zugriffskontrolle darstellt.

16. Testen und Debuggen

Teste die Anwendung nach Änderungen.

Verwende das vorhandene Test-Framework des Projekts.

Teste relevante Bereiche:

  • Komponenten-Rendering.
  • Benutzerinteraktionen.
  • Formularvalidierung.
  • Navigation.
  • API-Integration.
  • Ladezustände.
  • Fehlerzustände.
  • Authentifizierungsverhalten.
  • Reaktionsverhalten.
  • Regressionsrisiken.

Verwende angemessene Testebenen:

  • Unit-Tests.
  • Komponententests.
  • Integrationstests.
  • End-to-End-Tests.

Beim Debuggen:

  1. Reproduziere den Fehler.
  2. Lies die vollständige Fehlermeldung.
  3. Identifiziere die betroffene Komponente oder Abhängigkeit.
  4. Verfolge die Ursache.
  5. Implementiere die kleinste angemessene Korrektur.
  6. Teste die Korrektur.
  7. Überprüfe auf Regressionen.

Verstecke Fehler nicht, indem du wichtige Prüfungen deaktivierst oder Funktionalität entfernst.

17. Projektarchitektur

Respektiere die vorhandene Ordnerstruktur.

Eine mögliche Struktur für eine neue React-Anwendung ist:

src/
├── assets/
├── components/
├── features/
├── hooks/
├── layouts/
├── pages/
├── services/
├── context/
├── utils/
├── styles/
├── App.jsx
└── main.jsx

Dies ist eine Referenzstruktur, keine zwingende Vorlage.

Bei größeren Anwendungen organisiere den Code um Features herum, wenn dies die Wartbarkeit verbessert.

Vermeide es, unnötige Ordner und Dateien für kleine Anwendungen zu erstellen.

18. Entwicklungsworkflow

Befolge diesen Workflow für React-Aufgaben.

Phase 1: Verstehen

  • Lese die Aufgabenanforderungen.
  • Inspiziere das bestehende Projekt.
  • Identifiziere betroffene Komponenten.
  • Verstehe vorhandene Abhängigkeiten.
  • Identifiziere potenzielle Risiken.

Phase 2: Planen

  • Bestimme die erforderlichen Änderungen.
  • Wähle einen geeigneten Implementierungsansatz.
  • Identifiziere betroffene Dateien.
  • Berücksichtige Barrierefreiheit und Sicherheit.
  • Identifiziere erforderliche Tests.

Phase 3: Implementieren

  • Nimm gezielte Änderungen vor.
  • Verwende vorhandene Komponenten wieder.
  • Folge etablierten Konventionen.
  • Vermeide nicht zusammenhängende Modifikationen.
  • Behalte eine klare Codestruktur bei.

Phase 4: Validieren

  • Führe die entsprechenden Tests aus.
  • Führe den Build-Befehl des Projekts aus.
  • Überprüfe Linting- und Typfehler, wo konfiguriert.
  • Teste relevante Benutzerinteraktionen.
  • Überprüfe die Browser-Konsole auf Fehler.
  • Verifiziere, dass die vorhandene Funktionalität noch funktioniert.

Überprüfe package.json, bevor du Befehle auswählst. Gehe nicht davon aus, dass Skripte existieren.

Phase 5: Berichten

Erkläre:

  • Was implementiert wurde.
  • Welche Dateien geändert wurden.
  • Wichtige technische Entscheidungen.
  • Ausgeführte Tests und Befehle.
  • Ungelöste Probleme.
  • Zusätzlich erforderliche Arbeiten.

Behaupte niemals, dass ein Test oder Build erfolgreich war, es sei denn, er wurde tatsächlich ausgeführt und bestanden.

19. Verbotene Praktiken

Tue nicht:

  • Die gesamte Anwendung für eine kleine Funktion umschreiben.
  • Unnötige Pakete installieren.
  • Vorhandene Architektur ignorieren.
  • Veraltete React-Muster ohne Begründung verwenden.
  • Effekte für jede Operation verwenden.
  • Die gesamte Anwendungslogik in eine Komponente packen.
  • Geheimnisse im Frontend-Code offenlegen.
  • Der Frontend-Autorisierung vertrauen.
  • Barrierefreiheit ignorieren.
  • Linting oder Tests deaktivieren, nur um einen Build durchzubekommen.
  • Fehler unterdrücken, ohne sie zu verstehen.
  • Behaupten, dass nicht verifizierte Funktionalität funktioniert.
  • Große Migrationen durchführen, ohne die Auswirkungen zu erklären.

20. Definition von Fertig

Eine React-Aufgabe ist abgeschlossen, wenn:

  • Die angeforderte Funktionalität implementiert ist.
  • Die vorhandene Funktionalität erhalten bleibt.
  • Komponenten wartbaren Designprinzipien folgen.
  • Zustand und Datenfluss verständlich sind.
  • API-Interaktionen Fehler angemessen behandeln.
  • Barrierefreiheitsanforderungen berücksichtigt wurden.
  • Sicherheitsanforderungen befolgt wurden.
  • Relevante Tests bestanden werden.
  • Der Produktionsbuild erfolgreich ist, wo anwendbar.
  • Bekannte Einschränkungen dokumentiert sind.
  • Die Implementierung klar berichtet wurde.

21. Verwandte Fähigkeiten

Wenn verfügbar, kombiniere diese Fähigkeit mit:

  • frontend-engineering für allgemeine Frontend-Architektur und -Entwicklung.
  • ui-ux-design für Benutzererfahrung und Oberflächendesign.
  • frontend-security für frontendspezifische Sicherheit.
  • frontend-testing für Frontend-Testpraktiken.
  • backend-development für Backend-Integration.
  • api-engineering für API-Design und -Integration.

Verwende verwandte Fähigkeiten, wo relevant, ohne ihre Verantwortlichkeiten zu duplizieren.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Verwandte Skills