Kapitel 7

Grundlagen der Entwicklung

Code-Konventionen, Tool-Konfigurationen und Best Practices für verschiedene Sprachen beherrschen, professionelle Entwicklungsgewohnheiten aufbauen und die Codequalität sowie die Effizienz der Teamzusammenarbeit verbessern.

Mit Sequential Thinking die Grundlagen der Entwicklung lernen

Entwicklungsgrundwissen umfasst viele Aspekte, wobeiMethoden des strukturierten DenkensKann Ihnen helfen, systematisch Folgendes zu beherrschen:

1
Code-Konventionen
Namens-, Formatierungs- und Kommentarrichtlinien in verschiedenen Sprachen
2
Tool-Konfiguration
Praktische Konfiguration von ESLint, Prettier und Formatierungstools
3
Best Practices
Praktiken für Fehlerbehandlung, Protokollierung, Leistung, Sicherheit usw.
4
Kontinuierliche Verbesserung
Code-Reviews, Qualitätskennzahlen, Verwaltung technischer Schulden

Code-Konventionen

Ein einheitlicher Code-Standard macht Code lesbarer und leichter wartbar und ist die Grundlage der Teamzusammenarbeit. Da jede Sprache eigene Konventionen hat, stellen wir sie unten nach Sprache geordnet vor.

Namenskonventionen

Variablen/Funktionen
camelCase
getUserName, calculateTotal
Klasse/Komponente
PascalCase
UserProfile, LoginForm
Konstante
UPPER_SNAKE_CASE
MAX_RETRY_COUNT, API_BASE_URL
Datei
kebab-case
user-service.ts, login-form.tsx

ESLint-Konfiguration

Empfohlen Airbnb oder TypeScript ESLint Konfiguration.

.eslintrc.json（Airbnb + TypeScript）：
{
  "extends": [
    "airbnb-base",
    "airbnb-typescript/base",
    "plugin:@typescript-eslint/recommended",
    "plugin:@typescript-eslint/recommended-requiring-type-checking"
  ],
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "project": "./tsconfig.json"
  },
  "rules": {
    "@typescript-eslint/no-explicit-any": "error",
    "@typescript-eslint/explicit-function-return-type": "warn",
    "import/prefer-default-export": "off",
    "max-len": ["error", { "code": 100 }]
  }
}

Prettier-Konfiguration

.prettierrc：
{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 100,
  "tabWidth": 2,
  "useTabs": false,
  "arrowParens": "always"
}

TypeScript-Strict-Mode

tsconfig.json (Strikter Modus):
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true
  }
}

React-Konventionen

  • • Funktionskomponenten und Hooks verwenden und Klassenkomponenten vermeiden
  • • Props werden mit TypeScript-Interfaces definiert
  • • Komponentennamen verwenden PascalCase
  • • Verwenden Sie React.memo, um die Leistung zu optimieren (falls erforderlich)
  • • Benutzerdefinierte Hooks beginnen mit `use`

Schnellreferenz für andere Sprachen

Rust
  • • rustfmt (Formatierung)
  • • clippy (Codeprüfung)
  • • snake_case-Namenskonvention
C#
  • • dotnet format
  • • EditorConfig
  • • PascalCase-Benennung
Swift/Kotlin/Dart
  • • Swift: SwiftLint
  • • Kotlin: ktlint
  • • Dart: dart format

Versionskontrolle

Git ist das Standardwerkzeug der modernen Entwicklung. Git-Workflows, Branching-Strategien und Code-Review-Abläufe zu beherrschen, ist die Grundlage der Teamzusammenarbeit.

Branch-Strategie

Git Flow
• main: Produktionsumgebung
• develop: Entwicklungs-Branch
• feature/*: Feature-Branch
• release/*: Release-Branches
• hotfix/*: Hotfix
GitHub Flow
• main: Hauptzweig
• feature/*: Feature-Branch
• Über PR zusammenführen
• Geeignet für kontinuierliche Bereitstellung
GitLab Flow
• main: Hauptzweig
• Umgebungs-Branches (staging, production)
• Upstream-first-Prinzip

Konvention für Commit-Nachrichten (Conventional Commits)

Format: <type>(<scope>): <subject>
feat(auth): Benutzeranmeldefunktion hinzufügen
fix(api): Problem mit der Leistung von Datenabfragen beheben
docs(readme): Installationsanweisungen aktualisieren
refactor(utils): Datumsformatierungsfunktion refaktorieren
feat
Neue Funktion
fix
Bugs beheben
docs
Dokumentaktualisierung
style
Codeformat
refactor
Refactoring
test
Test
chore
Build/Tools
perf
Leistungsoptimierung

Git-Hooks-Konfiguration

pre-commit Hook
# Vor dem Einreichen Lint- und Formatierungsprüfungen ausführen
npm run lint
npm run format:check
commit-msg Hook
# Format der Commit-Nachricht prüfen
npx commitlint --edit $1

💡 Verwenden husky(Node.js) oder pre-commit(Python) Git Hooks verwalten

Code-Review-Prozess

1Einen Feature-Branch erstellen, die Entwicklung abschließen und den Code committen
2Einen Pull Request erstellen und die PR-Beschreibung sowie die Checkliste ausfüllen
3Code-Reviewer prüfen den Code (Funktionalität, Leistung, Sicherheit, Wartbarkeit)
4Den Code basierend auf dem Feedback ändern und erneut einreichen
5Nach Freigabe der Prüfung in den Hauptzweig zusammenführen

Abhängigkeitsverwaltung

Projektabhängigkeiten angemessen verwalten, um Wartbarkeit und Sicherheit des Projekts zu gewährleisten. Verschiedene Sprachen haben unterschiedliche Methoden zur Verwaltung von Abhängigkeiten.

Semantische Versionierung (SemVer)

Hauptversion (MAJOR)
Nicht kompatible API-Änderungen
2.0.0
Nebenversionnummer (MINOR)
Abwärtskompatible Funktionsergänzungen
1.2.0
Versionsnummer (PATCH)
Behebung von Problemen der Abwärtskompatibilität
1.2.3
Versionsbereich：^1.2.3 (erlaubt 1.x.x, nicht 2.0.0), ~1.2.3 (erlaubt 1.2.x, nicht 1.3.0)

Gesperrte Dateiverwaltung

Node.js
  • • package-lock.json（npm）
  • • yarn.lock（yarn）
  • • pnpm-lock.yaml（pnpm）
  • • In die Versionsverwaltung einchecken, um Konsistenz sicherzustellen
Python
  • • requirements.txt（pip）
  • • poetry.lock（Poetry）
  • • Pipfile.lock（Pipenv）
  • • Virtuelle Umgebungen verwenden, um Abhängigkeiten zu isolieren

Sicherheitsaudit der Abhängigkeiten

Node.js
npm audit
npm audit fix
yarn audit
pnpm audit
Python
pip-audit
safety check
bandit (Code-Sicherheitsprüfungen)

💡 Verwenden Dependabot oder Renovate Abhängigkeiten und Sicherheitspatches automatisch aktualisieren

Strategie zur Aktualisierung von Abhängigkeiten

  • • Regelmäßig aktualisieren: Einmal im Monat veraltete Abhängigkeiten prüfen
  • • Sicherheit zuerst: Abhängigkeiten mit Sicherheitslücken vorrangig aktualisieren
  • • Testgetrieben: nach Aktualisierungen die vollständige Testsuite ausführen
  • • Schrittweise Aktualisierung：Jeweils eine Hauptabhängigkeit aktualisieren, um großflächige Änderungen zu vermeiden
  • • Dokumentationsaufzeichnung: Wichtige Abhängigkeitsaktualisierungen und Migrationsschritte dokumentieren

Richtlinien zur Fehlerbehandlung

Eine gute Fehlerbehandlung macht Programme robuster und verbessert die Benutzererfahrung. Verschiedene Sprachen haben unterschiedliche Muster der Fehlerbehandlung.

Klassifizierung von Fehlertypen

Geschäftsfehler
  • • Benutzer-Eingabefehler
  • • Verstöße gegen Geschäftsregeln
  • • Freundliche Fehlermeldungen zurückgeben
Systemfehler
  • • Datenbankverbindung fehlgeschlagen
  • • Dateisystemfehler
  • • Detaillierte Protokolle aufzeichnen
Netzwerkfehler
  • • API-Aufruf fehlgeschlagen
  • • Zeitüberschreitungsfehler
  • • Einen Wiederholungsmechanismus implementieren

Fehlerbehandlungsmodi

TypeScript/JavaScript/Python/Java：
try {
  const result = await riskyOperation();
  return result;
} catch (error) {
  logger.error('Vorgang fehlgeschlagen', { error });
  throw new BusinessError('Benutzerfreundliche Fehlermeldung');
}

Best Practices für die Fehlerbehandlung

  • • Den Fehlertyp klar benennen: Klare Fehlertypen und Fehlercodes definieren
  • • Fehlerprotokolle aufzeichnen: Vollständige Fehlerinformationen und Kontext aufzeichnen
  • • Benutzerfreundliche Hinweise: den Nutzern freundliche Fehlermeldungen anzeigen und technische Details verbergen
  • • Fehlerbehebung: Bietet Wiederherstellungsmechanismen wie Wiederholungsversuche und Fallbacks
  • • Fehlergrenze: Fehlergrenzen (React) oder Middleware (Express) verwenden, um Fehler zentral zu behandeln

Protokollierungsrichtlinien

Gutes Logging ist die Grundlage für Debugging und Monitoring. Strukturierte Logs machen Protokolle leichter analysier- und verarbeitbar.

Protokollstufe

DEBUG
Detaillierte Debug-Informationen
Entwicklungsdebugging
INFO
Allgemeine Informationen
Normalbetrieb
WARN
Warnmeldung
Mögliche Probleme
ERROR
Fehlermeldung
Fehlerhaft, aber wiederherstellbar
FATAL
kritischer Fehler
Das System kann nicht fortfahren

Strukturierte Logs (JSON-Format)

Beispiel:
{
  "timestamp": "2025-01-27T10:30:00Z",
  "level": "ERROR",
  "message": "Benutzeranmeldung fehlgeschlagen",
  "context": {
    "userId": "12345",
    "ip": "192.168.1.1",
    "userAgent": "Mozilla/5.0..."
  },
  "error": {
    "type": "AuthenticationError",
    "message": "Falsches Passwort",
    "stack": "..."
  },
  "requestId": "req-abc123"
}

Protokollkontext

Pflichtfeld
  • • timestamp: Zeitstempel
  • • level: Protokollstufe
  • • message: Protokollmeldung
  • • requestId: Anfrage-ID (Nachverfolgung)
Optionales Feld
  • • userId: Benutzer-ID
  • • operation: Operationstyp
  • • duration: Dauer der Aktion
  • • metadata: zusätzliche Metadaten

Maskierung sensibler Informationen

  • • Passwort: Passwörter niemals protokollieren, verwenden *** Alternative
  • • Token: Nur die ersten und letzten Zeichen des Tokens aufzeichnen
  • • Ausweisnummer：Anonymisierung, nur ein Teil der Ziffern wird angezeigt
  • • Bankkartennummer: Nur die letzten 4 Ziffern anzeigen
  • • E-Mail： teilweise Anonymisierung kann in Betracht gezogen werden (z. B. u***@example.com)

Leistungsoptimierung

Die Leistungsoptimierung ist ein fortlaufender Prozess. Vom Code- bis zum Architekturniveau gibt es Optimierungspotenzial.

Code-Performance-Optimierung

Algorithmusoptimierung
  • • Die geeignete Datenstruktur wählen (HashMap vs. List)
  • • Verschachtelte Schleifen vermeiden; Indizes oder eine Map verwenden
  • • Zwischenspeicherung verwenden, um wiederholte Berechnungen zu vermeiden
  • • Analyse der Zeitkomplexität (O(n) vs. O(n²))
Frontend-Optimierung
  • • Code-Splitting und Lazy Loading
  • • Bildoptimierung (WebP, Lazy Loading)
  • • Verwenden Sie React.memo, um unnötige erneute Renderings zu vermeiden
  • • Virtuelles Scrollen (lange Listen)

Optimierung von Datenbankabfragen

Indexoptimierung
  • • Indizes für häufig abgefragte Felder hinzufügen
  • • Übermäßige Indizierung vermeiden (beeinträchtigt die Schreibleistung)
  • • Verbundindizes verwenden, um Mehrfeldabfragen zu optimieren
  • • Abfragepläne regelmäßig analysieren (EXPLAIN)
Abfrageoptimierung
  • • Vermeiden Sie SELECT *, fragen Sie nur die benötigten Felder ab
  • • Paginierung verwenden, um das gleichzeitige Laden großer Datenmengen zu vermeiden
  • • Verwenden Sie JOIN anstelle mehrerer Abfragen
  • • N+1-Abfrageprobleme vermeiden

Cache-Strategie

Speicher-Cache
  • • Lokaler Cache (Map, LRU-Cache)
  • • Geeignet für Hot Data
  • • Auf Speicherbegrenzungen achten
Redis
  • • Verteiltes Caching
  • • Ablaufzeit festlegen
  • • Schutz vor Cache-Penetration / Durchschlag / Lawine
CDN
  • • Beschleunigung statischer Ressourcen
  • • Bild-, CSS- und JS-Dateien
  • • Edge-Knoten-Caching

Leistungsüberwachung

  • • APM-Tools：New Relic, Datadog, Sentry (Leistungsüberwachung)
  • • Leistungsanalyse：Chrome DevTools、Python cProfile、Go pprof
  • • Metriküberwachung: Antwortzeit, Durchsatz, Fehlerrate, Ressourcennutzung
  • • Warnmechanismus: Leistungsschwellenwerte festlegen und bei Überschreitung automatisch warnen

Sicherheits-Best Practices

Sicherheit ist keine Option, sondern Pflicht. Von der Code-Ebene bis zur Bereitstellungsebene muss Sicherheit in jeder Phase berücksichtigt werden.

Eingabevalidierung und Bereinigung

Frontend-Validierung
  • • Formulareingaben mit Bibliotheken wie Zod und Yup validieren
  • • Clientseitige Validierung verbessert die Benutzererfahrung
  • • Verlassen Sie sich jedoch niemals nur auf die Frontend-Validierung
Backend-Validierung
  • • Alle Eingaben müssen validiert werden
  • • Eine Whitelist statt einer Blacklist verwenden
  • • Benutzereingaben bereinigen und escapen

Schutz vor gängigen Angriffen

SQL-Injection
  • • Parametrisierte Abfragen (Prepared Statements) verwenden
  • • ORM verwenden (Prisma, TypeORM)
  • • SQL-Strings niemals zusammenfügen
XSS (Cross-Site-Scripting)
  • • Ausgabe-Escaping (automatisches Escaping von React)
  • • Content Security Policy (CSP) verwenden
  • • Die Verwendung von dangerouslySetInnerHTML vermeiden
CSRF (Cross-Site Request Forgery)
  • • CSRF-Token verwenden
  • • SameSite-Cookie-Attribut
  • • Den Referer-Header validieren
Verschlüsselung sensibler Daten
  • • Passwörter werden mit bcrypt und Argon2 gehasht
  • • Die Übertragung verwendet HTTPS (TLS)
  • • Sensible Daten bei der Speicherung verschlüsseln

Schlüsselverwaltung

Umgebungsvariablen
  • • Eine .env-Datei verwenden (nicht in Git einchecken)
  • • Verwende .env.example als Vorlage
  • • Im Produktionseinsatz einen Schlüsselverwaltungsdienst verwenden
Schlüsselverwaltungsdienst
  • • AWS Secrets Manager
  • • HashiCorp Vault
  • • Azure Key Vault
  • • Schlüssel regelmäßig rotieren

OWASP Top 10 Schutz

1.Injection-Angriffe (SQL, NoSQL, Befehlsinjektion)
2.Fehlgeschlagene Authentifizierung
3.Verlust sensibler Daten
4.XML External Entity (XXE)
5.Fehlerhafte Zugriffskontrolle
6.Unsichere Konfigurationsfehler
7.XSS-Cross-Site-Scripting
8.Unsichere Deserialisierung
9.Komponenten mit bekannten Sicherheitslücken verwenden
10.Unzureichendes Logging und Monitoring

Code-Review

Code-Review ist ein wichtiger Schritt zur Sicherstellung der Codequalität. Etablieren Sie klare Review-Prozesse und Checklisten, um Reviews effizienter zu gestalten.

Prüf-Checkliste

Funktion
  • ☐ Entspricht die Funktion den Anforderungen
  • ☐ Sind Randfälle behandelt
  • ☐ Ist die Fehlerbehandlung vollständig
  • ☐ Sind die Tests ausreichend
Leistung
  • ☐ Gibt es Leistungsprobleme?
  • ☐ Sind die Datenbankabfragen optimiert
  • ☐ Gibt es ein Speicherleck
  • ☐ Ist die Cache-Nutzung angemessen?
Sicherheit
  • ☐ Ist die Eingabevalidierung vollständig
  • ☐ Sind sensible Informationen offengelegt worden
  • ☐ Ist die Berechtigungsprüfung korrekt?
  • ☐ Gibt es Sicherheitslücken in den Abhängigkeiten?
Wartbarkeit
  • ☐ Ist der Code klar und gut lesbar?
  • ☐ Ist die Namensgebung angemessen?
  • ☐ Sind die Kommentare ausreichend
  • ☐ Ob die Projektvorgaben eingehalten werden

Bewährte Review-Praktiken

Zeitnahe Prüfung: nach der PR-Erstellung so schnell wie möglich prüfen, um Entwicklungsblockaden zu vermeiden
Konstruktives Feedback: Probleme aufzeigen und Verbesserungsvorschläge machen, statt nur zu kritisieren
Kleingruppenprüfung：Halten Sie den pro Prüfung überprüften Codeumfang unter 400 Zeilen
Automatisierungsprüfung: CI/CD verwenden, um Formatierung, Tests und Sicherheit automatisch zu prüfen

Kontinuierliche Verbesserung

Codequalität ist keine einmalige Aufgabe, sondern ein Prozess kontinuierlicher Verbesserung. Richten Sie Qualitätsmetriken und Überwachungsmechanismen ein.

Codequalitätsmetriken

Zyklomatische Komplexität
  • • Codekomplexität messen
  • • Ziel: < 10
  • • Tools: SonarQube, CodeClimate
Codeabdeckung
  • • Der Anteil des durch Tests abgedeckten Codes
  • • Ziel: > 80%
  • • Tools: Jest, Coverage.py, JaCoCo
Technische Schulden
  • • Code Smells, doppelter Code
  • • Regelmäßig refaktorisieren
  • • Tool: SonarQube

Automatisierte Prüfungen (CI/CD-Integration)

GitHub-Actions-Beispiel:
name: Code Quality

on: [push, pull_request]

jobs:
  quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
      - name: Install dependencies
        run: npm ci
      - name: Run linter
        run: npm run lint
      - name: Run tests
        run: npm test
      - name: Check coverage
        run: npm run test:coverage

Technische-Schulden-Management

  • • Schulden identifizieren: Verwenden Sie Tools, um Code Smells und doppelten Code automatisch zu erkennen
  • • Priorisierung：Nach Auswirkungsbereich und Behebungsaufwand priorisieren
  • • Regelmäßiges Refactoring：In jedem Sprint eine bestimmte Zeit für Refactoring einplanen
  • • Schulden erfassen: In einem Issue oder in der technischen Schuldenliste dokumentieren
  • • Neue technische Schulden vermeiden: bei Code-Reviews auf technische Schulden achten

Lernergebnisse

Nach Abschluss dieses Kapitels werden Sie:

  • 1Die Codekonventionen verschiedener Sprachen (TypeScript, Python, Java, Go usw.) und die Tool-Konfiguration beherrschen
  • 2Versionierung mit Git beherrschen und Verzweigungsstrategien sowie Code-Review-Prozesse verstehen
  • 3Die Bedeutung der Abhängigkeitsverwaltung verstehen und Sicherheitsprüfungs- und Aktualisierungsstrategien beherrschen
  • 4Beherrsche Fehlerbehandlung und Protokollierungsstandards, um die Robustheit des Codes zu verbessern
  • 5Leistungsoptimierung und Sicherheits-Best Practices verstehen und hochwertigen Code schreiben
  • 6Einen Mechanismus für Code-Reviews und kontinuierliche Verbesserung einführen, um die Codequalität des Teams zu verbessern
Vorheriges Kapitel: Überblick über KI-AnwendungsframeworksNächstes Kapitel: Interaktion der Oberfläche