Case Converter

Ähnliche Tools

Was ist ein Case Converter (Namensstil-Konverter)?

Anwendungsfälle

• Umwandlung von API-Response-Feldnamen aus snake_case in camelCase für JavaScript/TypeScript-Frontends
• Konvertierung von Java-Klassennamen (PascalCase) zu Python-Variablennamen (snake_case) beim Sprachwechsel
• Umwandlung von CSS-Klassennamen in kebab-case für konsistente Stylesheet-Benennung
• Konvertierung von SQL-Spaltennamen (snake_case) zu JSON-Feldnamen (camelCase) für REST-APIs
• Vorbereitung von Dateinamen durch Konvertierung in kebab-case oder snake_case für Cross-Plattform-Kompatibilität
• Umwandlung von Blog-Titeln in URL-Slugs mithilfe von kebab-case für SEO-freundliche Pfade
• Schnelle Konvertierung von Konstantennamen in SCREAMING_SNAKE_CASE für JavaScript/Python/Java-Konfigurationen
• Umkehrung (reverse) von Textstrings zum Testen von Palindromen oder für spezielle Textverarbeitungsaufgaben

Anleitung

1. Geben Sie Ihren Text, Ihre Variablennamen oder Ihre Phrase in das Eingabefeld oben ein
2. Alle unterstützten Namensstile werden automatisch und in Echtzeit unterhalb der Eingabe angezeigt
3. Vergleichen Sie die verschiedenen Ausgabeformate (camelCase, PascalCase, snake_case usw.) nebeneinander
4. Klicken Sie auf das Kopiersymbol neben einem beliebigen Ausgabeformat, um es über die Clipboard API in die Zwischenablage zu kopieren
5. Für Stapelverarbeitung geben Sie mehrere durch Leerzeichen, Zeilenumbrüche oder Kommas getrennte Begriffe ein
6. Nutzen Sie die reverse-Option, um Text rückwärts auszugeben, oder aLtErNaTiNg cAsE (MoCk CaSe) für spielerische Textgestaltung

Funktionen

• Ein-Klick-Konvertierung zwischen allen gängigen Namensstilen: camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE_CASE und mehr
• Ideal für die Organisation von Variablennamen, Schnittstellen-Feldnamen, Dateinamen, CSS-Klassennamen und URL-Fragmenten
• Mehrere Formate werden nach der Eingabe in Echtzeit gleichzeitig ausgegeben – bequemer Vergleich und Kopie
• Verarbeitet gängige Trennzeichen: Leerzeichen, Unterstriche, Bindestriche, chinesische und englische Satzzeichen
• Zusätzliche Texttransformationen: reverse (Umkehrung), UPPER CASE, lower case, Title Case, sentence case, aLtErNaTiNg cAsE (MoCk CaSe)
• Jede Ausgabe hat einen Ein-Klick-Kopierbutton über die Clipboard API – kein manuelles Markieren nötig
• Vollständige Browser-lokale Verarbeitung: Text wird niemals an einen Server gesendet, keine Registrierung erforderlich

Codebeispiele

// Zu camelCase
function toCamelCase(str) {
  return str
    .replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '')
    .replace(/^[A-Z]/, c => c.toLowerCase());
}

// Zu PascalCase
function toPascalCase(str) {
  return str
    .replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '')
    .replace(/^[a-z]/, c => c.toUpperCase());
}

// Zu snake_case
function toSnakeCase(str) {
  return str
    .replace(/([A-Z])/g, '_$1')
    .replace(/[-_\s]+/g, '_')
    .toLowerCase()
    .replace(/^_/, '');
}

// Zu kebab-case
function toKebabCase(str) {
  return str
    .replace(/([A-Z])/g, '-$1')
    .replace(/[-_\s]+/g, '-')
    .toLowerCase()
    .replace(/^-/, '');
}

// Beispiele
console.log(toCamelCase('hello_world'));   // helloWorld
console.log(toPascalCase('hello_world'));  // HelloWorld
console.log(toSnakeCase('helloWorld'));    // hello_world
console.log(toKebabCase('helloWorld'));    // hello-world

import re

def to_camel_case(s: str) -> str:
    """Konvertiert zu camelCase (z. B. hello_world -> helloWorld)"""
    s = re.sub(r'[-_\s]+(.)?', lambda m: m.group(1).upper() if m.group(1) else '', s)
    return s[0].lower() + s[1:] if s else s

def to_pascal_case(s: str) -> str:
    """Konvertiert zu PascalCase (z. B. hello_world -> HelloWorld)"""
    s = re.sub(r'[-_\s]+(.)?', lambda m: m.group(1).upper() if m.group(1) else '', s)
    return s[0].upper() + s[1:] if s else s

def to_snake_case(s: str) -> str:
    """Konvertiert zu snake_case (z. B. helloWorld -> hello_world)"""
    s = re.sub(r'([A-Z])', r'_\1', s)
    s = re.sub(r'[-_\s]+', '_', s).lower()
    return s.lstrip('_')

def to_kebab_case(s: str) -> str:
    """Konvertiert zu kebab-case (z. B. helloWorld -> hello-world)"""
    s = re.sub(r'([A-Z])', r'-\1', s)
    s = re.sub(r'[-_\s]+', '-', s).lower()
    return s.lstrip('-')

# Beispiele
print(to_camel_case('hello_world'))   # helloWorld
print(to_pascal_case('hello_world'))  # HelloWorld
print(to_snake_case('helloWorld'))    # hello_world
print(to_kebab_case('helloWorld'))    # hello-world

public class CaseConverter {

    public static String toCamelCase(String s) {
        StringBuilder result = new StringBuilder();
        boolean nextUpper = false;
        boolean first = true;
        for (char c : s.toCharArray()) {
            if (c == '_' || c == '-' || c == ' ') {
                nextUpper = !first;
            } else {
                if (first) {
                    result.append(Character.toLowerCase(c));
                    first = false;
                } else if (nextUpper) {
                    result.append(Character.toUpperCase(c));
                    nextUpper = false;
                } else {
                    result.append(Character.toLowerCase(c));
                }
            }
        }
        return result.toString();
    }

    public static String toSnakeCase(String s) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isUpperCase(c)) {
                if (i > 0) result.append('_');
                result.append(Character.toLowerCase(c));
            } else if (c == '-' || c == ' ') {
                result.append('_');
            } else {
                result.append(c);
            }
        }
        return result.toString();
    }

    public static void main(String[] args) {
        System.out.println(toCamelCase("hello_world"));  // helloWorld
        System.out.println(toSnakeCase("helloWorld"));   // hello_world
    }
}

Welcher Namensstil ist der richtige für Ihr Projekt?

Die Wahl des Namensstils hängt von der Programmiersprache, dem Framework und den Team-Konventionen ab. Die wichtigsten Stile – camelCase, PascalCase, snake_case, kebab-case und SCREAMING_SNAKE_CASE – haben jeweils klare Anwendungsbereiche. Ein Wechsel zwischen Stilen ist bei API-Integrationen (Frontend ↔ Backend) und Sprachmigrationen häufig erforderlich.

Best Practices

Häufig gestellte Fragen

Fehlerbehebung

Glossar

camelCase

Ein Namensstil, bei dem der erste Buchstabe klein geschrieben wird und jedes nachfolgende Wort mit einem Großbuchstaben beginnt, ohne Trennzeichen (z. B. `myVariableName`). Wird in JavaScript, TypeScript, Java und C# für Variablen und Funktionen verwendet. Auch lowerCamelCase genannt.

PascalCase

Ein Namensstil, bei dem jedes Wort mit einem Großbuchstaben beginnt, ohne Trennzeichen (z. B. `MyClassName`). Wird für Klassen, Typen und Komponenten in Java, C#, TypeScript und React verwendet. Auch UpperCamelCase oder CapitalCase genannt.

snake_case

Ein Namensstil, bei dem alle Buchstaben klein geschrieben und Wörter durch Unterstriche getrennt werden (z. B. `my_variable_name`). Dies ist die Konvention in Python, Ruby, SQL und vielen Skriptsprachen.

kebab-case

Ein Namensstil, bei dem alle Buchstaben klein geschrieben und Wörter durch Bindestriche getrennt werden (z. B. `my-variable-name`). Wird in CSS-Klassennamen, HTML-Attributen, URL-Slugs und Linux-Dateinamen verwendet. Auch spine-case, lisp-case oder dash-case genannt.

SCREAMING_SNAKE_CASE

Ein Namensstil, bei dem alle Buchstaben groß geschrieben und Wörter durch Unterstriche getrennt werden (z. B. `MAX_RETRY_COUNT`). Wird für Konstanten in JavaScript, Python, Java und C verwendet. Auch CONSTANT_CASE, MACRO_CASE oder UPPER_SNAKE_CASE genannt.

Title Case

Eine Schreibweise, bei der der erste Buchstabe jedes Wortes großgeschrieben wird (z. B. `Hello World`). Wird häufig für Buchtitel, Überschriften und Artikeltitel im Englischen verwendet.

sentence case

Eine Schreibweise, bei der nur der erste Buchstabe des ersten Wortes eines Satzes großgeschrieben wird (z. B. `Hello world`). Dies ist die Standardschreibweise für Sätze in den meisten europäischen Sprachen.

aLtErNaTiNg cAsE (MoCk CaSe)

Eine spielerische Schreibweise mit abwechselnd großen und kleinen Buchstaben (z. B. `hElLo WoRlD`). Auch StUdlY CaPs oder spongecase genannt. Populär durch Meme-Kultur, hat keine technische Bedeutung.

reverse

Eine Texttransformation, bei der die Reihenfolge der Zeichen umgekehrt wird (z. B. `hello` → `olleh`). Nützlich zum Testen von Palindromen und für spezielle Textverarbeitungsaufgaben.

Naming Convention (Namenskonvention)

Eine vereinbarte Regel zur Benennung von Variablen, Funktionen, Klassen, Dateien und anderen Identifiern in der Softwareentwicklung. Verschiedene Sprachen und Communities verwenden unterschiedliche Konventionen (camelCase in Java, snake_case in Python).

Clipboard API

Eine browser-native Web-API (`navigator.clipboard`), die das asynchrone Lesen und Schreiben der Systemzwischenablage ermöglicht. Sie ersetzt ältere Methoden wie `document.execCommand('copy')` und erfordert HTTPS oder localhost.

regex

Abkürzung für Regular Expression (regulärer Ausdruck). Ein Muster zur Beschreibung und zum Durchsuchen von Zeichenketten. Wird im Case Converter zur Erkennung von Wortgrenzen und Trennzeichen verwendet.

Base64

Ein Binär-zu-Text-Kodierungsverfahren, das beliebige Binärdaten als ASCII-Zeichenkette darstellt (A-Z, a-z, 0-9, +, /, =). Die Groß-/Kleinschreibung ist bei Base64 signifikant – eine Änderung zerstört die dekodierten Daten. Case Converter sollte nicht auf Base64-Strings angewendet werden.

ASCII / Unicode / UTF-8

ASCII ist ein 7-Bit-Zeichenkodierungsstandard für lateinische Buchstaben, Ziffern und Steuerzeichen. Unicode ist ein universeller Zeichenstandard, der fast alle Schriftsysteme der Welt umfasst. UTF-8 ist eine Byte-kompatible Kodierung von Unicode und die dominante Kodierung im Web.

Namensstil-Übersicht: Alle unterstützten Formate auf einen Blick

Namensstil nach Sprache/Ökosystem

Privacy & Security

Alle Konvertierungen laufen vollständig lokal in Ihrem Browser mit JavaScript ab. Eingegebener Text wird niemals über das Netzwerk an einen Server gesendet, nicht gespeichert, nicht aufgezeichnet und nicht analysiert. Es findet keine Server-seitige Verarbeitung statt. Die Seite kann nach dem ersten Laden auch offline verwendet werden. Die Clipboard API wird nur bei explizitem Klick auf einen Kopierbutton verwendet, um Text in Ihre lokale Zwischenablage zu schreiben.

Authoritative References

• MDNMDN: Clipboard API Dokumentation
• WikipediaWikipedia: Naming Convention (Programmierung)
• GoogleGoogle Java Style Guide – Naming
• Python.orgPEP 8 – Style Guide for Python Code