Convertir camelCase a snake_case, kebab-case y PascalCase

Escribe o pega un nombre de variable, de función o de columna, o una lista con uno por línea, y la herramienta lo convierte a los estilos más usados en programación: camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, kebab-case, dot.case y Title Case. Separa bien los acrónimos (HTTPServer, userID), puede quitar las tildes y todo se convierte en tu navegador.

Nombres, uno por línea

Quitar tildes (y la ñ pasa a n) Separar los números (v2Api → v_2_api)

Cómo separa las palabras

Para pasar de un estilo a otro, primero hay que saber dónde empieza cada palabra. La herramienta usa las mismas reglas que change-case, la biblioteca de JavaScript más usada para esto:

Todo lo que no es letra ni cifra separa: espacios, guiones, guiones bajos, puntos o barras. mi-variable, mi_variable y mi variable dan las mismas dos palabras.
Una minúscula o una cifra seguida de una mayúscula: userId se divide en user e Id, y base64Encode en base64 y Encode.
Un acrónimo seguido de una palabra: en HTTPServer, la S empieza una palabra nueva porque la sigue una minúscula, así que salen HTTP y Server. Un acrónimo al final se queda entero: userID da user e ID.
Los números se quedan pegados a la letra de delante (utf8, base64, v2), salvo que marques «Separar los números».

Al unir de nuevo, los acrónimos se tratan como una palabra más: getHTTPResponseCode pasa a get_http_response_code en snake_case y a getHttpResponseCode en camelCase. Es lo que recomiendan las guías de estilo de Google para Java y la de Microsoft para .NET con los acrónimos de más de dos letras (HtmlParser, no HTMLParser). Go es la excepción: sus convenciones piden mantener los acrónimos en mayúsculas (ServeHTTP, userID).

Qué estilo usa cada lenguaje

camelCase: variables y funciones en JavaScript, TypeScript, Java y C# (variables locales y parámetros). En Go, lo que no se exporta.
PascalCase: clases, interfaces y tipos en casi todos los lenguajes; en C#, también métodos y propiedades; en Go, todo lo que se exporta.
snake_case: variables y funciones en Python (PEP 8), Rust y Ruby, y la convención habitual para tablas y columnas de SQL.
SCREAMING_SNAKE_CASE: constantes en Python, Java, JavaScript y C, y variables de entorno como DATABASE_URL.
kebab-case: direcciones web, clases e identificadores de CSS, atributos de HTML, nombres de paquetes npm y de archivos. No sirve para variables, porque el guion es el signo de restar.
dot.case: claves de archivos de configuración, como las application.properties de Spring (server.port).

Una regla práctica: no traduzcas la convención de un lenguaje a otro. Si una API devuelve JSON en snake_case y tu código es de JavaScript, conviértelo en un solo sitio, al recibir los datos, en lugar de mezclar los dos estilos por el programa.

Convertir nombres en Python

Sin bibliotecas externas, con las mismas reglas:

import re
import unicodedata


def sin_tildes(texto):
    """Quita tildes y diéresis: descompone cada letra (NFD) y descarta las marcas."""
    return "".join(c for c in unicodedata.normalize("NFD", texto) if unicodedata.category(c) != "Mn")


def palabras(nombre):
    """Divide un identificador en palabras: userID → user ID, HTTPServer → HTTP Server, mi-variable → mi variable."""
    trozos = re.split(r"[^\w]+|_", sin_tildes(nombre))      # todo lo que no es letra ni cifra separa
    resultado = []
    for trozo in trozos:
        actual = ""
        for i, c in enumerate(trozo):
            anterior = trozo[i - 1] if i else ""
            siguiente = trozo[i + 1] if i + 1 < len(trozo) else ""
            if actual and c.isupper() and (
                anterior.islower() or anterior.isdigit()               # userId → user Id
                or (anterior.isupper() and siguiente.islower())        # HTTPServer → HTTP Server
            ):
                resultado.append(actual)
                actual = ""
            actual += c
        if actual:
            resultado.append(actual)
    return resultado


def camel(nombre):
    p = palabras(nombre)
    return p[0].lower() + "".join(w.capitalize() for w in p[1:]) if p else ""


def pascal(nombre):
    return "".join(w.capitalize() for w in palabras(nombre))


def snake(nombre):
    return "_".join(w.lower() for w in palabras(nombre))


def constante(nombre):
    return "_".join(w.upper() for w in palabras(nombre))


def kebab(nombre):
    return "-".join(w.lower() for w in palabras(nombre))


for nombre in ["getHTTPResponseCode", "número de teléfono", "user_id", "MAX-RETRY-COUNT"]:
    print(f"{nombre!r:24} {camel(nombre):20} {pascal(nombre):20} {snake(nombre):23} {constante(nombre):23} {kebab(nombre)}")

$ python3 nombres.py'getHTTPResponseCode'    getHttpResponseCode  GetHttpResponseCode  get_http_response_code  GET_HTTP_RESPONSE_CODE  get-http-response-code
'número de teléfono'     numeroDeTelefono     NumeroDeTelefono     numero_de_telefono      NUMERO_DE_TELEFONO      numero-de-telefono
'user_id'                userId               UserId               user_id                 USER_ID                 user-id
'MAX-RETRY-COUNT'        maxRetryCount        MaxRetryCount        max_retry_count         MAX_RETRY_COUNT         max-retry-count

Otras herramientas para desarrolladores: probar expresiones regulares, comparar textos, formateador de JSON y codificar Base64 y URL. Todas, en decodigo.com/herramientas.

Reglas de separación: change-case (Blake Embrey, licencia MIT). Convenciones: PEP 8, Google Java Style Guide, Microsoft, convenciones de mayúsculas en .NET y Go Code Review Comments. La herramienta se comparó con change-case 5.4 en 6,040 nombres, la mitad quitando tildes, y en los siete estilos (42,280 conversiones): coinciden en todas. La función de Python da lo mismo que la herramienta en 2,000 nombres más.