Global Araç
Snake Case Converter
snake_case (underscore-separated lowercase) is the dominant naming convention in Python (PEP 8 mandates snake_case for variable / function / module names), Ruby, Rust (in some contexts), SQL database column names (industry-standard convention across PostgreSQL, MySQL, SQLite), and environment variables (DATABASE_URL, API_KEY — uppercase snake_case is convention for env vars). Java, C#, and JavaScript prefer camelCase or PascalCase for identifiers; CSS and URL slugs prefer kebab-case. Knowing when to use which is part of the implicit knowledge of being a competent programmer; getting it wrong (camelCase Python variables, snake_case JavaScript variables) is a code-review smell signaling unfamiliarity.
The converter handles both directions: words/sentences/camelCase/kebab-case → snake_case, and snake_case → space-separated words. The forward conversion handles edge cases: camelCase boundaries (split at lowercase-then- uppercase), consecutive capitals (parseHTMLDocument → parse_html_document, not parse_h_t_m_l_document), special characters (replace with underscores or strip), unicode (transliterate accented characters), and consecutive separators (multiple-spaces → single underscore). Reverse direction: split on underscores, capitalize first letter of each word for human reading.
Convention contexts where snake_case dominates: (1) Python — PEP 8 mandates snake_case for variable / function / module names; PascalCase for classes; UPPER_SNAKE_CASE for constants. (2) SQL — column names like user_id, created_at, email_address are universal across databases. Never use camelCase in SQL schemas; case sensitivity varies by database and creates bugs. (3) Environment variables — UPPERCASE_SNAKE_CASE convention (DATABASE_URL, OPENAI_API_KEY, STRIPE_PUBLIC_KEY). (4) Ruby and Crystal — same as Python. (5) File names in many systems (Linux often uses snake_case for system config files; Python projects use snake_case for module files). Avoid snake_case in: JavaScript identifiers (unidiomatic), CSS classes (kebab-case standard), URLs (kebab-case for SEO and readability).
Nasıl Kullanılır
- Paste your text or identifier.
- Pick direction: to-snake_case or from-snake_case-to-words.
- Optionally enable UPPER_SNAKE_CASE output for env vars / constants.
- Click Convert and copy the result.
- For batch conversion, paste line-separated; tool processes each.
Ne Zaman Kullanılır
- Translating identifiers between languages with different conventions (JavaScript camelCase → Python snake_case).
- Naming database columns or SQL identifiers (always snake_case).
- Naming environment variables (UPPER_SNAKE_CASE convention).
- Renaming variables when adopting Python project conventions.
- Converting JSON keys from camelCase API responses to Python-friendly snake_case.
Ne Zaman Kullanılmaz
- Languages where snake_case is unidiomatic — JavaScript / TypeScript / Java / C# / Swift / Kotlin all prefer camelCase.
- URL slugs and CSS classes — kebab-case is the convention.
- File paths on case-sensitive filesystems where existing code expects different convention.
- Refactoring without testing — automated case conversion can rename string content (logs, strings) you didn't intend to change.
Yaygın Kullanım Senaryoları
- Pre-decision sanity-check on inputs and outputs
- Educational use — demonstrating the underlying concept
- Onboarding a colleague who needs the same calculation/conversion
- Verifying a number or output before passing it on
Sık Sorulan Sorular
Where is snake_case used?
Python (PEP 8 mandates), Ruby, SQL database column names (universal across PostgreSQL, MySQL, SQLite), environment variables (UPPER_SNAKE_CASE convention), Crystal, Elixir (mostly), file names in many Unix conventions, Rust (variable names use snake_case; types use PascalCase). Avoid in: JavaScript / TypeScript identifiers (camelCase), CSS classes (kebab-case), URLs (kebab-case).
What's the difference from kebab-case?
Identical structure with different separator. snake_case uses underscore (_); kebab-case uses dash (-). Functionally equivalent but conventional domains differ. snake_case dominates programming-language identifiers and SQL columns. kebab-case dominates URLs, CSS, HTML attributes. Languages that allow dashes in identifiers (Lisp, Clojure) prefer kebab; those that don't (most languages, since dash is subtraction) use snake.
What's UPPER_SNAKE_CASE for?
Constants in many languages (Python: MAX_RETRIES = 5; Ruby: API_VERSION; Java: MAX_LENGTH but Java uses MAX_LENGTH_FIELD_NAME naming for static finals, Python style). Environment variables almost always: DATABASE_URL, OPENAI_API_KEY, STRIPE_PUBLIC_KEY. The convention signals “this is constant / immutable / configuration, not regular variable.” Auto-conversion tools usually have a separate option for UPPER_SNAKE_CASE output.
How does it handle camelCase?
Splits at lowercase-then-uppercase boundaries: getUserName → get_user_name. Handles consecutive capitals correctly: parseHTMLDocument → parse_html_document (not parse_h_t_m_l_document). Acronyms get lowercased as words. URL becomes url; HTML becomes html; ID becomes id. The conversion is generally lossy: round-tripping through both can produce slightly different casing.
Why don't JavaScript engineers use snake_case?
Convention. JavaScript's ECMAScript style guide and the broader ecosystem (jQuery, React, Node.js, Express) all standardized on camelCase for variables / functions and PascalCase for classes / constructors. Going against this in JS code reads as “Python developer who hasn't learned JS yet.” Linters (ESLint with airbnb-style config) flag snake_case in JS as warnings.
What about JSON keys?
Camelcase dominant in modern APIs (RESTful APIs from major providers tend to use camelCase: githubApiResponse, stripeChargeAmount). Snake_case common in older / Python-built APIs. Some APIs (Twitter, Stripe) use snake_case in JSON because their backends are Ruby/Python. When consuming, keep API key naming for direct access OR use a serialization library (Python pydantic, Ruby Active Model Serializers) to convert at the boundary.