Code Style Enforcer
Diese Fähigkeit stellt sicher, dass Code projektspezifischen Stilkonventionen und -mustern folgt, die automatisierte Linter möglicherweise übersehen.
Wann diese Fähigkeit zu verwenden ist
- Benutzer fordert eine Code-Stil-Überprüfung oder -Verbesserung an
- Sicherstellung der Konsistenz in der gesamten Codebasis
- Einbinden neuer Code- oder Mitwirkende
- Pre-Commit-Code-Überprüfung
- Benutzer erwähnt "Stil", "Konsistenz", "Formatierung" oder "Konventionen"
Anweisungen
1. Projekt-Styleguides erkennen
Suche nach Stilkonfigurationsdateien:
JavaScript/TypeScript:
.eslintrc.*- ESLint-Konfiguration.prettierrc.*- Prettier-Konfigurationtsconfig.json- TypeScript-Compileroptionen.editorconfig- Editor-Konfiguration
Python:
.pylintrc,pylint.cfg- Pylintpyproject.toml- Black, isort-Konfiguration.flake8- Flake8-Konfigurationsetup.cfg- Verschiedene Tool-Konfigurationen
Ruby:
.rubocop.yml- RuboCop-Konfiguration
Go:
go.fmtstandardmäßig erzwungen.golangci.yml- GolangCI-Lint
Java:
checkstyle.xml- Checkstyle.editorconfig
Allgemein:
CONTRIBUTING.md- BeitragsrichtlinienSTYLE_GUIDE.md- Projekt-Styleguide.editorconfig- Editorübergreifende Einstellungen
Verwende Glob, um diese Dateien zu finden, und Read, um die Stilpräferenzen des Projekts zu verstehen.
2. Vorhandene Code-Muster analysieren
Untersuche vorhandenen Code-Stichproben, um implizite Konventionen zu verstehen:
Dateiorganisation:
- Verzeichnisstrukturmuster
- Dateibenennungskonventionen (camelCase, kebab-case, snake_case)
- Import/Export-Organisation
Code-Struktur:
- Klassen-/Funktionsreihenfolge
- Platzierung von öffentlichen vs. privaten Methoden
- Konstante/Variablendeklarationsort
Formatierung:
- Einrückung (Leerzeichen vs. Tabs, Größe)
- Zeilenlängenbeschränkungen
- Verwendung von Leerzeilen
- Kommentarstile
Benennung:
- Variablenbenennung (camelCase, snake_case)
- Klassenbenennung (PascalCase, Großschreibung)
- Konstantenbenennung (UPPER_CASE, etc.)
- Dateibenennungsmuster
Verwende Grep, um gemeinsame Muster in ähnlichen Dateien zu finden.
3. Über Linter hinaus: Auf Muster prüfen
Konzentriere dich auf Stilprobleme, die automatisierte Tools oft übersehen:
Namenskonsistenz:
- Boolesche Variablen:
is,has,should-Präfixe - Ereignisbehandler:
handle*,on*-Muster - Getter/Setter:
get*,set*-Konsistenz - Sammlungsbenennung: Plural vs. Singular
- Akronyme: konsistente Großschreibung
Code-Organisation:
- Zusammengehörige Funktionen gruppiert
- Konsistente Dateistruktur über Module hinweg
- Logische Reihenfolge (public vor private, etc.)
- Trennung der Zuständigkeiten
Kommentare und Dokumentation:
- Vollständigkeit von JSDoc/Docstring
- Kommentarstil-Konsistenz
- TODO/FIXME-Format
- Inline- vs. Blockkommentare
Import/Export-Muster:
- Import-Reihenfolge (externe, interne, relative)
- Benannte vs. Standard-Exports
- Destrukturierungs-Konsistenz
- Aliasing-Muster
Fehlerbehandlung:
- Konsistentes Format der Fehlermeldungen
- Verwendung von Fehlerklassen
- Try/Catch-Muster
- Logging-Format
Typverwendung (TypeScript/getippte Sprachen):
- Explizite vs. inferierte Typen
interfacevs.type-Vorliebe- Generische Benennung (T, K, V vs. beschreibend)
- Null/Undefined-Behandlung
4. Häufige Anti-Patterns identifizieren
Markiere Code-Gerüche und Anti-Patterns:
Magische Zahlen:
// Schlecht
if (status === 200) { }
// Gut
const HTTP_OK = 200;
if (status === HTTP_OK) { }
Inkonsistente Null-Prüfungen:
// Inkonsistent
if (user === null) { }
if (!data) { }
if (typeof result === 'undefined') { }
// Konsistent
if (user === null) { }
if (data === null) { }
if (result === undefined) { }
Verschachtelte Ternäre:
// Schwer lesbar
const value = a ? b ? c : d : e;
// Besser
let value;
if (a) {
value = b ? c : d;
} else {
value = e;
}
Lange Parameterlisten:
# Schwer wartbar
def create_user(name, email, age, address, phone, ...):
# Besser
def create_user(user_data: UserData):
5. Projektspezifische Konventionen prüfen
Suche nach Mustern, die für dieses Projekt einzigartig sind:
- Benutzerdefinierte Benennung für bestimmte Domänen (z. B. "repo" vs. "repository")
- Bevorzugte Bibliotheken für häufige Aufgaben
- Architekturmuster (MVC, Serviceschicht, etc.)
- Testdateibenennung und -struktur
- Konfigurationsmuster
Lies CONTRIBUTING.md, README.md oder ähnliche Dokumente für explizite Richtlinien.
6. Stilempfehlungen generieren
Für jedes Problem bereitstellen:
Aktueller Code:
function getData(id) {
const d = fetch('/api/users/' + id);
return d;
}
Problem:
- Inkonsistente Benennung (
getDatavs. andere Funktionen verwendenfetch*) - Einbuchstabiger Variablenname (
d) - String-Verkettung anstelle von Template-Literalen
Empfohlen:
function fetchUser(id) {
const userData = fetch(`/api/users/${id}`);
return userData;
}
7. Probleme priorisieren
Nach Auswirkung ordnen:
Hohe Priorität (Konsistenz):
- Inkonsistenzen bei der Benennung ähnlicher Funktionen
- Gemischte Einrückungen oder Formatierungen
- Inkonsistente Fehlerbehandlung
Mittlere Priorität (Lesbarkeit):
- Magische Zahlen/Zeichenketten
- Unklare Variablennamen
- Fehlende Dokumentation
Niedrige Priorität (Nice-to-have):
- Kommentarformatierung
- Import-Reihenfolge
- Zusätzliche Leerzeilen
8. Automatisierte Tools vorschlagen
Tools zur Durchsetzung von Stilen empfehlen:
JavaScript/TypeScript:
npm install --save-dev prettier eslint
npx prettier --write .
npx eslint --fix .
Python:
pip install black isort flake8
black .
isort .
Go:
go fmt ./...
golangci-lint run
Ruby:
gem install rubocop
rubocop -a
9. EditorConfig erstellen oder aktualisieren
.editorconfig vorschlagen, falls fehlend:
root = true
[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
[*.{js,ts,jsx,tsx}]
indent_style = space
indent_size = 2
[*.py]
indent_style = space
indent_size = 4
[*.go]
indent_style = tab
10. Checkliste für die Stilüberprüfung
Bei der Überprüfung von Code auf Stil:
- Benennung folgt den Projektkonventionen
- Einrückung und Formatierung sind konsistent
- Importe sind ordnungsgemäß organisiert
- Kommentare wo nötig, nicht übermäßig
- Keine magischen Zahlen oder Zeichenketten
- Fehlerbehandlung ist konsistent
- Dateiorganisation entspricht der Projektstruktur
- Keine offensichtlichen Code-Gerüche
- Typanmerkungen sind konsistent (falls zutreffend)
- Tests folgen den Testkonventionen
Best Practices
- Konsistenz vor Perfektion: Vorhandenen Mustern folgen, auch wenn sie nicht ideal sind
- Entscheidungen dokumentieren: Styleguides für mehrdeutige Fälle hinzufügen
- Wo möglich automatisieren: Prettier, Black, gofmt, etc. verwenden
- Pragmatisch sein: Funktionierenden Code nicht nur aus Stilgründen umgestalten
- Team-Abstimmung: Sich auf relevante Stile einigen
- Inkrementelle Verbesserung: Stile in bearbeiteten Dateien korrigieren, nicht auf einmal
- Lesbarkeit zuerst: Stil dient der Lesbarkeit, nicht umgekehrt
Häufige Stilkonflikte
Tabs vs. Leerzeichen
.editorconfigoder vorhandene Dateien prüfen- Im Zweifelsfall die Mehrheit des Projekts verwenden
Anführungszeichen (einfach vs. doppelt)
- JavaScript: Einfach (
') üblich - Python: Beides, konsistent sein
- Go: Immer doppelt (
") - Linter-Konfiguration befolgen, falls vorhanden
Semikolons (JavaScript)
- Mehrheit des vorhandenen Codes prüfen
- Falls gemischt, Prettier zur Durchsetzung vorschlagen
Zeilenlänge
- Übliche Grenzwerte: 80, 100, 120 Zeichen
- Linter-Konfiguration oder
.editorconfigprüfen
Import-Reihenfolge
- Üblich: Stdlib, extern, intern, relativ
- Automatisierte Tools verwenden (isort, organize imports)
Unterstützende Dateien
reference/style-guides.md: Links zu populären Styleguidesexamples/before-after.md: Codebeispiele, die Verbesserungen zeigen