camelCase in snake_case umwandeln: Regeln für alle Schreibweisen

VeröffentlichtToolBezeichner umwandeln: camelCase, snake_case, kebab-case, CONSTANT_CASE

Inhalt
  1. Wann Sie Schreibweisen umwandeln müssen
  2. Wörter ohne Tool selbst trennen und Schreibweisen anwenden
  3. Umwandlungsergebnisse, die oft verwirren
  4. Zusammenfassung
  5. Technischer Hintergrund: Erkennung von Wortgrenzen per regulärem Ausdruck und Tokenizer
  6. Die 7 wichtigsten Schreibweisen (Casing Conventions) im Vergleich
  7. Die 5 häufigsten und folgenreichsten Fehler beim Umwandeln der Schreibweise
  8. Altlasten bereinigen: Refactoring der Namensgebung in 5 Schritten
  9. 7 Tipps zu Namensgebung und Schreibweise
  10. Entscheidungsbaum: Die passende Schreibweise finden
  11. Fachbegriffe im Überblick: Spickzettel für Profis (Terminologie)
  12. Häufig gestellte Fragen

Bei camelCase und snake_case entsteht die Verwirrung nicht, weil die Schreibweisen unbekannt wären, sondern weil man die Regeln nicht kennt: An welcher Stelle wird ein Text in Wörter zerlegt, und mit welchem Zeichen werden diese Wörter wieder verbunden?

Mit diesen Regeln lässt sich erklären, wie aus myVariableName der Bezeichner my_variable_name wird. Genauso erklärt sich, warum Texte mit Ziffern und Sonderzeichen anders zerlegt werden, als man erwartet.

Dieser Beitrag richtet sich an Entwickler, die mit Schreibweisen für Variablen- und Dateinamen arbeiten, und an alle, die Umwandlungsergebnisse selbst nachprüfen müssen.

Kurzfassung ① Wörter werden an zwei Stellen getrennt: dort, wo auf einen lateinischen Kleinbuchstaben oder eine Ziffer direkt ein Großbuchstabe folgt, und dort, wo eine Folge von Zeichen steht, die weder Buchstaben noch Ziffern noch Hangul sind. ② camelCase und PascalCase setzen die getrennten Wörter ohne Zeichen zusammen, snake_case, kebab-case und CONSTANT_CASE verbinden sie mit Unterstrich bzw. Bindestrich. ③ Title Case und die Satzschreibweise nutzen diese Regel zur Worttrennung nicht. Wenn Sie einen camelCase-Text ohne Leerzeichen einsetzen, wird er daher nicht in einzelne Wörter zerlegt.

Wann Sie Schreibweisen umwandeln müssen

In API-Dokumentationen oder Design-Spezifikationen stehen oft Namen wie „User Profile Image“, die für Menschen gut lesbar sind. Im Code lassen sich solche Namen nicht einfach übernehmen. Dort sieht es in der Praxis so aus:

  • JavaScript-Variablennamen: camelCase (z. B. userProfileImage)
  • Spaltennamen in Datenbanken: snake_case (z. B. user_profile_image)
  • CSS Custom Properties und URL-Pfade: kebab-case (z. B. user-profile-image)
  • Umgebungsvariablen: CONSTANT_CASE (z. B. USER_PROFILE_IMAGE)

Schwierig wird es, wenn Ziffern oder Abkürzungen im Namen vorkommen. Bei Texten wie getUserID oder html5Video, in denen Groß- und Kleinbuchstaben und Ziffern gemischt sind, beurteilt jeder von Hand anders, wo getrennt werden muss.

So kommt es vor, dass derselbe Name im Team mal als getUserId, mal als getUserID und mal als get_user_id geschrieben wird. Wenn Sie wissen, dass für jede Schreibweise genau festgelegt ist, wie Wörter getrennt und zusammengesetzt werden, können Sie solche Abweichungen anhand der Regeln überprüfen.

Wörter ohne Tool selbst trennen und Schreibweisen anwenden

Die Umwandlung läuft in zwei Schritten ab. Zuerst wird der Text in Wörter zerlegt, danach werden die Wörter nach der Regel der jeweiligen Schreibweise wieder zusammengesetzt. Wenn Sie diese beiden Schritte von Hand nachvollziehen, erhalten Sie auch ohne Tool dasselbe Ergebnis.

Schritt 1: Wortgrenzen finden

camelCase, PascalCase, snake_case, kebab-case und CONSTANT_CASE finden Wortgrenzen nach zwei Regeln:

  • Regel 1 (Groß-/Kleinschreibung): Folgt auf einen lateinischen Kleinbuchstaben oder eine Ziffer direkt ein Großbuchstabe, wird dazwischen getrennt. myVariableName wird zu my / Variable / Name, html5Video zu html5 / Video.
  • Regel 2 (Zeichen als Grenze): Steht ein einzelnes Zeichen oder eine ganze Folge von Zeichen, die weder lateinische Buchstaben noch Ziffern noch Hangul sind (Leerzeichen, Unterstriche, Bindestriche, Punkte usw.), gilt der gesamte Abschnitt als Grenze, und nur die Buchstaben links und rechts bleiben als Wörter übrig. Bei hello___world ergeben sich trotz der drei Unterstriche nur die beiden Wörter hello / world.

Title Case und die Satzschreibweise arbeiten dagegen nur ähnlich wie Regel 2: Als Wort gilt jeweils ein Block, der durch Leerzeichen oder Zeichen abgetrennt ist. Regel 1 (Groß-/Kleinschreibung) wenden sie nicht an.

Wenn Sie also einen camelCase-Text ohne Leerzeichen in Title Case umwandeln, wird getUserID nicht in Wörter zerlegt, sondern bleibt ein einziger Block, bei dem nur der erste Buchstabe groß ist (Getuserid).

Wandeln Sie denselben Text dagegen in camelCase um, wird er korrekt in die drei Wörter get / User / ID zerlegt, und das Ergebnis ist getUserId.

Schritt 2: Die getrennten Wörter nach der Regel der Schreibweise zusammensetzen

SchreibweiseRegel zum Zusammensetzen der Wörter
GROSSBUCHSTABEN (UPPER)Der gesamte Text wird in Großbuchstaben umgewandelt (keine Worttrennung)
kleinbuchstaben (lower)Der gesamte Text wird in Kleinbuchstaben umgewandelt (keine Worttrennung)
Title CaseBei jedem durch Leerzeichen oder Zeichen abgetrennten Block wird nur der erste Buchstabe großgeschrieben
Satzschreibweise (Sentence case)Der gesamte Text wird kleingeschrieben, danach wird nur der erste Buchstabe des Satzes großgeschrieben
camelCaseDas erste Wort wird kleingeschrieben, bei den folgenden Wörtern nur der erste Buchstabe großgeschrieben, alles ohne Zeichen aneinandergehängt
PascalCaseBei allen Wörtern wird der erste Buchstabe großgeschrieben, alles ohne Zeichen aneinandergehängt
snake_caseAlle Wörter werden kleingeschrieben und mit Unterstrich (_) verbunden
kebab-caseAlle Wörter werden kleingeschrieben und mit Bindestrich (-) verbunden
CONSTANT_CASEAlle Wörter werden großgeschrieben und mit Unterstrich (_) verbunden

Bei camelCase und PascalCase bedeutet „nur den ersten Buchstaben großschreiben“, dass alle übrigen Buchstaben zwangsweise in Kleinbuchstaben umgewandelt werden.

Abkürzungen wie ID oder URL, die in einem Wort bereits aus mehreren Großbuchstaben bestehen, behalten deshalb nur den ersten Buchstaben als Großbuchstaben, der Rest wird klein. Das hilft beim Nachprüfen, wie unten beschrieben.

Probieren Sie es mit unserem Tool „Bezeichner umwandeln: camelCase, snake_case, kebab-case, CONSTANT_CASE“ aus.

Bezeichner umwandeln: camelCase, snake_case, kebab-case, CONSTANT_CASE

Wandelt Text sofort in GROSSBUCHSTABEN, kleinbuchstaben, Title Case, Satzschreibweise, camelCase, PascalCase, snake_case, kebab-case und CONSTANT_CASE um. Kostenlos, ohne Installation und Anmeldung.

Umwandlungsergebnisse, die oft verwirren

Gibt man denselben Text in mehrere Schreibweisen ein, kommen manchmal Ergebnisse heraus, die sich anhand der Regeln allein schwer vorhersagen lassen. Die folgenden Fälle treten in der Praxis besonders häufig auf.

Verwirrende SituationTatsächliche Regel
getUserID wird in camelCase zu getUserId, es steht also Id statt IDBeim Zusammensetzen bleibt von jedem Wort nur der erste Buchstabe ein Großbuchstabe, alle anderen werden klein. Schreibweisen, die ganze Wörter großschreiben, wie CONSTANT_CASE (GET_USER_ID), behalten die Abkürzung unverändert bei.
html5Video wird nach der 5 getrennt: html5 VideoFolgt auf einen Kleinbuchstaben oder eine Ziffer direkt ein Großbuchstabe, gilt diese Stelle als Wortgrenze. Steht eine Ziffer zwischen Kleinbuchstaben (z. B. user2name), wird dort nicht getrennt.
myVariableName wird in Title Case nicht in einzelne Wörter zerlegtTitle Case und die Satzschreibweise erkennen nur Leerzeichen und Zeichen als Grenzen. Die Trennung nach Groß-/Kleinschreibung gilt nur für die fünf Schreibweisen der camelCase-Familie.
Bei 이름Name, wo auf Hangul direkt ein lateinischer Großbuchstabe folgt, wird nicht getrenntDie Regel zur Groß-/Kleinschreibung greift nur zwischen lateinischen Kleinbuchstaben bzw. Ziffern und Großbuchstaben. Hangul ist von dieser Regel nicht betroffen.
Bei hello___world entsteht trotz mehrerer aufeinanderfolgender Trennzeichen kein leeres WortAufeinanderfolgende Zeichen werden zu einer einzigen Grenze zusammengefasst.

Zusammenfassung

  • Die Umwandlungsarten lassen sich in zwei Gruppen einteilen: Die eine behandelt den Text als Ganzes (GROSSBUCHSTABEN, kleinbuchstaben, Title Case, Satzschreibweise), die andere zerlegt ihn in Wörter und setzt diese wieder zusammen (camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE).
  • In der Gruppe mit Worttrennung wird dort getrennt, wo auf einen lateinischen Kleinbuchstaben oder eine Ziffer direkt ein Großbuchstabe folgt, und dort, wo eine Folge von Zeichen steht, die weder lateinische Buchstaben noch Ziffern noch Hangul sind.
  • camelCase und PascalCase behalten von jedem Wort nur den ersten Buchstaben groß und machen den Rest klein. Abkürzungen aus aufeinanderfolgenden Großbuchstaben verlieren dadurch ihre ursprüngliche Form.
  • Title Case und die Satzschreibweise erkennen keine Grenzen nach Groß-/Kleinschreibung, sondern nur Leerzeichen und Zeichen. Ein camelCase-Text ohne Leerzeichen wird deshalb nicht in einzelne Wörter zerlegt.
  • Hangul kennt keine Groß- und Kleinschreibung und bleibt daher bei jeder Schreibweise unverändert.
Bezeichner umwandeln: camelCase, snake_case, kebab-case, CONSTANT_CASE

Wandelt Text sofort in GROSSBUCHSTABEN, kleinbuchstaben, Title Case, Satzschreibweise, camelCase, PascalCase, snake_case, kebab-case und CONSTANT_CASE um. Kostenlos, ohne Installation und Anmeldung.


Technischer Hintergrund: Erkennung von Wortgrenzen per regulärem Ausdruck und Tokenizer

Hinter der scheinbar simplen Umwandlung von Schreibweisen stecken aufwendige String-Verarbeitung und die Grenzerkennung regulärer Ausdrücke (Regular Expressions). Vor allem Abkürzungen zu erhalten und die Übergänge zwischen Groß- und Kleinschreibung exakt zu erfassen, ist auch aus informatischer Sicht ein recht kniffliges Tokenisierungsproblem (Tokenization).

Lookahead und Lookbehind in regulären Ausdrücken (Lookaround)

Mit gewöhnlichen regulären Ausdrücken lässt sich eine zusammenhängende Zeichenkette nur schwer zerschneiden. Deshalb kombiniert man Lookbehind- und Lookahead-Assertions (Rückwärts- und Vorwärtssuche), um virtuelle Trenngrenzen zu erzeugen. Das grundlegende Muster zum Aufteilen von camelCase lautet: Regulärer Ausdruck: (?<=[a-z0-9])(?=[A-Z]) Dieses Muster trifft auf die Position zu, vor der ein Kleinbuchstabe oder eine Ziffer steht und nach der ein Großbuchstabe folgt. So wird myVariableName in my, Variable und Name zerlegt. Problematisch wird es, wenn mehrere Abkürzungen aufeinanderfolgen. Ein Wort wie HTTPServer wird mit dem obigen Ausdruck allein nicht in HTTP und Server getrennt. Dafür kommt eine zweite Regel hinzu: Regulärer Ausdruck: (?<=[A-Z])(?=[A-Z][a-z]) Dieses Muster trifft auf die Position zu, vor der ein Großbuchstabe steht und nach der die Kombination aus Großbuchstabe und Kleinbuchstabe folgt. Damit findet es die Grenze zwischen HTTP und Server exakt.

Die Tokenisierungs-Pipeline für Zeichenketten

Ein Konverter für Schreibweisen durchläuft in der Regel eine Pipeline mit vier Schritten:

  1. Normalisierung (Normalization): Leerzeichen am Anfang und Ende der Eingabe werden entfernt, aufeinanderfolgende Sonderzeichen oder Trennzeichen durch ein einzelnes Leerzeichen ersetzt.
  2. Zerlegung in Tokens (Split into tokens): Mit der oben beschriebenen Lookaround-Technik wird die Zeichenkette in ein Array einzelner Wörter (Tokens) zerlegt.
  3. Groß-/Kleinschreibung pro Token (Casing transformation per token): Die Schreibung jedes Tokens wird an die Zielschreibweise angepasst. Bei PascalCase wird etwa bei jedem Token der erste Buchstabe groß- und der Rest kleingeschrieben.
  4. Zusammenfügen mit Trennzeichen (Join with delimiter): Die umgewandelten Tokens werden mit dem Zieltrennzeichen wieder verbunden (leerer String, Unterstrich _, Bindestrich -).

Das Problem der Abkürzungen (Acronym Preservation Challenge)

Am meisten Kopfzerbrechen bereitet Entwicklern von Konvertern der Umgang mit Abkürzungen wie XMLHTTPRequest. Bei der Umwandlung in snake_case trennt der eine Konverter sauber zu xml_http_request. Einfache Konverter mit wenig ausgefeiltem regulärem Ausdruck machen daraus dagegen xml_httprequest oder zerlegen sie sogar in einzelne Buchstaben wie x_m_l_h_t_t_p_request. Welche Variante richtig ist, hängt von den Vorgaben der jeweiligen Sprache und den Konventionen im Team ab und sollte vorher abgestimmt werden.

Unterschiede bei den offiziellen Namenskonventionen je Sprache

Jedes Ökosystem einer Programmiersprache hat seinen eigenen offiziellen Styleguide.

  • Python (PEP 8): Funktions- und Variablennamen in snake_case, Klassennamen in PascalCase.
  • Java (Google Java Style Guide): Methoden und Variablen in camelCase, Konstanten in CONSTANT_CASE.
  • Go (Effective Go): Für nach außen sichtbare Bezeichner (Export) PascalCase (MixedCaps), intern camelCase.
  • Rust (RFC 430): Variablen und Funktionen in snake_case, Typen und Traits in PascalCase.
  • TypeScript / JavaScript: Variablen und Funktionen in camelCase, Klassen und Interfaces in PascalCase, Dateinamen häufig in kebab-case.

Die 7 wichtigsten Schreibweisen (Casing Conventions) im Vergleich

SchreibweiseMerkmale und AufbauHauptverwendung (Sprachen/Ökosysteme)Typische BeispieleRegex-Muster zum Trennen/Zusammenfügen
camelCaseErstes Wort klein, Anfangsbuchstaben der folgenden Wörter groß, keine LeerzeichenVariablen-/Funktionsnamen in Java, TS/JS, C#myVariableName, getUserIdTrennen: (?<=[a-z])(?=[A-Z]), Zusammenfügen: ohne Leerzeichen
PascalCaseAnfangsbuchstabe jedes Wortes groß, keine Leerzeichen (UpperCamelCase)C#, TS-Interfaces, Java-Klassen, Go-ExportMyVariableName, GetUserIdTrennen: (?<=[a-z])(?=[A-Z]), Zusammenfügen: ohne Leerzeichen
snake_caseAlle Wörter klein, Leerzeichen durch Unterstrich (_) ersetztPython-Variablen, Datenbank-Spaltennamen, Rust-Funktionenmy_variable_name, get_user_idMit Trennzeichen (_) per split und join
kebab-caseAlle Wörter klein, Leerzeichen durch Bindestrich (-) ersetztURL-Pfade, CSS-Eigenschaften, HTML-Tags, Ordnernamenmy-variable-name, get-user-idMit Trennzeichen (-) per split und join
CONSTANT_CASEAlle Wörter groß, Leerzeichen durch Unterstrich (_) ersetzt (UPPER_SNAKE_CASE)Umgebungsvariablen (.env), globale KonstantenMY_VARIABLE_NAME, GET_USER_IDMit Trennzeichen (_) per split und join
Title CaseAnfangsbuchstabe jedes Wortes groß, Leerzeichen bleiben erhaltenTitel von Blogbeiträgen, Buchtitel, MenübeschriftungenMy Variable Name, Get User IdAnhand von Leerzeichen ( ) den ersten Buchstaben großschreiben
Train-CaseAlle Wörter groß, Leerzeichen durch Bindestrich (-) ersetzt (COBOL-CASE)Von LISP abgeleitete Sprachen, ältere Mainframe-SystemeMY-VARIABLE-NAME, GET-USER-IDMit Trennzeichen (-) per split und join

Die 5 häufigsten und folgenreichsten Fehler beim Umwandeln der Schreibweise

Diese fünf Probleme treten besonders oft auf, wenn Bezeichner von Hand umgewandelt oder fehlerhafte Skripte verwendet werden.

  1. Verlorene Abkürzungsgrenzen durch einfache reguläre Ausdrücke (Losing Acronym Boundaries): Wandeln Sie getURL in snake_case um und setzen mit einem simplen regulären Ausdruck vor jedem Großbuchstaben einen Unterstrich, wird daraus get_u_r_l: Das Kürzel zerfällt in sinnlose Einzelbuchstaben. Ein sorgfältiger Lookaround-Ausdruck oder ein spezielles Werkzeug ist hier unverzichtbar.

  2. Trennfehler bei Mischung aus Buchstaben und Ziffern (Mixing Numbers with Letters): Bei einer Zeichenkette wie v2Api verhalten sich die Konverter unterschiedlich: Manche erzeugen v_2_api, andere v2_api. Ob Ziffern als eigenes Wort gelten oder als Fortsetzung der vorangehenden Zeichen, sollten Sie im Team klar festlegen.

  3. Fehlfunktion regulärer Ausdrücke bei Nicht-ASCII-Zeichen und koreanischen Zeichen: Enthält ein Bezeichner Unicode-Zeichen wie Hangul oder Emojis (zum Beispiel get유저Info), scheitert die Worterkennung bei veralteten Konvertern, die nur das lateinische Alphabet berücksichtigen. Das Ergebnis ist dann etwa get유저info oder gleich eine Fehlermeldung.

  4. Uneinheitliche Namenskonventionen in großen Teams werden geduldet: Im selben Projekt schreibt der eine user_id, die andere userId und ein Dritter sogar user_ID. Das beeinträchtigt die Lesbarkeit des Codes erheblich und macht projektweites Refactoring oder Ersetzen per Textsuche (grep) unmöglich.

  5. Fehlende Regeln zur Groß- und Kleinschreibung bei der JSON-Serialisierung: Kommunizieren Backend (snake_case) und Frontend (camelCase) miteinander, muss die Umwandlung der Feldnamen im API-Gateway oder im DTO-Serializer (zum Beispiel Jackson, GSON, class-transformer) aktiviert sein. Andernfalls zeigt der Client undefined-Werte an.

Altlasten bereinigen: Refactoring der Namensgebung in 5 Schritten

  1. Team-Styleguide festlegen und per Werkzeug durchsetzen (.editorconfig / ESLint): Mündlich vereinbarte Konventionen nützen nichts. Legen Sie im Projektstamm eine .editorconfig und eine .eslintrc (oder .prettierrc) an, damit die Schreibweise in der IDE aller Teammitglieder verbindlich geprüft wird.
  2. Konsistenz der vorhandenen Bezeichner prüfen (Audit Current Identifier Consistency): Lassen Sie ein Werkzeug zur statischen Codeanalyse (zum Beispiel SonarQube) über den bestehenden Code laufen. So erkennen Sie, in welchen Modulen die Verstöße gegen die Namensregeln am gravierendsten sind, und können das Refactoring schrittweise planen.
  3. Middleware für die automatische Serialisierungsumwandlung einrichten: Aktivieren Sie in Frameworks wie Spring Boot oder NestJS global eine Middleware oder einen Decorator (PropertyNamingStrategy), der die Schlüssel eingehender und ausgehender JSON-Payloads automatisch umwandelt.
  4. Stapelweise Umbenennung mit einem speziellen Umwandlungswerkzeug (Batch Renames): Nutzen Sie die Funktion „Refactor – Rename“ Ihrer IDE oder das Werkzeug „Bezeichner umwandeln: camelCase, snake_case, kebab-case, CONSTANT_CASE“ oben auf dieser Seite, um Dutzende Variablennamen in einem Rutsch sicher umzuwandeln. Handarbeit führt zu Tippfehlern.
  5. Strenge Lint-Prüfungen in die CI-Pipeline einbinden (Run CI Lint Checks): Bauen Sie in Ihren CI/CD-Prozess, etwa mit GitHub Actions, einen verpflichtenden Lint-Schritt ein. Pull Requests (PR) mit Bezeichnern, die gegen die Regeln verstoßen, werden dadurch automatisch am Merge gehindert.

7 Tipps zu Namensgebung und Schreibweise

  1. Folgen Sie konsequent den Idiomen der Sprache und des Frameworks statt persönlichem Geschmack. Wer in Python camelCase oder in Java snake_case verwendet, belastet die Kolleginnen und Kollegen beim Lesen erheblich.
  2. Einigen Sie sich eindeutig auf die Schreibweise aufeinanderfolgender Großbuchstaben in Abkürzungen. Ob HTTPRequest oder HttpRequest, ob userID oder userId: Halten Sie die Regel des Teams schriftlich fest. Der aktuelle Trend geht zu HttpRequest, bei dem nur der erste Buchstabe wie bei einem gewöhnlichen Wort großgeschrieben wird.
  3. Nutzen Sie automatische Serialisierungs-Annotationen. Mit @JsonProperty("user_id") in Java, @Expose({ name: "user_id" }) in TypeScript oder dem Tag json:"user_id" in Go bleibt im Code camelCase erhalten, und die Felder lassen sich trotzdem sauber auf snake_case in Datenbank oder API abbilden.
  4. Verwenden Sie für URL-Pfade und REST-API-Endpunkte grundsätzlich kebab-case. Statt /get_user_profile (falsch) oder /getUserProfile (falsch) ist /get-user-profile (richtig) hinsichtlich Suchmaschinenoptimierung (SEO) und Lesbarkeit der weltweite Standard.
  5. Vergeben Sie CONSTANT_CASE nur für wirklich unveränderliche (immutable) Werte. Eine gewöhnliche Variable, deren Wert sich zur Laufzeit ändern kann, in Großbuchstaben mit Unterstrichen zu deklarieren, widerspricht dem semantischen Zweck einer Konstante und ist ein Anti-Pattern.
  6. Verstehen Sie das Prinzip der Lookaround-Ausdrücke und schreiben Sie eigene Skripte. Wenn es nicht bei einer einmaligen Umwandlung bleibt, steigert ein im Editor hinterlegtes Makro zum Ersetzen mit dem oben beschriebenen Muster (?<=[a-z0-9])(?=[A-Z]) Ihre Produktivität enorm.
  7. Speichern Sie dieses Umwandlungswerkzeug als Lesezeichen im Browser. Wenn Sie schnell eine Datenbankabfrage schreiben oder ein DTO-Interface tippen müssen, spart es Ihnen viel Zeit gegenüber dem Umschreiben von Hand.

Entscheidungsbaum: Die passende Schreibweise finden

Wenn Sie sich fragen: „In welcher Schreibweise sollte ich diesen Variablennamen eigentlich halten?“, führt Sie der folgende Entscheidungsbaum in einer Sekunde zur Antwort.

  1. Handelt es sich um eine Konfigurationsdatei (.env), eine unveränderliche Konstante oder eine globale Umgebungsvariable?
    • JA ➔ CONSTANT_CASE (z. B. MAX_RETRY_COUNT)
    • NEIN ➔ weiter zum nächsten Punkt
  2. Handelt es sich um einen Web-URL-Endpunkt, einen CSS-Klassennamen oder einen Verzeichnis- bzw. Dateinamen?
    • JA ➔ kebab-case (z. B. user-profile-card)
    • NEIN ➔ weiter zum nächsten Punkt
  3. Handelt es sich um einen Tabellen- oder Spaltennamen in einer relationalen Datenbank (RDBMS)?
    • JA ➔ snake_case (z. B. created_at)
    • NEIN ➔ weiter zum nächsten Punkt
  4. Verwenden Sie Python, Rust, Ruby oder PHP (teilweise)?
    • JA ➔ snake_case (z. B. fetch_user_data)
    • NEIN (Java, JS, TS, C#, Go usw.) ➔ weiter zum nächsten Punkt
  5. Handelt es sich um eine Klasse, ein Interface, einen Typ oder etwas, das in Go exportiert werden soll?
    • JA ➔ PascalCase (z. B. UserDataResponse)
    • NEIN (gewöhnliche Variable, Funktion, Methode, Parameter) ➔ camelCase (z. B. fetchUserData)

Fachbegriffe im Überblick: Spickzettel für Profis (Terminologie)

  • camelCase (Kamelschreibweise): Die Wörter werden ohne Leerzeichen aneinandergehängt. Das erste Wort beginnt mit einem Kleinbuchstaben, bei den folgenden Wörtern ist der erste Buchstabe jeweils ein Großbuchstabe. Der Name erinnert an die Höcker eines Kamels.
  • PascalCase: Schreibweise, bei der jedes Wort mit einem Großbuchstaben beginnt. Wird auch UpperCamelCase genannt.
  • snake_case: Der Name steht für die lange, zusammenhängende Form einer Schlange. Leerzeichen zwischen den Wörtern werden dabei durch Unterstriche (Underscore, _) ersetzt.
  • kebab-case: Wie die Fleischstücke auf einem Kebab-Spieß werden die Wörter durch Bindestriche (Dash, -) verbunden. Wird vor allem in URLs und CSS verwendet.
  • CONSTANT_CASE: Alle Buchstaben werden großgeschrieben und die Wörter durch Unterstriche verbunden (UPPER_SNAKE_CASE). Wird ausschließlich für Konstanten und Umgebungsvariablen verwendet.
  • Lookaround in regulären Ausdrücken (Regex Lookaround): Leistungsfähige Suchfunktion in regulären Ausdrücken, die eine Bedingung prüft, ohne dass der geprüfte Teil im Ergebnis enthalten ist. Es gibt Lookahead (?=...) und Lookbehind (?<=...).
  • DTO-Serialisierung (Serialization): Vorgang, bei dem Objektdaten (DTO) aus dem Arbeitsspeicher für die Übertragung über das Netzwerk oder die Speicherung in einer Datenbank in ein Format wie JSON umgewandelt werden. Dabei sind häufig Umwandlungen zwischen Schreibweisen nötig.

Häufig gestellte Fragen

Q1. Wie wandle ich Bezeichner mit aufeinanderfolgenden Großbuchstaben wie IOStream am sichersten um?

Aufeinanderfolgende Großbuchstaben in Abkürzungen sind die größte Schwachstelle klassischer camelCase-Konverter. Wandelt man IOStream in camelCase um, erzeugen manche Systeme iOStream, andere ioStream. Am sichersten und zeitgemäßesten ist es, eine Abkürzung wie ein einzelnes Wort zu behandeln und den Bezeichner als IoStream (PascalCase) oder ioStream (camelCase) zu deklarieren. Bei einer späteren automatischen Umwandlung in snake_case wird er dann sauber zu io_stream getrennt, was die Interoperabilität maximiert.

Q2. Welchen Regeln folgt die Worttrennung, wenn ein Bezeichner Ziffern enthält?

Ziffern werden je nach Werkzeug und Framework etwas unterschiedlich behandelt. In der Regel sind Ziffern den lateinischen Kleinbuchstaben gleichgestellt. Deshalb wird user2Name in user2 / Name getrennt und zu user2_name. Es gibt jedoch strenge Lint-Regeln, die eine Ziffer zwischen zwei Buchstaben (zum Beispiel bei v2Api) als eigenes Wort behandeln und daraus v_2_api machen. Um unvorhersehbares Verhalten zu vermeiden, sollten Sie Ziffern am besten gar nicht mitten im Bezeichner verwenden, sondern ans Ende stellen.

Q3. Wie gehen Konverter für Schreibweisen mit Hangul oder CJK-Zeichen (Chinesisch, Japanisch, Koreanisch) um?

Hangul kennt keine Groß- und Kleinschreibung. Die Zeichen werden daher nicht umgewandelt, sondern bleiben unverändert erhalten. Entscheidend ist die Erkennung der Wortgrenzen. Moderne, auf regulären Ausdrücken basierende Konverter mit vollständiger Unicode-Unterstützung (wie das Werkzeug auf dieser Seite) erkennen die Grenze zwischen lateinischen Buchstaben und Hangul genauso selbstverständlich wie die zwischen zwei lateinischen Buchstaben. Ältere Skripte, die nur veraltete reguläre Ausdrücke verwenden, behandeln Hangul dagegen wie Leerzeichen oder Sonderzeichen, sodass Variablennamen beschädigt werden können. Wenn Sie Variablennamen in Hangul verwenden, sollten Sie unbedingt ein Umwandlungswerkzeug einsetzen, das Unicode (UTF-8) unterstützt.

Dieser Artikel basiert auf unserem koreanischen Original. Koreanisches Original lesen

Ähnliche Artikel

  1. Zeichen zählen mit und ohne Leerzeichen: Welche Zahl zählt?Bewerbung oder Hausarbeit: Zählen Sie mit oder ohne Leerzeichen? Warum Zähltools abweichen, was Zeilenumbrüche und Bytes ausmachen und wie Sie selbst prüfen.
  2. JSON null-Werte entfernen: Was bleibt, was wird gelöschtSo entfernen Sie null, leere Strings, leere Arrays und Objekte aus JSON: warum 0 und false bleiben, wie die Rekursion arbeitet und wann Syntaxfehler stoppen.
  3. A-Record vs. CNAME: Unterschied erklärt und Format prüfenA-Record verweist auf eine IPv4-Adresse, CNAME auf einen anderen Domainnamen. So unterscheiden sich beide in der Zonendatei und so prüfen Sie Ihre Eingabe.
  4. CSS-Akkordeon erstellen: Checkbox-Hack ohne JavaScript erklärtSo funktioniert ein CSS-Akkordeon ohne JavaScript: Checkbox- und Radio-Hack im Code erklärt, mit Live-Vorschau sowie HTML- und CSS-Code zum Kopieren.
  5. Doppelte CSS-Selektoren finden und zusammenführenWenn ein CSS-Selektor mehrfach vorkommt, überschreibt der spätere Wert den früheren. So finden Sie Duplikate per grep und führen sie automatisch zusammen.
  6. CSS minifizieren: Was entfernt wird und was erhalten bleibtBeim CSS-Minify entfallen Kommentare und überflüssige Leerzeichen, Strings und calc() bleiben intakt. Dazu: so wird die Ersparnis in Prozent berechnet.

Passende Tools