Convertir mayúsculas/minúsculas _

¿Qué es la conversión de mayúsculas/minúsculas?

La conversión de mayúsculas/minúsculas toma una cadena de entrada y emite las mismas palabras en una convención de capitalización distinta. Los destinos más comunes son camelCase y PascalCase (usados para identificadores en la mayoría de los lenguajes con llaves), snake_case y CONSTANT_CASE (Python, Ruby, Rust, macros de C), kebab-case (URL, nombres de clases CSS, atributos HTML, nombres de paquetes npm), dot.case (claves de configuración, rutas de objetos JavaScript), path/case (identificadores estilo sistema de archivos), Title Case y Sentence case (titulares y prosa), más lower case y UPPER CASE íntegros. Este convertidor detecta los límites naturales de palabra en tu entrada — espacios en blanco, guiones, guiones bajos, puntos, barras y las transiciones minúscula→mayúscula que marcan identificadores tipo helloWorld — y los reensambla con el separador y el patrón de capitalización que cada caso destino exige.

¿Cómo funciona la conversión de mayúsculas/minúsculas?

Tu entrada se procesa íntegramente en tu navegador usando un pequeño tokenizador en JavaScript puro y once formateadores de capitalización. Los pasos principales son:

1. Tu entrada se lee tal cual del área de texto — cada byte que pegaste se mantiene en memoria de forma local.
2. Un tokenizador divide la entrada por espacios, guiones bajos, guiones, puntos y barras, y luego subdivide cada fragmento por los límites minúscula→mayúscula (de modo que helloWorld se convierte en ["hello", "World"]) y por los límites letra↔dígito (de modo que v2API se convierte en ["v", "2", "API"]).
3. Los tokens vacíos se filtran y los supervivientes se pasan a minúsculas con String.prototype.toLocaleLowerCase para que las letras Unicode del turco, alemán y otros idiomas se preserven correctamente.
4. Once formateadores ensamblan luego los tokens en cada caso destino: camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, dot.case, path/case, Title Case (con una lista de palabras cortas para que and, the, of, etc. permanezcan en minúsculas salvo como primera o última palabra), Sentence case, lower case y UPPER CASE.
5. La salida se escribe una fila por caso en la cuadrícula de resultados; cada fila tiene su propio botón de copia que usa la Clipboard API asíncrona con un respaldo síncrono document.execCommand('copy') para navegadores antiguos.

¿Por qué usar un convertidor de mayúsculas/minúsculas?

• Refactorizar identificadores: renombra una variable JavaScript de user_id a userId, una función Python de helloWorld a hello_world, o una constante Rust de maxBuffer a MAX_BUFFER sin editar a mano carácter por carácter.
• Convertir claves de configuración: pasa un JSON lleno de claves camelCase a YAML en snake_case para un servicio Python, o a kebab-case para un chart de Helm, con un solo pegado.
• Redactar titulares: pega un titular borrador y lee la forma Title Case (con las excepciones de palabras cortas del Chicago Manual of Style) junto a la forma Sentence case (AP Stylebook) — elige la que use tu publicación.
• Generar slugs de URL: pega el título de un artículo y copia la forma kebab-case directo en el campo de slug de tu CMS — el tokenizador maneja la puntuación y las frases multi-palabra sin dejar separadores sueltos.

¿Cuáles son las aplicaciones comunes de la conversión de capitalización?

Cambiar entre convenciones de capitalización aparece en ingeniería de software, redacción de contenido e ingeniería de datos:

• Refactorización de código: renombra identificadores en una base de código cuando cambia una guía de estilo (p. ej. JavaScript camelCase → Python snake_case durante una reescritura del backend) sin introducir erratas.
• Remodelado de payloads de API: convierte claves JSON camelCase a snake_case antes de alimentarlas a un backend Ruby on Rails o Django, o a kebab-case para un nombre de clase CSS-in-JS.
• Redacción de titulares y slugs: produce títulos de página en Title Case, meta-descripciones en Sentence case y slugs de URL en kebab-case desde el mismo titular fuente en un paso.

¿Cómo es un ejemplo de conversión de capitalización?

Pega Hello World API en la entrada. La cuadrícula de resultados muestra once filas simultáneamente: helloWorldApi (camelCase), HelloWorldApi (PascalCase), hello_world_api (snake_case), HELLO_WORLD_API (CONSTANT_CASE), hello-world-api (kebab-case), hello.world.api (dot.case), hello/world/api (path/case), Hello World Api (Title Case), Hello world api (Sentence case), hello world api (lower case) y HELLO WORLD API (UPPER CASE). La misma entrada pegada como helloWorldAPI se tokeniza a las mismas tres palabras — el detector de límite minúscula→mayúscula maneja también esa forma.

¿Esto se ejecuta en mi navegador?

Sí. El tokenizador y los once formateadores de capitalización son unas 120 líneas de JavaScript puro corriendo dentro de la pestaña del navegador. Nada se sube, ningún service worker hace de proxy de tu entrada y la página no realiza ninguna petición de red para el paso de conversión en sí. El único tráfico saliente son los activos estándar de carga de página (CSS, fuentes, analítica) — tu texto nunca llega a Ultim8Soft.

¿Qué formato de capitalización debo usar para nombres de variables?

Depende del lenguaje y de la guía de estilo del equipo. Las bases de código JavaScript y TypeScript usan abrumadoramente camelCase para variables y funciones, PascalCase para clases y componentes React, y CONSTANT_CASE para nombres de variables de entorno y constantes a nivel de módulo — tanto la guía de estilo JavaScript de Google como la de Airbnb fijan esas elecciones. Python (PEP 8), Ruby y Rust prefieren snake_case para variables y funciones, PascalCase para clases y CONSTANT_CASE para constantes de módulo. Las bases de código C y C++ (kernel Linux, LLVM) se apoyan en snake_case para funciones y CONSTANT_CASE para macros del preprocesador. Cuando dudes, ejecuta el linter o formateador de tu equipo — te dirá qué convención está vigente.

¿Cómo se tokeniza la entrada?

El tokenizador primero divide la entrada por cualquier secuencia de espacio en blanco, guion bajo (_), guion (-), punto (.) o barra (/). Cada fragmento resultante se vuelve a dividir por los límites minúscula→mayúscula (de modo que helloWorld se convierte en ["hello", "World"]) y por los límites letra↔dígito (de modo que v2API se convierte en ["v", "2", "API"]). Los tokens vacíos se filtran y los supervivientes se pasan a minúsculas con String.prototype.toLocaleLowerCase. Los formateadores luego re-capitalizan y re-unen los tokens con el separador que cada caso destino requiere. La estrategia maneja las seis formas comunes de identificador — camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE y prosa con espacios — de fábrica.

¿Qué pasa con caracteres Unicode / no ASCII?

Las letras Unicode sobreviven el viaje de ida y vuelta. El tokenizador usa String.prototype.toLocaleLowerCase y toLocaleUpperCase, que respetan reglas de capitalización específicas del locale — la i turca con y sin punto, la ß alemana que pasa a SS, letras latinas acentuadas en francés y español, etc. Los caracteres no letra que NO están en el conjunto de separadores (espacio en blanco, _, -, ., /) — por ejemplo dígitos, letras acentuadas o caracteres CJK — se mantienen dentro del token en que aparecen y los formateadores los re-emiten tal cual. Eso significa que una entrada como nœud_principal se tokeniza a ["nœud", "principal"] y se convierte limpiamente a nœudPrincipal (camelCase) o NœudPrincipal (PascalCase).

Este convertidor de mayúsculas/minúsculas es una única página estática que ejecuta el tokenizador y los once formateadores enteramente en tu navegador — sin biblioteca de terceros, sin llamada de red por conversión, sin cuenta. Pega cualquier texto arriba, escanea las once salidas en paralelo y copia la que necesites.