Conversión de mayúsculas y minúsculas de cadenas snake_case, camelCase y por qué importa en APIs

La capitalización de cadenas es una de esas cosas que los desarrolladores no piensan hasta que silenciosamente rompen algo en producción. Un frontend en JavaScript envía userId pero el backend en Python espera user_id. Un ORM renombra silenciosamente tu columna SQL. Una tarea de CI falla porque una variable de entorno estaba mal escrita.

Las convenciones de capitalización existen porque los diferentes lenguajes, marcos y sistemas evolucionaron de forma independiente — cada uno con sus propios idiomas. Comprender cuál formato pertenece en cada lugar y saber cómo convertir entre ellos es una habilidad práctica que ahorra tiempo de depuración.

Los principales formatos de capitalización

Aquí tienes un resumen rápido de lo que encontrarás en la práctica y en qué contexto cada formato es la opción adecuada:

Contexto	Convención	Ejemplo	Notas
Variables en JavaScript / claves en JSON	el caso de Carmel	userId, firstName	La mayoría de los APIs REST siguen este formato
Variables en Python / claves en JSON	caso_serpiente	user_id, first_name	Django, FastAPI, SQLAlchemy por defecto
Nombres de clases (la mayoría de los lenguajes)	PascalCaso	UserProfile, ApiResponse	También llamado UpperCamelCase
Rutas en URLs	kebab-case	/user-profile, /api-docs	Mejor para el SEO que las subrayadas
Variables de entorno	SCREAMING_SNAKE	DATABASE_URL, API_KEY	Universal en shells y plataformas de CI
Encabezados HTTP	Train-Case	Content-Type, X-Api-Key	Estándar de HTTP/1.1
Columnas y tablas en SQL	caso_serpiente	user_id, created_at	Convención de PostgreSQL, MySQL

¿Por qué una capitalización inadecuada rompe las integraciones de API?

La causa más común de fallos es la frontera entre JavaScript y Python. Los ecosistemas en JavaScript — React, Node, APIs del navegador — producen camelCase. Los ecosistemas en Python — FastAPI, Django REST Framework, SQLAlchemy — esperan snake_case.

Cuando un cliente en JavaScript envía este payload:

{
  "firstName": "Alice",
  "userId": 42
}

Un servidor en Python que accede a request.json["first_name"] recibe un KeyError. Sin advertencia, sin fallback — solo un error. FastAPI puede resolver esto con alias_generator = to_camel en modelos de Pydantic, pero eso es una configuración opcional que la mayoría de los equipos no establecen hasta que enfrentan el error.

El mismo problema aparece en la frontera entre JavaScript y GraphQL, entre microservicios escritos en diferentes lenguajes, y en cualquier lugar en que deserialices JSON sin una mapeo explícito.

Conversión programáticamente

La mayoría de los lenguajes tienen esta solución, pero los enfoques varían.

JavaScript: La opción más limpia es change-case (ligero) o lodash (_.camelCase, _.snakeCase). Si prefieres omitir la dependencia:

// camelCase → snake_case
const toSnakeCase = str =>
  str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);

toSnakeCase('userName');   // 'user_name'
toSnakeCase('createdAt');  // 'created_at'

Python: El re el módulo lo maneja, pero la versión en un paso rompe en acrónimos como HTTPSProxy. Usa el enfoque en dos pasos:

import re

def to_snake_case(name):
    s1 = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', name)
    return re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', s1).lower()

to_snake_case('userName')    # 'user_name'
to_snake_case('HTTPSProxy')  # 'https_proxy'

Ruby: La biblioteca estándar no incluye un convertidor de capitalización. github.com/iancoleman/strcase es la opción común:

import "github.com/iancoleman/strcase"

strcase.ToSnake("UserName")  // "user_name"
strcase.ToCamel("user_name") // "UserName"
strcase.ToKebab("UserName")  // "user-name"

Si necesitas una conversión rápida sin escribir código, el IO Tools Convertidor de Capitalización de Cadenas maneja camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE y más — sin necesidad de instalación.

Convenciones de bases de datos y problemas de ORMs

Las bases de datos SQL — PostgreSQL, MySQL, SQLite — usan por convención snake_case para nombres de columnas y tablas. user_id, created_at, payment_method. Este es el formato esperado, y las consultas SQL brutas lo reflejarán.

Los ORMs suelen convertir automáticamente entre la convención del lenguaje y la de la base de datos, lo cual es conveniente hasta que no lo es. Sequelize convierte por defecto camelCase de JavaScript a snake_case en algunas configuraciones — excepto cuando no lo hace, dependiendo de las opciones del modelo, el dialecto o la versión. Prisma genera nombres de campos en camelCase que se mapean a columnas en snake_case. ActiveRecord pluraliza los nombres de tablas y convierte todo a snake_case.

La solución práctica: ser explícito. Define los nombres de columnas en tus definiciones de modelo en lugar de depender de conversiones automáticas. Esto hace que el mapeo sea visible en las revisiones de código y evita sorpresas cuando ejecutas consultas SQL directas o migras a un ORM diferente.

Rutas en URLs: usa kebab-case, no subrayados

Para rutas en URLs, kebab-case es la recomendación clara. La documentación de Google ha tratado históricamente los guiones como separadores de palabras y las subrayadas como unificadores. Una URL como /string-case-converter indica dos palabras distintas; /string_case_converter se lee como un único token.

La implicación práctica: las URLs en kebab-case funcionan mejor para el posicionamiento en buscadores en múltiples palabras clave. No es un factor de ranking importante, pero cuesta nada hacerlo bien desde el inicio.

Las principales APIs están de acuerdo — GitHub, Stripe y Twilio usan kebab-case para rutas en URLs. Segmentos como /api/v1/user-profiles son legibles, fáciles de escribir y coherentes con los estándares web.

Archivos de configuración: SCREAMING_SNAKE para variables de entorno, camelCase para YAML

Las variables de entorno usan universalmente SCREAMING_SNAKE_CASE. DATABASE_URL, AWS_SECRET_ACCESS_KEY, REDIS_HOST — esta convención se mantiene en Linux, Docker, Kubernetes y en todas las plataformas de CI/CD que encontrarás. Los shells exportan variables en este formato. No lo contradigas.

Los archivos de configuración en YAML cuentan otra historia. Los manifestos de Kubernetes, Docker Compose y los flujos de GitHub Actions usan camelCase para las claves — apiVersion, containerPort, imagePullPolicy. Ansible es la excepción notable, que usa snake_case en todas sus definiciones de tareas.

La regla aquí es simple: ajusta el formato al que espera la herramienta. No trates de normalizar todos tus archivos de configuración — eso crea inconsistencias sin ahorrar esfuerzo.

Obtener conversiones correctas

La tabla anterior cubre la mayoría de los escenarios. La verdadera habilidad es saber cuándo una discrepancia de capitalización causa un error en tiempo de ejecución y cuándo un framework lo maneja silenciosamente. Cuando trabajas entre lenguajes, verifica qué hace tu serializador o ORM — no asumas que la conversión automática está ocurriendo.

Para conversiones rápidas, de un solo uso, sin escribir código, el IO Tools Convertidor de Capitalización de Cadenas maneja todos los formatos principales en un solo lugar. Pega una cadena, elige el formato objetivo, listo.

También te puede interesar