T
case-converter text-utility programming formatting

El Convertidor de Mayúsculas Definitivo: Transforma Estilos de Texto al Instante

Cambia sin esfuerzo entre MAYÚSCULAS, minúsculas, camelCase, PascalCase y más. Una herramienta versátil para desarrolladores y escritores.

2026-04-09 Usar esta herramienta

¿Qué es el «case» de un texto? Historia y origen

La palabra «case» (caso) para referirse a las mayúsculas y minúsculas tiene un origen muy concreto: la imprenta de tipos móviles. Los tipógrafos del siglo XIX guardaban los tipos en dos bandejas superpuestas. Los tipos de letra mayúscula (uppercase) estaban en la bandeja de arriba, y los de letra minúscula (lowercase), en la de abajo. Este detalle físico se convirtió en vocabulario que sobrevivió a la era mecánica y digital.

Con la llegada de los ordenadores y los lenguajes de programación, surgió una restricción práctica: los identificadores no podían contener espacios. Para nombrar variables o funciones compuestas por varias palabras, los programadores desarrollaron de forma orgánica distintas convenciones de concatenación. El lenguaje C popularizó el guión bajo, Smalltalk inventó el camelCase, Pascal dio nombre al estilo de iniciales en mayúscula, y CSS introdujo el guión como separador en sus propiedades.

Hoy en día, un desarrollador fullstack maneja en un mismo día TypeScript en el frontend, Python en el backend, SQL en la base de datos y JSON en la API REST, cada uno con sus propias convenciones de nombrado. Por eso una herramienta de conversión de casos tiene tanto valor en el día a día.

Todos los tipos de case explicados

camelCase

La primera palabra va en minúsculas y cada palabra siguiente comienza con mayúscula. No hay separador.

Ejemplos: myVariableName, getUserById, fetchDataFromApi

Usado en: JavaScript (variables y funciones), TypeScript (variables y funciones), Java (variables y métodos), Swift, Kotlin.

El nombre viene de las «jorobas» que forman las letras mayúsculas intercaladas, parecidas al lomo de un camello. Es el estilo por defecto en la mayoría de los lenguajes de la familia C para identificadores que no son tipos.

PascalCase (UpperCamelCase)

Igual que camelCase, pero la primera palabra también empieza con mayúscula. Todas las palabras tienen la inicial en mayúscula.

Ejemplos: MyClassName, HttpRequestHandler, UserProfileService

Usado en: C# (clases e interfaces), TypeScript (clases, interfaces y enumeraciones), Java (clases), convenciones de .NET en general.

PascalCase actúa como señal semántica de "esto es un tipo". Se popularizó con el lenguaje Pascal, aunque Smalltalk lo utilizaba de forma similar con anterioridad.

snake_case

Todas las letras en minúscula, palabras separadas por guión bajo.

Ejemplos: my_variable_name, get_user_by_id, calculate_total_price

Usado en: Python (obligatorio por PEP 8 para variables, funciones y módulos), Ruby, Rust, nombres de columnas en SQL, biblioteca estándar de C.

El guión bajo actúa como separador visual claro, lo que hace que los identificadores largos sean muy legibles sin depender de cambios de mayúsculas.

kebab-case

Todas las letras en minúscula, palabras separadas por guión medio.

Ejemplos: my-css-class, user-profile-card, background-color

Usado en: Propiedades CSS (font-size, border-radius), atributos HTML, slugs de URL, claves de configuración YAML/TOML.

En la mayoría de lenguajes de programación, el guión medio se interpreta como el operador de resta, por lo que kebab-case no puede usarse en nombres de variables. Sin embargo, es el estándar dominante en CSS y URLs.

SCREAMING_SNAKE_CASE (UPPER_SNAKE_CASE)

Como snake_case, pero completamente en mayúsculas.

Ejemplos: MAX_RETRY_COUNT, API_BASE_URL, DEFAULT_TIMEOUT_MS

Usado en: Constantes en casi todos los lenguajes: Python, JavaScript/TypeScript, Java (static final), macros de C, variables de entorno del sistema operativo.

El impacto visual de las mayúsculas transmite un mensaje inequívoco: «este valor no cambia en tiempo de ejecución». Los linters de la mayoría de ecosistemas generan advertencias si se viola esta convención.

Title Case

La inicial de cada palabra importante va en mayúscula (artículos, preposiciones y conjunciones suelen dejarse en minúscula según las guías de estilo).

Ejemplos: My Article Title, Introduction to Machine Learning

Usado en: Títulos de artículos y libros, etiquetas de botones en UI, textos de marketing.

Las reglas exactas varían según la guía de estilo (Chicago, APA, AP). Para la mayoría de los usos en desarrollo, «poner en mayúscula la inicial de cada palabra» es una aproximación suficientemente segura.

Sentence case

Solo la primera letra de la primera palabra va en mayúscula (más los nombres propios).

Ejemplos: This is a paragraph heading

Usado en: Prosa normal, algunas etiquetas de UI, convenciones de títulos en lenguas europeas.

Las guías de Material Design recomiendan Sentence case para el texto del cuerpo y las etiquetas secundarias.

flatcase

Todas las letras en minúscula, sin separador alguno.

Ejemplos: myvariable, httphandler, packagename

Usado en: Nombres de paquetes en Go (fmt, http, strconv), nombres de paquetes Java (com.example.myapp).

Sacrifica la legibilidad en favor de la brevedad, por lo que solo es adecuado para nombres cortos de un único concepto.

Por qué importan las convenciones de nomenclatura

Las convenciones de nomenclatura no son una preferencia estética; son un protocolo de comunicación dentro de un equipo de desarrollo.

Cuando toda la base de código sigue un mismo convenio, los desarrolladores pueden inferir el significado por la forma del identificador:

  • Ver MyService en TypeScript indica inmediatamente que es un tipo, no un valor.
  • Ver MAX_CONNECTIONS indica que es una constante.
  • Ver user_id en una consulta SQL indica que es una columna de base de datos.

Legibilidad: El estudio de Binkley et al. (2009) mostró que camelCase se lee más rápido en identificadores cortos dentro del código, mientras que snake_case gana en comprensión para palabras compuestas largas.

Consistencia del equipo: Mezclar getUserById y get_user_by_id en el mismo repositorio obliga a los revisores a realizar un cambio de contexto constante. Los linters como ESLint, flake8 o golangci-lint pueden hacer cumplir las convenciones de forma automática.

Soporte del tooling: La autocompletación del IDE, las herramientas de refactorización y los generadores de documentación dependen de patrones de nomenclatura consistentes para funcionar correctamente.

Convenciones por lenguaje

JavaScript / TypeScript

Variables y funciones:    camelCase       (let userName, function getData)
Clases e interfaces:      PascalCase      (class UserService, interface IRepository)
Constantes:               SCREAMING_SNAKE  (const MAX_SIZE = 100)
Enumeraciones:            PascalCase      (enum Direction)
Nombres de archivo:       kebab-case      (user-service.ts, api-client.ts)
Clases CSS:               kebab-case      (.btn-primary, .card-header)

Python (PEP 8)

Variables y funciones:    snake_case      (user_name, get_data)
Clases:                   PascalCase      (class UserService)
Constantes:               SCREAMING_SNAKE  (MAX_SIZE = 100)
Módulos:                  snake_case      (my_module.py)
Miembros privados:        _single_leading_underscore

Go

Identificadores exportados:   PascalCase  (func GetUser, type UserService)
Identificadores no exportados: camelCase  (func getUser, var userCount)
Nombres de paquete:           flatcase    (package http, package fmt)

Go usa el case como modificador de visibilidad: PascalCase = público (exportado), camelCase = privado (no exportado). El compilador lo impone.

Java

Variables y métodos:      camelCase       (String userName, void getData())
Clases e interfaces:      PascalCase      (class UserService)
Constantes:               SCREAMING_SNAKE  (static final int MAX_SIZE = 100)
Paquetes:                 flatcase        (com.example.myapp)

CSS y HTML

Nombres de clase:         kebab-case      (.btn-primary, .nav-item)
Propiedades personalizadas: kebab-case   (--primary-color, --font-size-lg)

SQL / Bases de datos

Tablas:                   snake_case      (user_profiles, order_items)
Columnas:                 snake_case      (first_name, created_at)

Cómo funciona el convertidor técnicamente

Un convertidor de casos debe resolver dos problemas fundamentales:

  1. Detección de límites de palabra: dado un string en cualquier formato, dividirlo en una lista de tokens (palabras).
  2. Reensamblado: unir esos tokens en el formato objetivo.

La detección de límites usa expresiones regulares para identificar transiciones:

  • De minúscula a mayúscula: camelCase → camel, Case
  • Guión bajo o guión medio: snake_case → snake, case
  • Espacios en blanco
  • Límites de dígitos (opcional): base64Encode → base64, Encode

El caso más complejo son las siglas: XMLParser debe dividirse en XML, Parser, no en X, M, L, Parser.

Ejemplos de código

Python

import re

def tokenize(text: str) -> list[str]:
    """Divide cualquier convención de nombrado en una lista de tokens en minúscula."""
    text = re.sub(r'(?<=[a-z0-9])(?=[A-Z])', '_', text)
    text = re.sub(r'(?<=[A-Z])(?=[A-Z][a-z])', '_', text)
    words = re.split(r'[\s_\-]+', text)
    return [w.lower() for w in words if w]

def to_snake_case(text: str) -> str:
    return '_'.join(tokenize(text))

def to_camel_case(text: str) -> str:
    words = tokenize(text)
    return words[0] + ''.join(w.title() for w in words[1:])

def to_pascal_case(text: str) -> str:
    return ''.join(w.title() for w in tokenize(text))

def to_kebab_case(text: str) -> str:
    return '-'.join(tokenize(text))

def to_screaming_snake(text: str) -> str:
    return '_'.join(tokenize(text)).upper()

# Ejemplos
print(to_snake_case("getUserByID"))     # get_user_by_id
print(to_camel_case("user_profile"))    # userProfile
print(to_pascal_case("my-css-class"))  # MyCssClass
print(to_screaming_snake("apiBaseUrl")) # API_BASE_URL

JavaScript / TypeScript

function tokenize(str) {
  return str
    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
    .split(/[\s_\-]+/)
    .filter(Boolean)
    .map(w => w.toLowerCase());
}

function toKebabCase(str) {
  return tokenize(str).join('-');
}

function toCamelCase(str) {
  const words = tokenize(str);
  return words[0] + words.slice(1).map(w => w[0].toUpperCase() + w.slice(1)).join('');
}

function toPascalCase(str) {
  return tokenize(str).map(w => w[0].toUpperCase() + w.slice(1)).join('');
}

// Ejemplos
console.log(toKebabCase('MyBackgroundColor'));  // my-background-color
console.log(toCamelCase('user_profile_page'));  // userProfilePage
console.log(toPascalCase('get-user-by-id'));    // GetUserById

Casos de uso reales

Diseño de APIs y documentación

Al diseñar una API REST, es fundamental mantener coherencia entre los slugs de URL (kebab-case), las claves del payload JSON (camelCase en el ecosistema JavaScript, snake_case en Python) y las columnas de la base de datos (snake_case).

Cadena de conversión típica:

  • Columna de BD: user_created_at
  • Respuesta JSON: userCreatedAt
  • Parámetro URL: user-created-at
  • Constante en código: USER_CREATED_AT

Migraciones de bases de datos

Al migrar entre ORMs o motores de base de datos, las convenciones de nombres de columnas suelen diferir. ActiveRecord (Ruby on Rails) prefiere snake_case; algunos sistemas legados usan PascalCase. Una conversión masiva de casos ahorra horas de trabajo tedioso.

Refactorización de código

Las bases de código grandes acumulan nombres inconsistentes de diferentes épocas o colaboradores. Durante sprints de refactorización, el convertidor de casos ayuda a procesar listas de identificadores rápidamente.

Regex manual vs. librerías

JavaScript: change-case

import { camelCase, snakeCase, pascalCase, kebabCase } from 'change-case';

camelCase('user_profile_page');  // 'userProfilePage'
snakeCase('getUserById');        // 'get_user_by_id'
pascalCase('my-css-class');      // 'MyCssClass'
kebabCase('MyBackgroundColor');  // 'my-background-color'

JavaScript: Lodash

import _ from 'lodash';
_.camelCase('Foo Bar');   // 'fooBar'
_.snakeCase('fooBar');    // 'foo_bar'
_.kebabCase('fooBar');    // 'foo-bar'

Python: inflection

import inflection
inflection.camelize('device_type')        # 'DeviceType'
inflection.underscore('DeviceType')       # 'device_type'
inflection.dasherize('device_type')       # 'device-type'

Cuándo usar una librería vs. implementación propia: Las librerías ganan en producción (manejo de casos límite, soporte Unicode, mantenimiento comunitario). Implementa tu propio convertidor solo cuando necesites un comportamiento específico no disponible en las librerías existentes.

Buenas prácticas

1. La consistencia por encima de la preferencia personal

La mejor convención de nomenclatura para tu proyecto es la que todo el equipo usa de forma uniforme. Mezclar snake_case y camelCase en la misma base de código es peor que usar cualquiera de los dos de forma exclusiva.

2. Automatiza con linters

No dependas de que las personas recuerden las convenciones:

  • ESLint con @typescript-eslint/naming-convention (JavaScript/TypeScript)
  • flake8 con el plugin pep8-naming (Python)
  • golangci-lint con el linter revive (Go)
  • RuboCop (Ruby)

3. Documenta tus convenciones

Añade una sección en el CONTRIBUTING.md de tu proyecto especificando qué convención aplica a cada tipo de identificador.

4. Respeta los idioms del lenguaje

No impongas convenciones externas a un lenguaje. Usar camelCase en Python porque «el resto del stack lo usa» es un antipatrón: combate el tooling del lenguaje y las expectativas de cualquier desarrollador Python que se incorpore al equipo.

5. Gestiona las siglas de forma coherente

Elige un enfoque y documéntalo:

  • XMLParser vs XmlParser vs xmlParser
  • userID vs userId
  • La guía de estilo de Go prefiere userID y xmlParser; la mayoría de guías JS prefieren userId y xmlParser.

Preguntas frecuentes

P: ¿Hay diferencia entre PascalCase y UpperCamelCase? No, son exactamente la misma convención. «PascalCase» es el término más habitual en la comunidad de desarrollo. «UpperCamelCase» se usa en documentación académica o formal para distinguirlo del camelCase normal (también llamado lowerCamelCase).

P: ¿Por qué no puedo usar kebab-case en variables de JavaScript? Porque el guión - es el operador de resta en JavaScript (y en la mayoría de lenguajes de la familia C). La expresión my-variable se parsea como my menos variable, no como un identificador único. Los lenguajes de configuración (YAML, CSS) no tienen esta restricción.

P: ¿El convertidor maneja caracteres Unicode y no ASCII? Las implementaciones robustas sí. Los enfoques basados en regex simples pueden tratar letras acentuadas (é, ü, ñ) como límites de palabra o perder su capitalización. Librerías como change-case para JavaScript manejan correctamente los casos Unicode más comunes.

P: ¿Qué case debo usar para los archivos de componentes React? La comunidad React usa PascalCase tanto para el nombre del componente como para el archivo: UserProfileCard.tsx. Esto distingue los archivos de componentes de los archivos de utilidades (utils.ts, api-client.ts) de un vistazo.

P: ¿Cómo debo tratar los números en los identificadores? La mayoría de tokenizadores tratan una secuencia de dígitos como su propio token. base64Encoder → base64, Encoder → base64_encoder en snake_case. Asegúrate de que tu tokenizador gestione esto de forma coherente para términos comunes como md5, sha256, oauth2.

P: ¿Deben las columnas de base de datos usar snake_case aunque la aplicación use camelCase? Casi siempre sí. SQL no distingue mayúsculas de minúsculas en la mayoría de bases de datos, y firstName podría interpretarse de forma diferente por distintas herramientas. snake_case es la convención SQL universal y es comprendida por todos los ORMs. El mapeo a camelCase se hace en la capa de aplicación.

P: ¿Qué case debo usar para las variables de entorno? SCREAMING_SNAKE_CASE es el estándar universal para variables de entorno: DATABASE_URL, JWT_SECRET, PORT. Esta convención es seguida por la metodología de aplicaciones de doce factores, Docker, Kubernetes y prácticamente todas las plataformas de despliegue.

Descripción General

El formateo de texto es una parte fundamental de la programación y la escritura. Nuestro Convertidor de Casos es una utilidad de alto rendimiento diseñada para ayudar a los usuarios a transformar el formato de su texto al instante. Ya sea que necesite corregir un error de "BLOQUEO DE MAYÚSCULAS" o convertir un nombre de variable para un lenguaje de programación diferente, nuestra herramienta ofrece un conjunto completo de opciones para realizar el trabajo sin tener que volver a escribir manualmente.

Características Principales

  • Múltiples Modos de Caso: Soporta MAYÚSCULAS, minúsculas, Tipo oración (Sentence case), Tipo Título (Title Case), camelCase, PascalCase, snake_case y kebab-case.
  • Transformación en Vivo: Vea cómo cambia su texto en tiempo real mientras escribe o pega.
  • Interfaz Limpia: Diseñado para la velocidad con botones de copia con un solo clic y botones de borrado.
  • Compatibilidad Universal: Funciona con cualquier texto UTF-8, soportando caracteres especiales y diversos idiomas.

Cómo Usar

  1. Pegar Texto: Ingrese el texto que desea transformar en el cuadro de entrada.
  2. Elegir Modo: Seleccione el formato de caso deseado del menú.
  3. Refinar: Active opciones como "Eliminar espacios adicionales" si están disponibles.
  4. Copiar: Haga clic en el botón de copiar para obtener su texto recién formateado al instante.

Casos de Uso Comunes

  • Codificación y Scripting: Convierta rápidamente nombres_de_variables a camelCase o UPPER_SNAKE_CASE para diferentes convenciones.
  • Edición de Contenido: Corrija oraciones capitalizadas accidentalmente o formatee títulos para publicaciones de blog.
  • Gestión de Bases de Datos: Estandarice nombres de campos o valores de entrada durante la limpieza de datos.
  • Redes Sociales: Cree texto estilizado para publicaciones y bios.

Trasfondo Técnico

La herramienta utiliza Expresiones Regulares (Regex) especializadas para identificar los límites de las palabras y aplicar la lógica de transformación. Por ejemplo, para convertir a camelCase, el algoritmo identifica espacios, guiones bajos y guiones medios, los elimina y pone en mayúscula la primera letra de las palabras siguientes.

Preguntas Frecuentes

  • ¿Es seguro? Sí, todas las transformaciones ocurren en su navegador; nunca almacenamos su texto.
  • ¿Soporta texto grande? Sí, puede manejar miles de palabras al instante.
  • ¿Puedo deshacer? Use el estándar del navegador CMD/CTRL+Z o simplemente cambie el modo de nuevo.

Limitaciones

  • Matices Contextuales: El modo de Tipo oración (Sentence case) puede no reconocer siempre correctamente los nombres propios.
  • Acrónimos: La transformación a Tipo Título (Title Case) puede poner en minúscula algunos acrónimos dependiendo del algoritmo.
  • Símbolos Complejos: Los caracteres no alfanuméricos generalmente se preservan, pero podrían afectar la detección de límites.
Volver al blog Convertidor de Mayúsculas/Minúsculas →