Namenskonventionen in der Programmierung — camelCase, snake_case und mehr

Sie öffnen zum ersten Mal eine Codebasis und sehen getUserName, get_user_name und GetUserName alles in derselben Datei. Sofort wissen Sie, dass etwas schiefgelaufen ist. Namenskonventionen sind eine dieser Sachen, die trivial erscheinen, bis man im Team arbeitet — dann werden sie essenziell.

Konsistente Benennung ist keine Frage der persönlichen Vorliebe. Es geht darum, Code für die nächste Person lesbar zu machen, die ihn anfasst — und das ist oft man selbst, sechs Monate später.

Warum Namenskonventionen wichtig sind

Drei Dinge brechen zusammen, wenn einem Projekt konsistente Benennung fehlt:

• Die Lesbarkeit leidet — Wenn sich Variablenstile alle paar Zeilen ändern, verschwendet Ihr Gehirn Zyklen damit, das Format zu parsen, anstatt die Logik zu verstehen
• Die Teamzusammenarbeit zerbricht — Pull Requests werden zu Schlachtfeldern über Stil statt über Inhalt. Das Einarbeiten neuer Entwickler dauert länger, weil es kein vorhersagbares Muster gibt
• Tooling funktioniert nicht mehr richtig — Linter, Auto-Vervollständigung, Code-Generatoren und Refactoring-Tools verlassen sich auf vorhersagbare Benennungsmuster

Die Konvention, die Sie wählen, ist weit weniger wichtig als eine zu wählen und dabei zu bleiben. Eine Codebasis mit konsistentem snake_case überall ist unendlich besser als eine mit drei verschiedenen Stilen.

Der vollständige Leitfaden zu Namenskonventionen

camelCase

Das erste Wort ist kleingeschrieben, und jedes folgende Wort beginnt mit einem Großbuchstaben. Keine Trennzeichen.

// JavaScript / TypeScript
const userName = "Alice";
let itemCount = 42;
function getUserProfile(userId) {
  return fetchData(`/users/${userId}`);
}

Wo es verwendet wird: JavaScript, TypeScript und Java verwenden camelCase für Variablen, Funktionsnamen und Methodennamen. Es ist auch der Standard in Swift für lokale Variablen und Funktionsparameter.

PascalCase

Jedes Wort beginnt mit einem Großbuchstaben. Auch UpperCamelCase genannt.

// TypeScript / C#
class UserProfile {
  firstName: string;
  lastName: string;
}

interface DatabaseConnection {
  host: string;
  port: number;
}

// React-Komponente
function NavigationBar({ items }: NavProps) {
  return <nav>{/* ... */}</nav>;
}

Wo es verwendet wird: C# verwendet PascalCase für fast alles Öffentliche — Klassen, Methoden, Eigenschaften. TypeScript und JavaScript verwenden es für Klassen, Interfaces, Typ-Aliase und Enums. React verlangt PascalCase für Komponentennamen, weil JSX Komponenten von HTML-Elementen unterscheiden muss.

In Go hat PascalCase eine besondere Bedeutung: Jeder Bezeichner, der mit einem Großbuchstaben beginnt, ist exportiert (öffentlich).

snake_case

Alle Wörter klein geschrieben, getrennt durch Unterstriche.

# Python
user_name = "Alice"
item_count = 42

def get_user_profile(user_id):
    return fetch_data(f"/users/{user_id}")

class UserProfile:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

Wo es verwendet wird: Python verwendet snake_case für praktisch alles außer Klassennamen. Ruby folgt demselben Muster. Rust verwendet snake_case für Variablen, Funktionen und Module. Datenbankschemas verwenden fast universell snake_case für Tabellen- und Spaltennamen.

SCREAMING_SNAKE_CASE

Alles in Großbuchstaben mit Unterstrichen. Reserviert für Konstanten und Werte, die sich nie ändern sollten.

// Konstanten in den meisten Sprachen
const MAX_RETRY_COUNT = 3;
const API_BASE_URL = "https://api.example.com";
const DEFAULT_TIMEOUT_MS = 5000;

Wo es verwendet wird: Nahezu jede Sprache verwendet SCREAMING_SNAKE_CASE für Konstanten. Das Großbuchstaben-Format ist ein universelles Signal: „Weise diesen Wert nicht neu zu."

kebab-case

Alles kleingeschrieben mit Bindestrichen als Trennzeichen.

/* CSS-Klassennamen */
.navigation-bar {
  background-color: #1a1a2e;
}

.user-profile-card {
  border-radius: 8px;
}

# CLI-Flags
npm install --save-dev eslint
git commit --no-verify

Wo es verwendet wird: CSS und HTML bevorzugen stark kebab-case. URL-Slugs verwenden es. CLI-Tools und Kommandozeilen-Flags folgen ihm.

kebab-case kann in den meisten Programmiersprachen nicht für Variablennamen verwendet werden, weil der Bindestrich als Minus-Operator interpretiert wird.

dot.case

Wörter getrennt durch Punkte.

// Java-Paketnamen
package com.example.userservice.controllers;

import org.springframework.boot.SpringApplication;

Wo es verwendet wird: Java-Paketbenennung, Dateierweiterungen, Konfigurationseigenschafts-Schlüssel in Spring Boot und ähnlichen Frameworks.

Title Case

Jedes wichtige Wort wird großgeschrieben. Kleinere Wörter wie „und", „der" und „von" bleiben klein, es sei denn, sie beginnen den Satz.

Wo es verwendet wird: UI-Überschriften, Seitentitel, Menüelemente, Dokumentationsabschnitte und Eigennamen.

path/case

Wörter getrennt durch Schrägstriche, die Dateisystem- oder Namespace-Konventionen folgen.

Wo es verwendet wird: Dateisystempfade, Modulpfade, Namespace-Hierarchien und URL-Routing-Strukturen.

Sprachspezifische Konventionstabelle

Häufige Fehler und wie man sie behebt

1. Konventionen im selben Bereich mischen

// ❌ Inkonsistent
const user_name = "Alice";
const itemCount = 42;
const MaxRetries = 3;

// ✅ Konsistentes camelCase
const userName = "Alice";
const itemCount = 42;
const maxRetries = 3;

2. Die falsche Konvention für die Sprache verwenden

# ❌ camelCase in Python verwenden
def getUserProfile(userId):
    userName = fetchUser(userId)
    return userName

# ✅ snake_case wie Python es erwartet
def get_user_profile(user_id):
    user_name = fetch_user(user_id)
    return user_name

3. Abkürzungen und Akronyme

// ❌ Inkonsistente Akronymbehandlung
const XMLParser = new XmlParser();
const htmlToJSON = convert(HTMLString);

// ✅ Akronyme als Wörter behandeln
const xmlParser = new XmlParser();
const htmlToJson = convert(htmlString);

4. Boolean-Namen ohne is/has/can-Präfixe

// ❌ Mehrdeutiger Boolean
const active = true;

// ✅ Klare Boolean-Absicht
const isActive = true;

Automatische Konvertierung zwischen Konventionen

Wenn Sie zwischen Sprachen arbeiten, ist die manuelle Konvertierung von Namenskonventionen mühsam und fehleranfällig.

Unser String Case Converter erledigt das automatisch. Fügen Sie einen beliebigen Bezeichner ein und konvertieren Sie ihn zwischen camelCase, PascalCase, snake_case, kebab-case und mehr mit einem einzigen Klick.

Weitere Lektüre

• JSON Formatting Best Practices — Strukturieren Sie Ihre Daten so sauber wie Sie Ihre Variablen benennen
• Regex Cheat Sheet — Musterabgleich-Referenz für Validierung und Textverarbeitung
• SQL Formatting Best Practices — Schreiben Sie lesbare SQL-Abfragen

---

Bereit, Namenskonventionen automatisch zu konvertieren? Probieren Sie unseren String Case Converter — fügen Sie einen beliebigen Bezeichner ein und transformieren Sie ihn zwischen camelCase, snake_case, PascalCase, kebab-case und mehr. Keine Registrierung, keine Daten an Server gesendet, komplett kostenlos.