Kapitel 7

Grundlagen der Entwicklung

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

Mit Sequential Thinking die Grundlagen der Entwicklung lernen

Entwicklungsgrundlagen umfassen mehrere Aspekte, verwendenMethoden 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-Striktmodus

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
• Durch Zusammenführen per PR
• 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): Leistungsprobleme bei Datenabfragen beheben
docs(readme): Installationsanweisungen aktualisieren
refactor(utils): Datumsformatierungsfunktion refaktorieren
feat
Neue Funktionen
fix
Bugs beheben
docs
Dokumentaktualisierung
style
Codeformat
refactor
Refactoring
test
Test
chore
Build/Werkzeuge
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）
  • • Verwenden Sie eine virtuelle Umgebung, 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: veraltete Abhängigkeiten einmal im Monat überprüfen
  • • Sicherheit zuerst: Abhängigkeiten mit Sicherheitslücken vorrangig aktualisieren
  • • Testgetrieben: nach Aktualisierungen die vollständige Testsuite ausführen
  • • Schrittweise Aktualisierung: jeweils nur eine wichtige Abhängigkeit aktualisieren, um umfangreiche Änderungen zu vermeiden
  • • Dokumentation: Wichtige Abhängigkeitsaktualisierungen und Migrationsschritte dokumentieren

Fehlerbehandlungsrichtlinien

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
  • • Verbindung zur Datenbank fehlgeschlagen
  • • Dateisystemfehler
  • • Detaillierte Protokolle aufzeichnen
Netzwerkfehler
  • • API-Aufruf fehlgeschlagen
  • • Zeitüberschreitungsfehler
  • • 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 zur Fehlerbehandlung

  • • Den Fehlertyp klar benennen: Klare Fehlertypen und Fehlercodes definieren
  • • Fehlerprotokolle aufzeichnen: Vollständige Fehlerinformationen und Kontext aufzeichnen
  • • Benutzerfreundliche Hinweise：Benutzerfreundliche Fehlermeldungen anzeigen und technische Details verbergen
  • • Fehlerwiederherstellung: Bietet Wiederherstellungsmechanismen wie Wiederholungsversuche und Fallbacks
  • • Fehlergrenze：Fehler zentral mit Error Boundaries (React) oder Middleware (Express) 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: Protokollnachricht
  • • 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 richtige 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 zu häufig verwendeten Abfragefeldern hinzufügen
  • • Übermäßige Indizierung vermeiden (beeinträchtigt die Schreibleistung)
  • • Kompositindizes 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-Cache

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
  • • Die 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
  • • Vermeiden Sie die Verwendung von dangerouslySetInnerHTML
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
  • • Die .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-Reviews sind ein wichtiger Schritt, um die Codequalität sicherzustellen. Etablieren Sie einen klaren Review-Prozess und eine Checkliste, damit Reviews effizienter werden.

Prüf-Checkliste

Funktion
  • ☐ Entspricht die Funktion den Anforderungen
  • ☐ Werden Randfälle behandelt
  • ☐ Ist die Fehlerbehandlung vollständig
  • ☐ Ob die Tests ausreichend sind
Leistung
  • ☐ Gibt es Leistungsprobleme?
  • ☐ Sind 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：PRs nach der 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
  • • Prioritätensortierung: Nach Auswirkungsbereich und Behebungskosten sortieren
  • • 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