Text Case Converter
Convert text to UPPER CASE, lower case, Capital Case, snake_case, camelCase and more.
๐ How to Use
Type or paste the text you want to convert.
Click the desired format button: UPPER CASE, lower case, Capital Case, snake_case, or camelCase.
Review the converted text and click ๐ Copy to save to your clipboard.
About the Case Converter
The Case Converter rewrites a string into the casing convention a given language or framework expects. Different ecosystems settled on different rules: JavaScript variables are camelCase, Python variables are snake_case, CSS classes and URLs are kebab-case, and C constants are CONSTANT_CASE. Pasting the wrong casing into a file either fails a linter or breaks naming conventions silently, so a one-click converter saves real friction when moving text between contexts.
How it works
The core casing primitives are JavaScript's toLowerCase() and toUpperCase(), which apply Unicode default case mapping. Building the multi-word conventions on top requires a word-boundary detector: the converter splits input on spaces, punctuation, and case transitions — a lowercase letter followed by an uppercase letter (as in myVar) is itself a boundary, so mixed-case identifiers can be re-emitted in any style. Each convention then rejoins the words differently:
camelCase— first word lowercase, every later word capitalized, no separatorPascalCase— every word capitalized, no separatorsnake_case— all lowercase, words joined with_kebab-case— all lowercase, words joined with-CONSTANT_CASE— all uppercase, words joined with_Title Case— every word capitalized, separated by spaces
Case mapping is locale-sensitive. The classic case is Turkish, whose alphabet distinguishes dotted and undotted I: the lowercase of I is ı (dotless) and the uppercase of i is İ (dotted). Default toLowerCase() ignores this, so for locale-correct output use toLocaleLowerCase('tr').
Common use cases
- Turning a readable title into a
camelCaseJavaScript variable or function name - Generating
snake_caseidentifiers for a Python or Ruby codebase - Producing
kebab-caseCSS class names and URL path segments - Normalizing database column or
CONSTANT_CASEenum values - Converting
SHOUTINGtext to readableTitle Case
Worked example
Starting from the title Hello World Example, each convention produces a distinct identifier:
camelCase: helloWorldExample
PascalCase: HelloWorldExample
snake_case: hello_world_example
kebab-case: hello-world-example
CONSTANT_CASE: HELLO_WORLD_EXAMPLE
Title Case: Hello World Example
Notice that camelCase lowercases only the first word, while PascalCase capitalizes every word — the two differ solely in the treatment of the leading word.
Frequently asked questions
What is the difference between camelCase and PascalCase?
In camelCase the first word is lowercase and each following word starts uppercase, with no separators (for example myVariableName). PascalCase (also called UpperCamelCase) capitalizes the first word as well, so the same input becomes MyVariableName. camelCase is the JavaScript convention for variables; PascalCase is used for classes and React components.
How are words split apart?
Words are split on spaces, punctuation, and case transitions. A lowercase letter followed by an uppercase letter (for example myVar) is treated as a boundary, so the converter can turn mixed input into snake_case or kebab-case without manual separation.
When should I use snake_case versus kebab-case?
snake_case (underscores) is the convention in Python, Ruby, and database column names. kebab-case (hyphens) is preferred in URLs, CSS class names, and HTML data attributes because hyphens are URL-safe and never need escaping.
Is case conversion locale-dependent?
Yes. JavaScript toLowerCase and toUpperCase follow Unicode default case mapping, but some languages have special rules. The most famous is Turkish, where lowercase of I is ı (dotted) and uppercase of i is İ (dotless). Use toLocaleLowerCase with a locale argument when locale-specific output matters.
Does the tool send my text anywhere?
No. All conversions run in your browser through native string methods. Nothing is uploaded, so the tool is safe for code snippets, identifiers, and confidential content.
์ผ์ด์ค ๋ณํ๊ธฐ๋?
์ผ์ด์ค ๋ณํ๊ธฐ๋ ๋ฌธ์์ด์ ํน์ ์ธ์ด๋ ํ๋ ์์ํฌ๊ฐ ๊ธฐ๋ํ๋ ๋์๋ฌธ์ ๊ท์น์ผ๋ก ๋ค์ ์จ ์ค๋๋ค. ์ํ๊ณ๋ง๋ค ์ ์ฐฉํ ๊ท์น์ด ๋ค๋ฆ
๋๋ค. JavaScript ๋ณ์๋ camelCase, Python ๋ณ์๋ snake_case, CSS ํด๋์ค์ URL์ kebab-case, C ์์๋ CONSTANT_CASE๋ฅผ ์๋๋ค. ์๋ชป๋ ์ผ์ด์ค๋ฅผ ๊ทธ๋๋ก ๋ถ์ฌ ๋ฃ์ผ๋ฉด ๋ฆฐํฐ๊ฐ ๊ฑธ๋ฆฌ๊ฑฐ๋ ๋ช
๋ช
๊ท์น์ด ์กฐ์ฉํ ๊นจ์ง๋ฏ๋ก, ๋ฌธ๋งฅ์ ์ฎ๊ธธ ๋ ํ ๋ฒ์ ๋ณํํด ์ฃผ๋ ๋๊ตฌ๊ฐ ์ค์ง์ ์ธ ๋ถํธ์ ์ค์ฌ ์ค๋๋ค.
์๋ ๋ฐฉ์
ํต์ฌ ๋์๋ฌธ์ ํ๋ฆฌ๋ฏธํฐ๋ธ๋ JavaScript์ toLowerCase()์ toUpperCase()์ด๋ฉฐ, ์ ๋์ฝ๋ ๊ธฐ๋ณธ ์ผ์ด์ค ๋งคํ์ ์ ์ฉํฉ๋๋ค. ์ฌ๋ฌ ๋จ์ด๋ก ์ด๋ฃจ์ด์ง ๊ท์น์ ๊ทธ ์์ ์ฌ๋ฆฌ๋ ค๋ฉด ๋จ์ด ๊ฒฝ๊ณ ๊ฐ์ง๊ฐ ํ์ํฉ๋๋ค. ์ด ๋ณํ๊ธฐ๋ ๊ณต๋ฐฑ, ๊ตฌ๋์ , ๊ทธ๋ฆฌ๊ณ ๋์๋ฌธ์ ์ ํ์ ๊ธฐ์ค์ผ๋ก ์
๋ ฅ์ ๋ถํ ํฉ๋๋ค. ์ฆ ์๋ฌธ์ ๋ค์ ์ค๋ ๋๋ฌธ์(์: myVar) ์์ฒด๊ฐ ๊ฒฝ๊ณ์ด๋ฏ๋ก, ์์ฌ ์๋ ์๋ณ์๋ ์ด๋ค ์คํ์ผ๋ก๋ ๋ค์ ์ถ๋ ฅํ ์ ์์ต๋๋ค. ๊ฐ ๊ท์น์ ๋จ์ด๋ฅผ ์๋ก ๋ค๋ฅด๊ฒ ์ด์ด ๋ถ์
๋๋ค.
camelCase— ์ฒซ ๋จ์ด๋ ์๋ฌธ์, ์ดํ ๋จ์ด๋ง ๋๋ฌธ์ ์์, ๊ตฌ๋ถ์ ์์PascalCase— ๋ชจ๋ ๋จ์ด ๋๋ฌธ์ ์์, ๊ตฌ๋ถ์ ์์snake_case— ๋ชจ๋ ์๋ฌธ์, ๋จ์ด๋ฅผ_๋ก ๊ฒฐํฉkebab-case— ๋ชจ๋ ์๋ฌธ์, ๋จ์ด๋ฅผ-๋ก ๊ฒฐํฉCONSTANT_CASE— ๋ชจ๋ ๋๋ฌธ์, ๋จ์ด๋ฅผ_๋ก ๊ฒฐํฉTitle Case— ๋ชจ๋ ๋จ์ด ๋๋ฌธ์ ์์, ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ
์ผ์ด์ค ๋งคํ์ ๋ก์ผ์ผ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ๋ํ์ ์ธ ์๊ฐ ํฐํค์ด๋ก, ์ํ๋ฒณ์ด ์ ์ด ์๋ I์ ์๋ I๋ฅผ ๊ตฌ๋ถํฉ๋๋ค. I์ ์๋ฌธ์๋ ı(์ ์์), i์ ๋๋ฌธ์๋ İ(์ ์์)์
๋๋ค. ๊ธฐ๋ณธ toLowerCase()๋ ์ด๋ฅผ ๋ฌด์ํ๋ฏ๋ก, ๋ก์ผ์ผ์ ๋ง๋ ๊ฒฐ๊ณผ๊ฐ ํ์ํ๋ฉด toLocaleLowerCase('tr')๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.
์์ฃผ ์ฐ๋ ๊ฒฝ์ฐ
- ์ฝ๊ธฐ ์ฌ์ด ์ ๋ชฉ์ JavaScript ๋ณ์/ํจ์ ์ด๋ฆ์ธ
camelCase๋ก ๋ฐ๊พธ๊ธฐ - Python์ด๋ Ruby ์ฝ๋์ฉ
snake_case์๋ณ์ ๋ง๋ค๊ธฐ - CSS ํด๋์ค๋ช
๊ณผ URL ๊ฒฝ๋ก ์ธ๊ทธ๋จผํธ์ธ
kebab-case์์ฑ - ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ปฌ๋ผ์ด๋
CONSTANT_CASEenum ๊ฐ ์ ๊ทํ - ๋๋ฌธ์
SHOUTINGํ ์คํธ๋ฅผ ์ฝ๊ธฐ ์ฌ์ดTitle Case๋ก ๋ณํ
์ฌ์ฉ ์
Hello World Example์ด๋ผ๋ ์ ๋ชฉ์์ ๊ฐ ๊ท์น์ด ๋ง๋๋ ์๋ณ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
camelCase: helloWorldExample
PascalCase: HelloWorldExample
snake_case: hello_world_example
kebab-case: hello-world-example
CONSTANT_CASE: HELLO_WORLD_EXAMPLE
Title Case: Hello World Example
camelCase๋ ์ฒซ ๋จ์ด๋ง ์๋ฌธ์๋ก ๋ง๋ค๊ณ PascalCase๋ ๋ชจ๋ ๋จ์ด๋ฅผ ๋๋ฌธ์๋ก ์์ํ๋ค๋ ์ ์ ์ฃผ๋ชฉํ์ธ์. ๋ ๊ท์น์ ์ฐจ์ด๋ ์ค์ง ์ฒซ ๋จ์ด์ ์ฒ๋ฆฌ์๋ง ์์ต๋๋ค.
์์ฃผ ๋ฌป๋ ์ง๋ฌธ
camelCase์ PascalCase์ ์ฐจ์ด๋?
camelCase๋ ์ฒซ ๋จ์ด๋ฅผ ์๋ฌธ์๋ก ์์ํ๊ณ ์ดํ ๋จ์ด๋ง ๋๋ฌธ์๋ก ์์ํ๋ฉฐ ๊ตฌ๋ถ์๊ฐ ์์ต๋๋ค(์: myVariableName). PascalCase(UpperCamelCase๋ผ๊ณ ๋ ํจ)๋ ์ฒซ ๋จ์ด๊น์ง ๋๋ฌธ์๋ก ์์ํ๋ฏ๋ก ๊ฐ์ ์
๋ ฅ์ด MyVariableName์ด ๋ฉ๋๋ค. camelCase๋ JavaScript ๋ณ์ ๊ด๋ก์ด๊ณ PascalCase๋ ํด๋์ค์ React ์ปดํฌ๋ํธ์ ์๋๋ค.
๋จ์ด๋ ์ด๋ป๊ฒ ๋ถํ ํ๋์?
๊ณต๋ฐฑ, ๊ตฌ๋์ , ๊ทธ๋ฆฌ๊ณ ๋์๋ฌธ์ ์ ํ์ ๊ธฐ์ค์ผ๋ก ๋จ์ด๋ฅผ ๋ถํ ํฉ๋๋ค. ์๋ฌธ์ ๋ค์ ์ค๋ ๋๋ฌธ์(์: myVar)๋ฅผ ๊ฒฝ๊ณ๋ก ์ฒ๋ฆฌํ๋ฏ๋ก, ์์ธ ์
๋ ฅ๋ ์๋ ๋ถ๋ฆฌ ์์ด snake_case๋ kebab-case๋ก ๋ฐ๊ฟ ์ ์์ต๋๋ค.
snake_case์ kebab-case๋ ์ธ์ ์ฐ๋์?
snake_case(๋ฐ์ค)๋ Python, Ruby, ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ปฌ๋ผ๋ช
๊ด๋ก์
๋๋ค. kebab-case(ํ์ดํ)๋ URL, CSS ํด๋์ค๋ช
, HTML data ์์ฑ์ ์ ํธ๋๋๋ฐ, ํ์ดํ์ URL์ ์์ ํ๊ณ ์ด์ค์ผ์ดํ๊ฐ ํ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
์ผ์ด์ค ๋ณํ์ ๋ก์ผ์ผ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋์?
๋ค. JavaScript์ toLowerCase/toUpperCase๋ ์ ๋์ฝ๋ ๊ธฐ๋ณธ ์ผ์ด์ค ๋งคํ์ ๋ฐ๋ฅด์ง๋ง ์ผ๋ถ ์ธ์ด์๋ ํน๋ณํ ๊ท์น์ด ์์ต๋๋ค. ๊ฐ์ฅ ์ ๋ช
ํ ์๊ฐ ํฐํค์ด๋ก, I์ ์๋ฌธ์๋ ı(์ ์์), i์ ๋๋ฌธ์๋ İ(์ ์์)์
๋๋ค. ๋ก์ผ์ผ๋ณ ๊ฒฐ๊ณผ๊ฐ ์ค์ํ๋ฉด ๋ก์ผ์ผ ์ธ์๋ฅผ ๋๊ฒจ toLocaleLowerCase๋ฅผ ์ฌ์ฉํ์ธ์.
์ ํ ์คํธ๊ฐ ์ธ๋ถ๋ก ์ ์ก๋๋์?
์๋๋๋ค. ๋ชจ๋ ๋ณํ์ ๋ธ๋ผ์ฐ์ ์์ ๋ค์ดํฐ๋ธ ๋ฌธ์์ด ๋ฉ์๋๋ก ์ฒ๋ฆฌ๋ฉ๋๋ค. ์ ๋ก๋๋๋ ๊ฒ์ ์์ผ๋ฏ๋ก ์ฝ๋ ์กฐ๊ฐ, ์๋ณ์, ๊ธฐ๋ฐ ๋ด์ฉ์๋ ์์ ํฉ๋๋ค.