T
case-converter text-utility programming formatting

Der ultimative Case Converter: Textstile sofort umwandeln

Wechseln Sie mühelos zwischen GROSSBUCHSTABEN, kleinschreibung, camelCase, PascalCase und mehr. Ein vielseitiges Tool für Entwickler und Autoren.

2026-04-09 Dieses Tool verwenden

Was ist Textcase? Geschichte und Herkunft

Das Wort „case" für Groß- und Kleinschreibung hat einen sehr konkreten historischen Ursprung: den Bleisatz der Druckerei. Setzer bewahrten ihre Lettern in zwei übereinanderliegenden flachen Kästen auf — dem „upper case" (oberer Kasten) für Großbuchstaben und dem „lower case" (unterer Kasten) für Kleinbuchstaben. Diese physische Herkunft prägte eine Terminologie, die das mechanische Zeitalter und die digitale Revolution überlebte.

Mit dem Aufkommen der Computerprogrammierung entstand eine praktische Einschränkung: Bezeichner durften keine Leerzeichen enthalten. Um zusammengesetzte Namen dennoch lesbar zu halten, entwickelten Programmierer organisch unterschiedliche Schreibweisenstile. C popularisierte den Unterstrich als Trennzeichen, Smalltalk erfand das camelCase, die Sprache Pascal machte die Großschreibung des Anfangsbuchstabens jedes Wortes bekannt, und CSS führte den Bindestrich als Separator ein.

Ein moderner Fullstack-Entwickler wechselt im Laufe eines Arbeitstages zwischen TypeScript im Frontend, Python im Backend, SQL in der Datenbank und JSON in der REST-API — jede Schicht hat ihre eigenen Namenskonventionen. Genau deshalb ist ein zuverlässiger Case-Konverter im Entwickleralltag unverzichtbar.

Alle Case-Typen im Detail

camelCase

Das erste Wort ist vollständig kleingeschrieben, jedes folgende Wort beginnt mit einem Großbuchstaben. Kein Trennzeichen.

Beispiele: myVariableName, getUserById, fetchDataFromApi

Verwendet in: JavaScript (Variablen, Funktionen), TypeScript (Variablen, Funktionen), Java (Variablen, Methoden), Swift, Kotlin.

Der Name kommt von den „Höckern", die die eingestreuten Großbuchstaben bilden — ähnlich dem Rücken eines Kamels. Es ist der Standardstil für Nicht-Typ-Bezeichner in den meisten C-ähnlichen Sprachen.

PascalCase (UpperCamelCase)

Wie camelCase, aber auch der erste Buchstabe des ersten Wortes wird großgeschrieben. Alle Wörter beginnen mit einem Großbuchstaben.

Beispiele: MyClassName, HttpRequestHandler, UserProfileService

Verwendet in: C# (Klassen, Interfaces, Methoden), TypeScript (Klassen, Interfaces, Enums), Java (Klassen), .NET-Ökosystem allgemein.

PascalCase dient als visuelles Signal: „Dies ist ein Typ." Es wurde durch die Sprache Pascal bekannt, obwohl Smalltalk einen ähnlichen Stil schon früher verwendete.

snake_case

Alle Buchstaben kleingeschrieben, Wörter durch Unterstriche getrennt.

Beispiele: my_variable_name, get_user_by_id, calculate_total_price

Verwendet in: Python (von PEP 8 vorgeschrieben für Variablen, Funktionen, Module), Ruby, Rust, SQL-Spaltennamen, C-Standardbibliothek.

Der Unterstrich fungiert als klarer visueller Separator, wodurch lange Bezeichner sehr gut lesbar bleiben.

kebab-case

Alle Buchstaben kleingeschrieben, Wörter durch Bindestriche getrennt.

Beispiele: my-css-class, user-profile-card, background-color

Verwendet in: CSS-Eigenschaftsnamen (font-size, border-radius), HTML-Attribute, URL-Slugs, YAML/TOML-Konfigurationsschlüssel.

In den meisten Programmiersprachen wird der Bindestrich als Subtraktionsoperator interpretiert, weshalb kebab-case nicht als Variablenname verwendet werden kann. In CSS und URLs ist es jedoch der dominierende Standard.

SCREAMING_SNAKE_CASE (UPPER_SNAKE_CASE)

Wie snake_case, aber vollständig in Großbuchstaben.

Beispiele: MAX_RETRY_COUNT, API_BASE_URL, DEFAULT_TIMEOUT_MS

Verwendet in: Konstanten in nahezu allen Sprachen — Python, JavaScript/TypeScript, Java (static final), C-Makros, Umgebungsvariablen des Betriebssystems.

Die optische Wirkung der Großbuchstaben vermittelt eine klare Botschaft: „Dieser Wert ändert sich zur Laufzeit nicht." Linter in den meisten Ökosystemen warnen, wenn diese Konvention verletzt wird.

Title Case

Der Anfangsbuchstabe jedes bedeutsamen Wortes wird großgeschrieben. Artikel, Präpositionen und Konjunktionen bleiben je nach Styleguide klein.

Beispiele: My Article Title, Introduction to Machine Learning

Verwendet in: Überschriften von Artikeln und Büchern, UI-Schaltflächenbeschriftungen, Marketingtexte.

Sentence case

Nur der erste Buchstabe des ersten Wortes wird großgeschrieben (sowie Eigennamen).

Beispiele: This is a paragraph heading

Verwendet in: Normale Prosa, einige UI-Beschriftungen, Titelkonventionen in europäischen Sprachen.

Die Material-Design-Richtlinien empfehlen Sentence case für Fließtext und sekundäre Beschriftungen.

flatcase

Alle Buchstaben kleingeschrieben, kein Trennzeichen.

Beispiele: myvariable, httphandler, packagename

Verwendet in: Go-Paketnamen (fmt, http, strconv), Java-Paketnamen (com.example.myapp).

Flatcase opfert Lesbarkeit zugunsten von Kürze und eignet sich daher nur für kurze Bezeichner mit einem einzelnen Konzept.

Warum Namenskonventionen wichtig sind

Namenskonventionen sind keine ästhetische Präferenz — sie sind ein Kommunikationsprotokoll innerhalb eines Entwicklungsteams.

Wenn eine gesamte Codebasis einheitliche Konventionen befolgt, können Entwickler die Bedeutung eines Bezeichners allein aus seiner Form ableiten:

  • MyService in TypeScript signalisiert sofort: das ist ein Typ.
  • MAX_CONNECTIONS signalisiert: das ist eine Konstante.
  • user_id in einer SQL-Abfrage signalisiert: das ist eine Datenbankspalte.

Lesbarkeit: Eine Studie von Binkley et al. (2009) ergab, dass camelCase bei kurzen Bezeichnern schneller gelesen wird, während snake_case bei langen zusammengesetzten Wörtern besser verständlich ist.

Team-Konsistenz: Das Mischen von getUserById und get_user_by_id in derselben Codebasis erzeugt unnötigen kognitiven Aufwand beim Code-Review. Automatisierte Linter wie ESLint, flake8 oder golangci-lint können Namenskonventionen durchsetzen und diese Debatte vollständig aus dem Review-Prozess eliminieren.

Tooling-Unterstützung: IDE-Autovervollständigung, Refactoring-Tools und Dokumentationsgeneratoren verlassen sich auf konsistente Namensmuster, um korrekt zu funktionieren.

Sprachspezifische Namenskonventionen

JavaScript / TypeScript

Variablen und Funktionen:   camelCase       (let userName, function getData)
Klassen und Interfaces:     PascalCase      (class UserService, interface IRepository)
Konstanten:                 SCREAMING_SNAKE  (const MAX_SIZE = 100)
Enumerationen:              PascalCase      (enum Direction)
Dateinamen:                 kebab-case      (user-service.ts, api-client.ts)
CSS-Klassen:                kebab-case      (.btn-primary, .card-header)

Python (PEP 8)

Variablen und Funktionen:   snake_case      (user_name, get_data)
Klassen:                    PascalCase      (class UserService)
Konstanten:                 SCREAMING_SNAKE  (MAX_SIZE = 100)
Module:                     snake_case      (my_module.py)
Private Mitglieder:         _single_leading_underscore

Go

Exportierte Bezeichner:     PascalCase      (func GetUser, type UserService)
Nicht exportierte Bezeichner: camelCase    (func getUser, var userCount)
Paketnamen:                 flatcase        (package http, package fmt)

Go verwendet Case als Sichtbarkeitsmodifikator: PascalCase = öffentlich (exportiert), camelCase = privat (nicht exportiert). Der Compiler erzwingt dies.

Java

Variablen und Methoden:     camelCase       (String userName, void getData())
Klassen und Interfaces:     PascalCase      (class UserService)
Konstanten:                 SCREAMING_SNAKE  (static final int MAX_SIZE = 100)
Pakete:                     flatcase        (com.example.myapp)

CSS und HTML

Klassennamen:               kebab-case      (.btn-primary, .nav-item)
Custom Properties:          kebab-case      (--primary-color, --font-size-lg)

SQL / Datenbanken

Tabellennamen:              snake_case      (user_profiles, order_items)
Spaltennamen:               snake_case      (first_name, created_at)

Technische Funktionsweise des Konverters

Ein Case-Konverter muss zwei grundlegende Probleme lösen:

  1. Wortgrenzenerkennnung: Einen String in beliebigem Format in eine Liste von Token (Wörtern) zerlegen.
  2. Neuzusammensetzung: Diese Token im Zielformat wieder zusammenfügen.

Die Wortgrenzenerkennung nutzt reguläre Ausdrücke, um Übergangspunkte zu identifizieren:

  • Von Kleinbuchstabe zu Großbuchstabe: camelCase → camel, Case
  • Unter- oder Bindestrich: snake_case → snake, case
  • Leerzeichen
  • Zifferngrenzen (optional): base64Encode → base64, Encode

Der kniffligste Sonderfall sind Akronyme: XMLParser muss in XML, Parser aufgeteilt werden — nicht in X, M, L, Parser.

Codebeispiele

Python

import re

def tokenize(text: str) -> list[str]:
    """Teilt beliebige Schreibweisen in eine Liste kleingeschriebener Token auf."""
    text = re.sub(r'(?<=[a-z0-9])(?=[A-Z])', '_', text)
    text = re.sub(r'(?<=[A-Z])(?=[A-Z][a-z])', '_', text)
    words = re.split(r'[\s_\-]+', text)
    return [w.lower() for w in words if w]

def to_snake_case(text: str) -> str:
    return '_'.join(tokenize(text))

def to_camel_case(text: str) -> str:
    words = tokenize(text)
    return words[0] + ''.join(w.title() for w in words[1:])

def to_pascal_case(text: str) -> str:
    return ''.join(w.title() for w in tokenize(text))

def to_kebab_case(text: str) -> str:
    return '-'.join(tokenize(text))

def to_screaming_snake(text: str) -> str:
    return '_'.join(tokenize(text)).upper()

# Beispiele
print(to_snake_case("getUserByID"))     # get_user_by_id
print(to_camel_case("user_profile"))    # userProfile
print(to_pascal_case("my-css-class"))  # MyCssClass
print(to_screaming_snake("apiBaseUrl")) # API_BASE_URL

JavaScript / TypeScript

function tokenize(str) {
  return str
    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
    .split(/[\s_\-]+/)
    .filter(Boolean)
    .map(w => w.toLowerCase());
}

function toKebabCase(str) {
  return tokenize(str).join('-');
}

function toCamelCase(str) {
  const words = tokenize(str);
  return words[0] + words.slice(1).map(w => w[0].toUpperCase() + w.slice(1)).join('');
}

function toPascalCase(str) {
  return tokenize(str).map(w => w[0].toUpperCase() + w.slice(1)).join('');
}

// Beispiele
console.log(toKebabCase('MyBackgroundColor'));  // my-background-color
console.log(toCamelCase('user_profile_page'));  // userProfilePage
console.log(toPascalCase('get-user-by-id'));    // GetUserById

Go

package main

import (
    "strings"
    "unicode"
)

func tokenize(s string) []string {
    var words []string
    var current strings.Builder

    runes := []rune(s)
    for i, r := range runes {
        if r == '_' || r == '-' || r == ' ' {
            if current.Len() > 0 {
                words = append(words, strings.ToLower(current.String()))
                current.Reset()
            }
            continue
        }
        if unicode.IsUpper(r) && current.Len() > 0 {
            if i+1 < len(runes) && unicode.IsLower(runes[i+1]) {
                words = append(words, strings.ToLower(current.String()))
                current.Reset()
            }
        }
        current.WriteRune(r)
    }
    if current.Len() > 0 {
        words = append(words, strings.ToLower(current.String()))
    }
    return words
}

func ToCamelCase(s string) string {
    words := tokenize(s)
    if len(words) == 0 {
        return ""
    }
    result := words[0]
    for _, w := range words[1:] {
        result += strings.Title(w)
    }
    return result
}

Reale Anwendungsfälle

API-Design und Dokumentation

Beim Entwurf einer REST-API ist Konsistenz zwischen URL-Slugs (kebab-case), JSON-Payload-Schlüsseln (camelCase im JavaScript-Ökosystem, snake_case in Python) und Datenbankspalten (snake_case) entscheidend.

Typische Konvertierungskette:

  • Datenbankspalte: user_created_at
  • JSON-API-Antwort: userCreatedAt
  • URL-Parameter: user-created-at
  • Konstante im Code: USER_CREATED_AT

Datenbankmigrationen

Bei der Migration zwischen ORMs oder Datenbank-Engines unterscheiden sich die Benennungskonventionen für Spalten oft erheblich. ActiveRecord (Ruby on Rails) bevorzugt snake_case; einige Legacy-Systeme verwenden PascalCase. Eine Batch-Konvertierung spart Stunden manueller Arbeit.

Code-Refactoring

Große Codebasen akkumulieren inkonsistente Benennungen aus unterschiedlichen Epochen oder von verschiedenen Beitragenden. Während Refactoring-Sprints hilft ein Case-Konverter, Listen von Bezeichnern schnell zu verarbeiten.

Bibliotheksvergleich: Eigene Regex vs. Bibliotheken

JavaScript: change-case

import { camelCase, snakeCase, pascalCase, kebabCase } from 'change-case';

camelCase('user_profile_page');  // 'userProfilePage'
snakeCase('getUserById');        // 'get_user_by_id'
pascalCase('my-css-class');      // 'MyCssClass'

Behandelt Unicode, Akronyme und Zahlen korrekt.

JavaScript: Lodash

import _ from 'lodash';
_.camelCase('Foo Bar');   // 'fooBar'
_.snakeCase('fooBar');    // 'foo_bar'
_.kebabCase('fooBar');    // 'foo-bar'

Python: inflection

import inflection
inflection.camelize('device_type')        # 'DeviceType'
inflection.underscore('DeviceType')       # 'device_type'
inflection.dasherize('device_type')       # 'device-type'

Eigene Implementierung vs. Bibliothek: In der Produktion sollten Bibliotheken bevorzugt werden (bessere Behandlung von Sonderfällen, Unicode-Unterstützung, Community-Wartung). Eigene Implementierungen sind nur in eingeschränkten Umgebungen ohne Abhängigkeiten sinnvoll.

Best Practices

1. Konsistenz vor persönlicher Präferenz

Die beste Namenskonvention für ein Projekt ist die, die das gesamte Team einheitlich verwendet. Das Mischen von snake_case und camelCase in derselben Codebasis ist schlimmer als die ausschließliche Verwendung von einer der beiden.

2. Mit Lintern automatisieren

Verlasse dich nicht auf das Gedächtnis der Entwickler:

  • ESLint mit @typescript-eslint/naming-convention (JavaScript/TypeScript)
  • flake8 mit pep8-naming-Plugin (Python)
  • golangci-lint mit revive-Linter (Go)
  • RuboCop (Ruby)

3. Konventionen dokumentieren

Füge einen Abschnitt in die CONTRIBUTING.md deines Projekts ein, der für jeden Bezeichnertyp die anzuwendende Konvention festlegt.

4. Sprach-Idiome respektieren

Externe Konventionen nicht auf eine Sprache aufzwingen. camelCase in Python zu verwenden, weil „der Rest des Stacks das verwendet", ist ein Antipattern — es kämpft gegen das Tooling der Sprache und die Erwartungen jedes Python-Entwicklers.

5. Akronyme konsistent behandeln

Wähle einen Ansatz und dokumentiere ihn:

  • XMLParser oder XmlParser oder xmlParser?
  • userID oder userId?
  • Googles Go-Styleguide bevorzugt userID und xmlParser; die meisten JS-Styleguides bevorzugen userId und xmlParser.

Häufig gestellte Fragen

F: Ist PascalCase dasselbe wie UpperCamelCase? Ja, es handelt sich um dieselbe Konvention. „PascalCase" ist in der Entwicklergemeinschaft gebräuchlicher. „UpperCamelCase" wird in akademischen oder formellen Dokumenten verwendet, um es vom normalen camelCase (manchmal lowerCamelCase genannt) zu unterscheiden.

F: Warum kann ich kebab-case nicht für Variablennamen in JavaScript verwenden? Weil der Bindestrich - in JavaScript (und den meisten C-ähnlichen Sprachen) als Subtraktionsoperator interpretiert wird. Der Ausdruck my-variable wird als my minus variable geparst, nicht als einzelner Bezeichner. Konfigurationssprachen (YAML, CSS) haben diese Einschränkung nicht.

F: Kann der Konverter Unicode und Nicht-ASCII-Zeichen verarbeiten? Robuste Implementierungen können das. Einfache Regex-Ansätze behandeln akzentuierte Zeichen (é, ü, ñ) möglicherweise als Wortgrenzen oder verlieren ihre Groß-/Kleinschreibungsinformation. Bibliotheken wie change-case für JavaScript verarbeiten gängige Unicode-Fälle korrekt.

F: Welches Case sollte ich für React-Komponentendateien verwenden? Die React-Community verwendet PascalCase sowohl für den Komponentennamen als auch für den Dateinamen: UserProfileCard.tsx. Dies unterscheidet Komponentendateien auf einen Blick von Utility-Dateien (utils.ts, api-client.ts).

F: Wie soll ich Zahlen in Bezeichnern behandeln? Die meisten Tokenizer behandeln eine Ziffernfolge als eigenes Token. base64Encoder → base64, Encoder → base64_encoder in snake_case. Stelle sicher, dass dein Tokenizer gängige Begriffe wie md5, sha256, oauth2 konsistent behandelt.

F: Sollten Datenbankspalten snake_case verwenden, auch wenn die Anwendung camelCase nutzt? Fast immer ja. SQL unterscheidet in den meisten Datenbanken keine Groß-/Kleinschreibung, und firstName könnte von verschiedenen Tools unterschiedlich interpretiert werden. snake_case ist die universelle SQL-Konvention und wird von jedem ORM verstanden. Das Mapping zu camelCase erfolgt in der Anwendungsschicht.

F: Welches Case sollte ich für Umgebungsvariablen verwenden? SCREAMING_SNAKE_CASE ist der universelle Standard für Umgebungsvariablen: DATABASE_URL, JWT_SECRET, PORT. Diese Konvention wird von der Twelve-Factor-App-Methodik, Docker, Kubernetes und praktisch allen Deployment-Plattformen befolgt.

Überblick

Textformatierung ist ein grundlegender Bestandteil von Programmierung und Schreiben. Unser Case-Konverter ist ein Hochleistungswerkzeug, das entwickelt wurde, um Benutzern zu helfen, die Schreibweise ihres Textes sofort zu transformieren. Egal, ob Sie einen „FESTSTELLTASTE“-Fehler beheben oder einen Variablennamen für eine andere Programmiersprache konvertieren müssen, unser Tool bietet eine umfassende Auswahl an Optionen, um die Aufgabe ohne manuelles Abtippen zu erledigen.

Hauptmerkmale

  • Mehrere Schreibweisen: Unterstützt GROSSBUCHSTABEN, Kleinbuchstaben, Satzanfang (Sentence case), Titel-Schreibweise (Title Case), camelCase, PascalCase, snake_case und kebab-case.
  • Live-Transformation: Sehen Sie zu, wie sich Ihr Text in Echtzeit ändert, während Sie tippen oder Text einfügen.
  • Saubere Benutzeroberfläche: Auf Schnelligkeit ausgelegt mit Ein-Klick-Kopier- und Lösch-Buttons.
  • Universelle Kompatibilität: Funktioniert mit jedem UTF-8-Text und unterstützt Sonderzeichen sowie verschiedene Sprachen.

Anwendung

  1. Text einfügen: Geben Sie den Text, den Sie transformieren möchten, in das Eingabefeld ein.
  2. Modus wählen: Wählen Sie das gewünschte Format aus dem Menü aus.
  3. Verfeinern: Aktivieren Sie Optionen wie „Zusätzliche Leerzeichen entfernen“, falls verfügbar.
  4. Kopieren: Klicken Sie auf den Kopier-Button, um Ihren neu formatierten Text sofort zu erhalten.

Häufige Anwendungsfälle

  • Programmierung & Skripting: Konvertieren Sie schnell variablen_namen in camelCase oder UPPER_SNAKE_CASE für verschiedene Konventionen.
  • Inhaltsbearbeitung: Korrigieren Sie versehentlich großgeschriebene Sätze oder formatieren Sie Titel für Blogbeiträge.
  • Datenbankverwaltung: Standardisieren Sie Feldnamen oder Eintragswerte während der Datenbereinigung.
  • Soziale Medien: Erstellen Sie stilisierten Text für Posts und Bios.

Technischer Hintergrund

Das Tool verwendet spezialisierte reguläre Ausdrücke (Regex), um Wortgrenzen zu identifizieren und die Transformationslogik anzuwenden. Um beispielsweise in camelCase zu konvertieren, identifiziert der Algorithmus Leerzeichen, Unterstriche und Bindestriche, entfernt diese und schreibt den ersten Buchstaben der nachfolgenden Wörter groß.

Häufig gestellte Fragen

  • Ist es sicher? Ja, alle Transformationen finden in Ihrem Browser statt; wir speichern Ihren Text niemals.
  • Unterstützt es große Texte? Ja, es kann tausende Wörter sofort verarbeiten.
  • Kann ich die Aktion rückgängig machen? Verwenden Sie den Standard-Browser-Befehl CMD/CTRL+Z oder ändern Sie einfach den Modus erneut.

Einschränkungen

  • Kontextuelle Nuancen: Die Satz-Schreibweise (Sentence case) erkennt Eigennamen möglicherweise nicht immer korrekt.
  • Akronyme: Die Transformation in die Titel-Schreibweise (Title Case) kann je nach Algorithmus einige Akronyme kleinschreiben.
  • Komplexe Symbole: Nicht-alphanumerische Zeichen bleiben im Allgemeinen erhalten, können aber die Erkennung von Wortgrenzen beeinflussen.
Zurück zum Blog Groß-/Kleinschreibung-Konverter →