Convertidor de Mayúsculas

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

La conversión de mayúsculas y minúsculas es el proceso de cambiar el uso de letras o el patrón de separación de palabras de una cadena de texto. Un convertidor toma una entrada como "hello world" y la transforma en UPPERCASE, lowercase, Title Case, camelCase, snake_case, kebab-case u otras convenciones. La transformación es sencilla para texto ASCII simple, pero surgen casos especiales con acrónimos ("XMLParser"), reglas específicas por idioma (la i turca con punto) y cadenas con varios sistemas de escritura.

Los lenguajes de programación, los sistemas de archivos y las guías de estilo imponen sus propias convenciones de nomenclatura. Las variables de JavaScript normalmente usan camelCase. Las funciones y variables de Python siguen snake_case según PEP 8. Los nombres de clases CSS usan kebab-case. Las columnas de bases de datos varían según el equipo, pero snake_case domina en PostgreSQL y MySQL. Cambiar manualmente entre estas convenciones es lento y propenso a errores, especialmente al renombrar en decenas de archivos.

Las convenciones de escritura también importan fuera del código. Title Case sigue reglas definidas por guías de estilo como el Chicago Manual of Style y la APA, donde los artículos y las preposiciones cortas se escriben en minúscula salvo que inicien la oración. Sentence case solo capitaliza la primera palabra y los nombres propios. El inglés americano usa Title Case por defecto en titulares; la mayoría de la documentación europea y tecnológica usa Sentence case.

¿Por qué usar este convertidor?

Pega cualquier texto y conviértelo entre nueve formatos de escritura al instante, sin instalar una extensión de VS Code ni escribir un script de un solo uso.

Casos de uso del convertidor

Referencia de convenciones de escritura

Cada convención de nomenclatura tiene reglas específicas para la capitalización y la separación de palabras. La tabla siguiente muestra los nueve formatos que admite esta herramienta, usando la frase "the quick brown fox" como referencia.

camelCase vs snake_case vs kebab-case

Estas tres convenciones dominan en el desarrollo de software, pero cada una pertenece a un ecosistema diferente. Elegir la incorrecta rompe los linters, viola los contratos de API o genera bases de código inconsistentes.

Ejemplos de código

Cómo convertir entre convenciones de escritura de forma programática. Cada ejemplo cubre las transformaciones más comunes: camelCase a snake_case, snake_case a camelCase, y conversiones básicas de mayúsculas, minúsculas y Title Case.

// camelCase → snake_case
function toSnakeCase(str) {
  return str
    .replace(/([a-z])([A-Z])/g, '$1_$2')
    .replace(/[\s-]+/g, '_')
    .toLowerCase()
}
toSnakeCase('myVariableName')  // → "my_variable_name"
toSnakeCase('kebab-case-str')  // → "kebab_case_str"

// snake_case → camelCase
function toCamelCase(str) {
  return str
    .toLowerCase()
    .replace(/[_-](\w)/g, (_, c) => c.toUpperCase())
}
toCamelCase('my_variable_name')  // → "myVariableName"

// Title Case
function toTitleCase(str) {
  return str.replace(/\w\S*/g, w =>
    w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
  )
}
toTitleCase('the quick brown fox')  // → "The Quick Brown Fox"

import re

text = "the quick brown fox"

# UPPERCASE / lowercase
text.upper()  # → "THE QUICK BROWN FOX"
text.lower()  # → "the quick brown fox"

# Title Case
text.title()  # → "The Quick Brown Fox"

# camelCase
def to_camel(s):
    words = re.split(r'[\s_-]+', s)
    return words[0].lower() + ''.join(w.capitalize() for w in words[1:])

to_camel("my_variable_name")  # → "myVariableName"

# snake_case from camelCase
def to_snake(s):
    return re.sub(r'([a-z])([A-Z])', r'\1_\2', s).lower()

to_snake("myVariableName")  # → "my_variable_name"

# kebab-case
def to_kebab(s):
    return re.sub(r'([a-z])([A-Z])', r'\1-\2', s).replace('_', '-').lower()

to_kebab("myVariableName")  # → "my-variable-name"

package main

import (
	"fmt"
	"regexp"
	"strings"
)

// camelCase → snake_case
func toSnake(s string) string {
	re := regexp.MustCompile("([a-z])([A-Z])")
	snake := re.ReplaceAllString(s, "${1}_${2}")
	return strings.ToLower(snake)
}

// snake_case → camelCase
func toCamel(s string) string {
	parts := strings.Split(strings.ToLower(s), "_")
	for i := 1; i < len(parts); i++ {
		parts[i] = strings.Title(parts[i])
	}
	return strings.Join(parts, "")
}

func main() {
	fmt.Println(toSnake("myVariableName"))  // → my_variable_name
	fmt.Println(toCamel("my_variable_name")) // → myVariableName
	fmt.Println(strings.ToUpper("hello"))    // → HELLO
	fmt.Println(strings.ToUpper("hello world")) // → HELLO WORLD
}

# UPPERCASE
echo "hello world" | tr '[:lower:]' '[:upper:]'
# → HELLO WORLD

# lowercase
echo "HELLO WORLD" | tr '[:upper:]' '[:lower:]'
# → hello world

# camelCase → snake_case (using sed)
echo "myVariableName" | sed 's/\([a-z]\)\([A-Z]\)/\1_\2/g' | tr '[:upper:]' '[:lower:]'
# → my_variable_name

# snake_case → kebab-case
echo "my_variable_name" | tr '_' '-'
# → my-variable-name

Preguntas frecuentes