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.jsonsrc/App.jsxoderApp.tsxmain.jsxodermain.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:
- Verwende Funktionskomponenten für neue React-Komponenten, sofern das Projekt keinen anderen Ansatz erfordert.
- Verwende Hooks gemäß den React-Regeln.
- Halte Komponenten auf klar definierte Verantwortlichkeiten fokussiert.
- Bevorzuge wiederverwendbare Komponenten, wenn Wiederverwendung die Wartbarkeit verbessert.
- Vermeide unnötige Komponentenabstraktion.
- Halte Geschäftslogik getrennt von der Präsentation, wo dies angemessen ist.
- Verwende beschreibende Namen für Komponenten, Funktionen, Variablen und Dateien.
- Behalte bestehende Projektkonventionen bei.
- Bevorzuge TypeScript, wenn das bestehende Projekt es verwendet.
- Vermeide unnötige Abhängigkeiten.
- Führe keine bahnbrechenden Änderungen ohne klaren Grund ein.
- 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:
useStateuseEffectuseContextuseRefuseMemouseCallback- 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:
- Überprüfe die verfügbaren API-Endpunkte.
- Verstehe die erwarteten Anfrage- und Antwortformate.
- Verwende den vorhandenen API-Client, falls verfügbar.
- Platziere die API-Konfiguration an geeigneten Orten.
- Behandle Ladezustände.
- Behandle Netzwerkfehler.
- Validiere und behandle unerwartete Antworten.
- Vermeide doppelte Anfragen.
- Vermeide die Offenlegung privater Anmeldeinformationen.
- 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:
- Reproduziere den Fehler.
- Lies die vollständige Fehlermeldung.
- Identifiziere die betroffene Komponente oder Abhängigkeit.
- Verfolge die Ursache.
- Implementiere die kleinste angemessene Korrektur.
- Teste die Korrektur.
- Ü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-engineeringfür allgemeine Frontend-Architektur und -Entwicklung.ui-ux-designfür Benutzererfahrung und Oberflächendesign.frontend-securityfür frontendspezifische Sicherheit.frontend-testingfür Frontend-Testpraktiken.backend-developmentfür Backend-Integration.api-engineeringfür API-Design und -Integration.
Verwende verwandte Fähigkeiten, wo relevant, ohne ihre Verantwortlichkeiten zu duplizieren.