Convertir claves JSON de camelCase a snake_case: reglas y casos

PublicadoHerramientaConvertidor de Caso de Llaves JSON

Contenido
  1. Cuándo aparece realmente este problema
  2. Cómo cambiar la notación a mano siguiendo las reglas
  3. Puntos que suelen malinterpretarse
  4. Resumen
  5. Preguntas frecuentes

Si la respuesta de una API llega en snake_case y el código del frontend usa la convención camelCase, no necesitas cambiar los nombres de las keys a mano cada vez: basta con conocer una sola regla de conversión de notación.

camelCase, snake_case, PascalCase y kebab-case son reglas de escritura que se basan en el mismo principio: "cómo se dividen las palabras y cómo se vuelven a unir". Este artículo explica cómo aplicar esas reglas tú mismo y qué casos límite suelen pasar desapercibidos en los conversores automáticos.

Resumen ① camelCase, snake_case, PascalCase y kebab-case son notaciones de los mismos datos que solo se diferencian en cómo separan las palabras. ② La conversión consiste en dividir las palabras según la posición de las mayúsculas y de los guiones bajos o guiones, y volver a unirlas según la notación de destino. ③ Las keys dentro de objetos y arrays anidados se rigen por la misma regla, aplicada de forma recursiva y sin límite de profundidad.

Cuándo aparece realmente este problema

Este problema surge cuando las convenciones de lenguajes y frameworks distintos se encuentran en torno a una misma API. Si el backend está escrito con un framework del ecosistema Python, las keys del JSON de respuesta suelen salir en snake_case (user_id, created_at).

En cambio, si el frontend es JavaScript o TypeScript, la convención del código suele ser camelCase (userId, createdAt).

Si usas la respuesta tal cual, acabarás con código donde user_id y userName se mezclan en un mismo archivo. Con pocos campos puedes improvisar una función de mapeo y seguir adelante, pero cuando hay decenas de campos y además se intercalan objetos anidados y arrays, es fácil olvidar una key en un nivel profundo.

Cómo cambiar la notación a mano siguiendo las reglas

Las cuatro notaciones se construyen con el mismo principio: divides el nombre de la key en "palabras" y luego las vuelves a unir según el modo que define cada notación.

Solo hay dos criterios para dividir palabras. En las notaciones sin separadores, como camelCase y PascalCase, cada mayúscula marca el inicio de una palabra nueva; en las notaciones con separadores, como snake_case y kebab-case, la división se hace en cada guion bajo (_) o guion (-).

Una vez divididas las palabras, basta con unirlas según estas reglas.

NotaciónRegla de uniónEjemplo (user, id)
camelCaseLa primera palabra en minúscula y, en las siguientes, solo la inicial en mayúscula, sin separadoresuserId
snake_caseTodas las palabras en minúscula, unidas con guion bajo (_)user_id
PascalCaseTodas las palabras con la inicial en mayúscula, sin separadoresUserId
kebab-caseTodas las palabras en minúscula, unidas con guion (-)user-id

Los objetos y arrays anidados siguen la misma regla

Por ejemplo, si conviertes { "user_id": 1, "profile": { "email_address": "a@test.com" } } a camelCase, user_id se divide por el guion bajo y pasa a ser userId, y email_address dentro del objeto profile anidado se convierte en emailAddress con la misma regla.

Si solo cambias las keys del nivel superior y dejas intactos los objetos internos, el resultado queda a medias, así que debes aplicar la misma regla de forma repetida en todos los niveles que hayas dividido.

Con arrays intercalados la regla no cambia. Una key que es un array, como order_list, pasa a orderList, y si los elementos de ese array son objetos como { order_id: 1 }, las keys dentro de cada elemento también cambian con la misma regla. Si los elementos son cadenas o números (por ejemplo, "tags": ["new", "sale"]), no hay ninguna key que cambiar y los valores se quedan como están.

Cómo automatizarlo con expresiones regulares

Al implementar este proceso en un programa, lo habitual es resolverlo con expresiones regulares. Una función que convierte a camelCase se reduce a un solo reemplazo: busca la letra minúscula que sigue a un "-" o un "_", la pasa a mayúscula y elimina el separador.

Una función que convierte a snake_case o kebab-case hace lo contrario: inserta un separador en cada posición donde aparece una mayúscula y luego pasa todo a minúscula. Para PascalCase, basta con tomar el resultado de camelCase y poner en mayúscula la primera letra.

Si solo tienes unas pocas keys, aplicar estas reglas a mano es suficiente. Pero cuando hay varios niveles de profundidad y muchas keys, es fácil olvidar alguna en los puntos anidados mientras las cambias una por una. Nuestra herramienta gratuita, el Convertidor de Caso de Llaves JSON, se encarga de esta aplicación recursiva de forma automática.

Compruébalo con nuestra herramienta gratuita.

Convertidor de Caso de Llaves JSON

Puedes usarlo gratis y sin registro: en cuanto pulses el botón Convertir verás el resultado al instante.

Puntos que suelen malinterpretarse

Las reglas en sí son sencillas, pero con datos reales hay ciertas formas de key que pueden dar resultados distintos de lo esperado.

SituaciónResultado
Guion y guion bajo mezclados (user-id_name)Ambos separadores se reconocen como inicio de palabra nueva, así que al convertir a camelCase se unen correctamente como userIdName
Key que ya empieza en mayúscula (UserId)Al convertir a snake_case o kebab-case, la regla inserta un separador en cada mayúscula, por lo que también queda uno delante de la primera letra y el resultado puede salir como _user_id o -user-id
El valor (value) es una cadena, un número, un booleano o nullSolo se convierten las keys; el contenido de los valores se mantiene tal cual estaba
La sintaxis JSON es incorrectaNo se convierte nada y en la pantalla se muestra tal cual el mensaje de error que genera JSON.parse

Keys con separadores mezclados o que empiezan en mayúscula

Que un guion y un guion bajo aparezcan juntos en una misma key (user-id_name) no es motivo de preocupación. Ambos separadores se reconocen como "inicio de una palabra nueva", así que al convertir a camelCase se unen correctamente como userIdName.

Al contrario, si la key original ya empieza en mayúscula, como en PascalCase (UserId), conviene mirar el resultado con atención. La regla para pasar a snake_case o kebab-case consiste en "insertar un separador en cada mayúscula", de modo que si la primera letra es mayúscula también se añade un separador ahí y el resultado puede quedar con un separador al principio.

Si ves un separador al inicio del resultado, puedes interpretarlo como una señal de que la key original empezaba en mayúscula.

Los valores (value) y los errores de sintaxis JSON

Los valores (value) no son objeto de conversión. Los valores de tipo cadena, número, booleano o null se mantienen exactamente como estaban, sea cual sea la notación. Aunque dentro de un valor aparezca por casualidad una cadena como user_id, esa cadena no cambia.

Cuando la sintaxis JSON es incorrecta, en lugar de la conversión aparece en pantalla el mensaje de error de análisis tal cual. Esto ocurre a menudo cuando los corchetes o las llaves no coinciden, cuando las keys no van entre comillas dobles, cuando queda una coma después del último elemento (trailing comma) o cuando se usan comillas simples en lugar de dobles.

El número de position que incluye el mensaje de error indica en qué carácter, contando desde el principio de la cadena e incluyendo los espacios, se produjo el problema, así que revisando esa zona puedes acotar la causa.

Resumen

  • camelCase, snake_case, PascalCase y kebab-case son notaciones de los mismos datos que solo se diferencian en la regla de dividir y volver a unir las palabras.
  • Los puntos donde empieza una mayúscula y las posiciones de los guiones bajos y los guiones son el criterio para dividir las palabras.
  • Para que el cambio sea completo, la misma regla debe aplicarse de forma repetida, sin límite de profundidad, a las keys dentro de objetos y arrays anidados.
  • Conviene saber que, si la key original empieza en mayúscula, el resultado de la conversión a snake_case o kebab-case puede quedar con un separador al principio.
  • El contenido de los valores (value), que no son keys, no se convierte, y si la sintaxis JSON es incorrecta se muestra tal cual el mensaje de error de análisis.
Convertidor de Caso de Llaves JSON

Puedes usarlo gratis y sin registro: en cuanto pulses el botón Convertir verás el resultado al instante.

Preguntas frecuentes

¿También se convierten las claves dentro de objetos y arreglos anidados?

Sí. Aunque un objeto contenga otro objeto o un arreglo contenga objetos, se buscan todas las claves en su interior de forma recursiva, sin límite de profundidad, y se convierten con la misma regla.

Si modifico el JSON en el campo de entrada, ¿el resultado cambia automáticamente?

No. La conversión se ejecuta una sola vez, con el valor que haya en la entrada en el momento en que presionas el botón "Convertir". Después de modificar la entrada, debes volver a presionar el botón para obtener un resultado nuevo.

¿También cambia la notación de las cadenas que están dentro de los valores, y no solo en los nombres de las claves?

No. Solo se convierten los nombres de las claves. Los valores como cadenas, números, booleanos y null se mantienen tal como estaban.

Aparece un error de sintaxis JSON, ¿qué está mal?

Significa que la cadena introducida no cumple la sintaxis que exige JSON.parse. Las causas más comunes son una coma final después del último elemento (trailing comma), el uso de comillas simples o nombres de clave sin comillas dobles. El número de posición que aparece en el mensaje de error en pantalla te indica en qué carácter se produjo el problema.

Este artículo está adaptado de nuestro original en coreano. Leer el original en coreano

Artículos relacionados

  1. Eliminar claves JSON: varias a la vez y en cualquier nivelAprende a borrar varias claves JSON a la vez y de forma recursiva: opción de mayúsculas, coincidencia exacta y resultado con un JSON no válido.
  2. Ordenar claves JSON alfabéticamente: qué cambia y qué noAl ordenar claves JSON solo cambia el orden de las propiedades; los arrays y los valores quedan igual. Mira cómo afectan la recursión y la indentación.
  3. Convertir un objeto JavaScript a JSON: errores y solucionesPor qué JSON.parse falla con objetos copiados de la consola: diferencias con la sintaxis JSON, cómo convertir a mano y cómo leer el error.
  4. Crear un JSON Schema: reglas de detección de tiposDescubre cómo se genera un esquema Draft-07 a partir de un JSON de ejemplo: cómo se deciden los tipos y qué significan required y anyOf.
  5. Error de sintaxis JSON: lee el mensaje y encuentra la causaQué indica la posición en un error de JSON y cómo reconocer los fallos más comunes: coma final, comillas simples, comentarios y claves sin comillas.
  6. JSON a TypeScript: cuándo aparecen ? y | en las interfacesCómo decide la conversión de JSON a TypeScript cuándo una clave lleva ? opcional y cuándo sus valores se unen con |, con ejemplos reales.

Herramientas relacionadas