Text Case Conversion: camelCase, snake_case, kebab-case and More

Naming conventions are one of the most important yet overlooked aspects of writing clean code. The way you name variables, functions, classes and files affects readability, consistency and collaboration across a project. Different programming languages, frameworks and ecosystems have adopted specific text case formats as their standards. Understanding these conventions and knowing how to convert between them is an essential skill for every developer.

Why Naming Conventions Matter

Consistent naming conventions make code easier to read and understand at a glance. When every developer on a team follows the same conventions, new contributors can navigate the codebase without guessing what format to use. Linters and automated tools rely on consistent naming to enforce code quality rules. Beyond readability, naming conventions also carry semantic meaning. For example, in JavaScript a name written in SCREAMING_SNAKE_CASE immediately signals a constant, while PascalCase indicates a class or component.

• Readability. Properly cased names are easier to scan and parse mentally, especially in large files with hundreds of identifiers.
• Consistency. A unified naming style across a codebase reduces cognitive load and prevents naming conflicts.
• Language conventions. Most languages have community-agreed naming standards. Following them makes your code feel idiomatic.
• Team standards. Style guides and linters enforce naming rules, catching inconsistencies before they reach code review.

Common Text Case Formats

Here are the most widely used case formats in programming, along with examples and where you will typically encounter each one.

camelCase

The first word is lowercase, and every subsequent word starts with an uppercase letter. No separators are used. This is the default convention for variables and function names in JavaScript, TypeScript, Java and Swift.

PascalCase

Every word starts with an uppercase letter, including the first one. Also known as UpperCamelCase. This is the standard for class names in most languages, React component names and C# methods and properties.

snake_case

All words are lowercase, separated by underscores. This is the dominant convention in Python, Ruby, Rust and database column names. It is also commonly used in file naming for many backend frameworks.

kebab-case

All words are lowercase, separated by hyphens. This format is used extensively in CSS class names, URL slugs, HTML attributes and CLI flags. It is also the convention for npm package names and file names in Angular projects.

SCREAMING_SNAKE_CASE (CONSTANT_CASE)

All words are uppercase, separated by underscores. This is universally used for constants, environment variables and configuration keys across nearly all programming languages.

dot.case

All words are lowercase, separated by dots. You will see this in Java package names, configuration keys in YAML and TOML files, and object property paths.

Title Case

Each word starts with an uppercase letter, and words are separated by spaces. This is used for headings, UI labels, button text and document titles. It is not used for code identifiers since spaces are not valid in variable names.

Language Conventions

Different programming languages and ecosystems have established preferences for which case formats to use. Here is a quick reference.

How Case Conversion Works

Converting between case formats follows a consistent two-step process. First, the input string is split into individual words. Then, the words are joined back together using the target format's rules.

The tricky part is the splitting step. A case converter needs to detect word boundaries by looking for several types of separators.

• Uppercase letters. In camelCase and PascalCase, an uppercase letter signals the start of a new word (getUserName becomes get, User, Name).
• Underscores. In snake_case and CONSTANT_CASE, underscores separate words.
• Hyphens. In kebab-case, hyphens separate words.
• Spaces. In Title Case and sentence case, spaces separate words.
• Dots. In dot.case, periods separate words.

Converting Between Cases in JavaScript

Here is a practical example showing how to split a string into words and convert it to different case formats in JavaScript.

Converting Between Cases in Python

Python's re module makes it straightforward to implement case conversion.

Common Pitfalls

Case conversion seems simple on the surface, but several edge cases can trip you up. Being aware of these will help you avoid subtle bugs.

• Acronyms and abbreviations. How should XMLParser be converted? Some tools produce xml_parser, while others produce x_m_l_parser. The correct approach splits on transitions between consecutive uppercase letters and lowercase letters, so XMLParser becomes xml_parser. Some style guides prefer XmlParser over XMLParser to avoid this ambiguity entirely.
• Single-letter words. Strings like getAValue can be ambiguous. Is the "A" a separate word or part of the next word? Most converters treat each uppercase letter as the start of a new word, resulting in get_a_value.
• Numbers in identifiers. Names like section2Title or h2Tag require special handling. Should section2Title become section_2_title or section2_title? The answer depends on your specific rules for number boundaries.
• Leading and trailing separators. Input strings like _private_var_ or --flag-name have separators at the edges. A good converter strips these before splitting to avoid empty words in the output.
• Mixed formats. Sometimes input already mixes conventions, like my_camelCase_string. A robust converter handles these gracefully by splitting on all possible word boundaries simultaneously.