Alternating Case Converter
aLtErNaTiNg writes hElLo wOrLd. Alternating case is the "mocking SpongeBob" format — used to mark text as sarcastic quotation in social posts and chat. It is a presentation effect rather than a naming convention, and it is worth knowing that screen readers announce it letter by letter, which makes it genuinely inaccessible in any context where the text carries meaning.
Conversions
| Input | aLtErNaTiNg |
|---|---|
hello world example | hElLo WoRlD eXaMpLe |
XMLHttpRequest | xMlHtTpReQuEsT |
user_first_name | uSeR_fIrSt_NaMe |
Total Order Count | tOtAl OrDeR cOuNt |
XMLHttpRequest becomes xMlHtTpReQuEsT. Word boundaries and acronyms are irrelevant to the transformation.The Same Text in Other Cases
| Case | Result |
|---|---|
| camelCase | helloWorldExample |
| PascalCase | HelloWorldExample |
| snake_case | hello_world_example |
| SCREAMING_SNAKE_CASE | HELLO_WORLD_EXAMPLE |
| kebab-case | hello-world-example |
| Train-Case | Hello-World-Example |
Where aLtErNaTiNg Fits
Alternating case is a rhetorical device rather than a naming convention — it marks text as mocking quotation in social posts and chat. Worth knowing that screen readers announce it letter by letter, which makes it genuinely inaccessible where the text carries meaning.
Converting in Code
``javascript
const alternating = (s) =>
[...s].map((c, i) => (i % 2 ? c.toUpperCase() : c.toLowerCase())).join('');
`
Whether the index counts every character or only letters changes the output, and implementations differ. Skipping spaces and punctuation produces a different pattern from counting them, and neither is more correct.
Converting at the API Boundary
The recurring friction is that JavaScript uses camelCase and Python, Ruby, Go and SQL use
snake_case. The fix is to convert in exactly one place — the client that talks to the API —
rather than letting both conventions into the same codebase.
`javascript
const toCamel = (s) => s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
const toSnake = (s) => s.replace(/[A-Z]/g, (c) => '_' + c.toLowerCase());
// Recursively, for a whole payload
const convertKeys = (value, fn) =>
Array.isArray(value)
? value.map((v) => convertKeys(v, fn))
: value && typeof value === 'object'
? Object.fromEntries(Object.entries(value).map(([k, v]) => [fn(k), convertKeys(v, fn)]))
: value;
`
Two things to watch: keys that are user data rather than field names must not be
converted, and the round trip is not always lossless — userID → user_id → userId
changes the original.
Where Each Convention Is Mandatory
Not stylistic — these will break if you deviate:
| Context | Requirement |
|---|---|
| Environment variables | Uppercase with underscores; POSIX reserves lowercase |
| Custom HTML elements | Must contain a hyphen |
| Python modules | Cannot contain hyphens; the import statement will not parse |
| SQL identifiers | Folded to one case unless quoted, so camelCase does not survive |
| React components | Must start uppercase, or JSX treats it as an HTML tag |
Renaming Safely
A find-and-replace across a codebase will hit strings, comments and unrelated identifiers.
Use your language server's rename symbol instead — it understands scope. For a bulk rename
across files, restrict the pattern with word boundaries and review the diff before
committing:
`bash
grep -rn '\buserId\b' src/ # look first
``