String Case Conversion in JavaScript — toUpperCase, toLowerCase, and More

JavaScript’s built-in toUpperCase() and toLowerCase() handle basic case conversion, but converting between naming conventions like camelCase, snake_case, and kebab-case requires regex or splitting logic. Here’s everything you need.

Use the Case Converter to convert text between any naming convention online.

Built-in case methods

// Basic conversion:
'Hello World'.toUpperCase();  // 'HELLO WORLD'
'Hello World'.toLowerCase();  // 'hello world'

// Locale-aware (recommended for user-facing text):
'İstanbul'.toLocaleLowerCase('tr');  // 'istanbul' (Turkish locale)
'istanbul'.toLocaleUpperCase('tr');  // 'İSTANBUL'

// Without locale (default behavior):
'istanbul'.toUpperCase();  // 'ISTANBUL' (works for most languages)

Title case

JavaScript has no built-in toTitleCase(). Common implementations:

// Simple: capitalize first letter of each word
function toTitleCase(str) {
  return str.replace(/\b\w/g, char => char.toUpperCase());
}

toTitleCase('hello world');           // 'Hello World'
toTitleCase('the quick brown fox');   // 'The Quick Brown Fox'

// Smart title case (skip articles/prepositions):
const MINOR_WORDS = new Set(['a', 'an', 'the', 'and', 'but', 'or', 'for',
                              'nor', 'on', 'at', 'to', 'by', 'in', 'of', 'up']);

function toSmartTitleCase(str) {
  return str
    .split(' ')
    .map((word, i) => {
      if (i === 0 || !MINOR_WORDS.has(word.toLowerCase())) {
        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
      }
      return word.toLowerCase();
    })
    .join(' ');
}

toSmartTitleCase('the quick brown fox');  // 'The Quick Brown Fox'
toSmartTitleCase('lord of the rings');    // 'Lord of the Rings'

camelCase conversions

// To camelCase from any format:
function toCamelCase(str) {
  return str
    .toLowerCase()
    .replace(/[-_\s]+(.)/g, (_, char) => char.toUpperCase());
}

toCamelCase('snake_case_string');    // 'snakeCaseString'
toCamelCase('kebab-case-string');    // 'kebabCaseString'
toCamelCase('Title Case String');    // 'titleCaseString'

// camelCase to snake_case:
function camelToSnake(str) {
  return str
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
    .replace(/([a-z\d])([A-Z])/g, '$1_$2')
    .toLowerCase();
}

camelToSnake('getUserProfile');   // 'get_user_profile'
camelToSnake('parseHTTPRequest'); // 'parse_http_request'

// camelCase to kebab-case:
function camelToKebab(str) {
  return str
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
    .replace(/([a-z\d])([A-Z])/g, '$1-$2')
    .toLowerCase();
}

camelToKebab('getUserProfile');   // 'get-user-profile'
camelToKebab('parseHTTPRequest'); // 'parse-http-request'

PascalCase conversions

// To PascalCase from any format:
function toPascalCase(str) {
  return str
    .toLowerCase()
    .replace(/[-_\s]+(.)/g, (_, char) => char.toUpperCase())
    .replace(/^(.)/, char => char.toUpperCase());
}

toPascalCase('user profile');     // 'UserProfile'
toPascalCase('get-user-data');    // 'GetUserData'
toPascalCase('parse_http');       // 'ParseHttp'

// PascalCase to camelCase (just lowercase first letter):
function pascalToCamel(str) {
  return str.charAt(0).toLowerCase() + str.slice(1);
}

pascalToCamel('UserProfile');     // 'userProfile'
pascalToCamel('GetUserData');     // 'getUserData'

snake_case conversions

// To snake_case from any format:
function toSnakeCase(str) {
  return str
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
    .replace(/([a-z\d])([A-Z])/g, '$1_$2')
    .replace(/[\s\-]+/g, '_')
    .toLowerCase();
}

toSnakeCase('camelCaseString');   // 'camel_case_string'
toSnakeCase('PascalCaseString');  // 'pascal_case_string'
toSnakeCase('kebab-case-string'); // 'kebab_case_string'
toSnakeCase('Hello World');       // 'hello_world'

// snake_case to camelCase:
function snakeToCamel(str) {
  return str.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
}

snakeToCamel('user_first_name');  // 'userFirstName'
snakeToCamel('get_user_profile'); // 'getUserProfile'

kebab-case conversions

// To kebab-case from any format:
function toKebabCase(str) {
  return str
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
    .replace(/([a-z\d])([A-Z])/g, '$1-$2')
    .replace(/[\s_]+/g, '-')
    .toLowerCase();
}

toKebabCase('camelCaseString');    // 'camel-case-string'
toKebabCase('snake_case_string');  // 'snake-case-string'
toKebabCase('Title Case String');  // 'title-case-string'

Universal converter utility

A single function that converts from any format to any format:

function parseWords(str) {
  return str
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
    .replace(/[-_]+/g, ' ')
    .toLowerCase()
    .trim()
    .split(/\s+/);
}

function convertCase(str, format) {
  const words = parseWords(str);
  
  switch (format) {
    case 'camel':
      return words.map((w, i) => i === 0 ? w : w[0].toUpperCase() + w.slice(1)).join('');
    case 'pascal':
      return words.map(w => w[0].toUpperCase() + w.slice(1)).join('');
    case 'snake':
      return words.join('_');
    case 'kebab':
      return words.join('-');
    case 'upper':
      return words.join('_').toUpperCase();
    case 'title':
      return words.map(w => w[0].toUpperCase() + w.slice(1)).join(' ');
    default:
      return str;
  }
}

convertCase('getUserProfile', 'snake');   // 'get_user_profile'
convertCase('user-first-name', 'camel'); // 'userFirstName'
convertCase('HELLO_WORLD', 'pascal');    // 'HelloWorld'
convertCase('parseHTTPRequest', 'kebab'); // 'parse-http-request'

TypeScript utilities

// Type-safe case conversion:
type CaseFormat = 'camel' | 'pascal' | 'snake' | 'kebab' | 'upper';

function convertCase(str: string, format: CaseFormat): string {
  // ... implementation
}

// Useful for transforming API response keys:
type KeysToCamelCase<T> = {
  [K in keyof T as K extends string ? CamelCase<K> : K]: T[K] extends object
    ? KeysToCamelCase<T[K]>
    : T[K];
};

Converting object keys

// Convert all keys from snake_case to camelCase:
function keysToCamelCase(obj) {
  if (Array.isArray(obj)) return obj.map(keysToCamelCase);
  if (obj && typeof obj === 'object') {
    return Object.fromEntries(
      Object.entries(obj).map(([k, v]) => [
        snakeToCamel(k),
        keysToCamelCase(v),
      ])
    );
  }
  return obj;
}

keysToCamelCase({ user_id: 1, first_name: 'Alice', address: { city_name: 'London' } });
// { userId: 1, firstName: 'Alice', address: { cityName: 'London' } }

Related tools

• Case Converter — convert text between naming conventions online
• camelCase Guide — when to use camelCase
• snake_case Guide — Python and SQL naming