← Todos los artículos
Actualizado el May 29, 20266 min read

Coma final en JSON: por qué { "a": 1, } lanza un error

Una sola coma extraviada tras el último elemento de un objeto o array JSON provoca un SyntaxError. Aprende por qué JSON prohíbe las comas finales, de dónde vienen y cómo eliminarlas.

Escribes lo que parece JSON perfectamente razonable —— cada key entre comillas, cada valor válido —— y JSON.parse() sigue lanzando un SyntaxError. El culpable es casi siempre una coma final: esa , extra que se queda después del último item de un objeto o array. Aquí está por qué JSON la prohíbe, por dónde se cuela y cómo deshacerte de ella.

¿Qué es una coma final?

Una coma final (también llamada «coma colgante» o «coma terminal») es una coma que aparece después del último item de una lista —— sin nada que la siga antes del corchete de cierre.

// Coma final en un objeto
{
  "name": "Ada",
  "score": 98,   // ← esta coma no tiene siguiente item
}

// Coma final en un array
[1, 2, 3,]
//       ^ mismo problema

Ambos ejemplos de arriba lanzarán un SyntaxError al pasarse a JSON.parse().

¿Por qué JSON prohíbe las comas finales?

La gramática JSON (definida en RFC 8259) especifica que una coma es un separador entre elementos —— siempre debe tener un valor a ambos lados. La regla formal para un objeto JSON se ve así:

object = "{" [ member *( "," member ) ] "}"
member = string ":" value

Una coma debe ir seguida de otro member. Si no hay nada después de la coma, la gramática es inválida. Esto fue una decisión de diseño deliberada: JSON prioriza la simplicidad y el parseo sin ambigüedades sobre la conveniencia del desarrollador.

JavaScript tomó otro camino. ES5 (2009) hizo explícitamente legales las comas finales en literales de array, y ES2017 lo extendió a parámetros de función. Las comas finales en JS ahora son estilo común —— muchos linters incluso las imponen porque producen diffs git más limpios cuando añades un nuevo item a una lista.

La brecha entre lo que JavaScript permite y lo que JSON permite es la raíz de casi todo error de coma final que verás.

De dónde vienen las comas finales

Archivos de config editados a mano

Archivos de config como tsconfig.json, package.json o ajustes de app son editados por humanos. Después de añadir o eliminar una entrada, es fácil dejar una coma errante. Muchos editores (VS Code, WebStorm) aceptan silenciosamente JSONC (JSON-with-Comments) que permite comas finales, así que el archivo se ve bien en el editor pero rompe en runtime.

// Borraste "debug": true pero olvidaste quitar la coma
{
  "compilerOptions": {
    "strict": true,
    "target": "ES2020",   // ← ahora final
  }
}

Serialización JavaScript → JSON

A veces los desarrolladores construyen un string JSON manualmente interpolando valores JavaScript, o usando Array.join(','). Si la lógica añade una coma después de cada item incondicionalmente, el último item se queda con una coma final.

// ❌ serialización manual ingenua
const parts = items.map(item => `"${item.name}": ${item.value}`);
const json = '{' + parts.join(',') + ',}'; // coma extra antes de }

// ✅ usa JSON.stringify —— siempre produce JSON válido
const json = JSON.stringify(Object.fromEntries(items.map(i => [i.name, i.value])));

Salida de LLM y AI

A los modelos de lenguaje a los que se les pide «salida en JSON» frecuentemente producen comas finales. El modelo ha visto enormes cantidades de código JavaScript durante el entrenamiento donde las comas finales son legales, así que replica el patrón. Siempre valida o repara el JSON generado por AI antes de parsearlo.

Copia-pega desde código JavaScript

Copiar un literal de objeto de un archivo .js o .ts y pegarlo en un contexto JSON es una de las formas más comunes en que aparecen las comas finales. El código fuente era JavaScript válido; el destino solo acepta JSON.

Cómo encontrar la coma final

El mensaje de error suele apuntarte cerca del problema, pero no siempre exactamente a la coma misma —— el parser solo nota que algo está mal cuando se topa con el inesperado } o ]:

SyntaxError: Expected double-quoted property name in JSON at position 58
// o
SyntaxError: Unexpected token '}', ..."score": 98,}" is not valid JSON

Trabaja hacia atrás desde la posición reportada. La coma final es el carácter inmediatamente antes del corchete de cierre que disparó el error.

Para archivos JSON grandes, una búsqueda con regex ayuda:

// Encontrar comas finales en objetos/arrays
,\s*[}\]]

Cómo arreglarlo

Opción 1 —— Borrarla manualmente

Encuentra el último item del objeto o array ofensor y elimina la coma de después. Para archivos pequeños este es el enfoque más rápido.

Opción 2 —— Usar reemplazo con regex (cuidado)

const fixed = raw.replace(/,\s*([}\]])/g, '$1');
JSON.parse(fixed);

Esto funciona para el caso común, pero es frágil: puede corromper strings que contengan ,} o ,] como caracteres literales. Úsalo solo cuando sepas que la entrada no contiene tales strings.

Opción 3 —— Usar un parser de reparación apropiado

Un parser de reparación entiende la gramática JSON completa y elimina las comas finales solo en las posiciones estructurales donde son inválidas, sin tocar el contenido de los strings. Es el enfoque más seguro para código de producción o input no confiable.

Opción 4 —— Cambiar a JSONC para archivos de config

Si las comas finales están en un archivo de config que controlas, considera cambiar a un parser que soporte JSONC (JSON con comentarios). El tsconfig.json de TypeScript ya usa JSONC. Para archivos de config de Node.js, librerías como @humanwhocodes/momoa o json5 parsean un superconjunto de JSON que permite comas finales y comentarios.

Cuando las comas finales sí están permitidas: JSONC y JSON5

Dos formatos adyacentes a JSON permiten deliberadamente comas finales (y algunas otras relajaciones), y vale la pena reconocerlos:

  • JSONC (JSON con comentarios) —— usado por tsconfig.json, el settings.json de VS Code y muchos otros configs de desarrollador. JSONC permite comentarios // / /* */ y comas finales. El archivo sigue llamándose .json, pero el JSON.parse() estándar lo rechaza —— VS Code y el tooling envían parsers conscientes de JSONC.
  • JSON5 —— un superconjunto más completo: comentarios, comas finales, keys sin comillas, comillas simples, strings multilínea, números hex. Opta con el paquete npm json5 o pyjson5 en Python. Úsalo donde humanos editan datos a mano y controlas el parser; no lo envíes por una API a clientes que esperan JSON estricto.

Regla práctica: mantén las comas finales fuera de cualquier cosa que cruce un parser JSON estricto (respuestas de API, bodies de request, archivos consumidos por librerías aleatorias), y abrázalas dentro de JSONC/JSON5 solo donde el consumidor está al tanto.

Previniendo comas finales

  • Nunca construyas strings JSON manualmente. Usa JSON.stringify() —— siempre produce salida que cumple la spec.
  • Añade una regla de linter. La regla jsonc/no-trailing-commas de ESLint atrapa comas finales en archivos .json al guardar.
  • Valida la salida de AI. Siempre ejecuta JSON.parse() (o un parser de reparación) sobre cualquier cosa que genere un modelo de lenguaje antes de usarla.
  • Usa Prettier. Prettier reformatea archivos JSON y elimina comas finales automáticamente al guardar.

Preguntas frecuentes

¿JSON permite comas finales?

No. La gramática JSON en RFC 8259 define una coma estrictamente como un separador entre dos valores, así que una coma sin nada después antes del } o ] de cierre es inválida. Cada parser estándar —— JSON.parse(), el módulo json de Python, el encoding/json de Go —— la rechaza.

¿Cómo elimino una coma final de JSON?

Para un archivo, borra la coma después del último item manualmente. Para arreglos repetidos o programáticos, usa JSON.stringify() para regenerar el JSON, un parser de reparación, o una herramienta como JSON Fix que elimina comas finales estructurales sin tocar el contenido de strings.

¿Por qué JavaScript permite comas finales pero JSON no?

JavaScript añadió comas finales en ES5 (arrays) y ES2017 (parámetros de función) como una funcionalidad de conveniencia para desarrolladores que produce diffs git más limpios. JSON es un formato de intercambio deliberadamente minimalista que prioriza el parseo sin ambigüedades sobre la conveniencia, así que nunca las adoptó. Ve JSON vs objetos JavaScript para la lista completa de diferencias.

¿Qué error causa una coma final?

Normalmente SyntaxError: Unexpected token '}' o Expected double-quoted property name in JSON, porque el parser espera otro valor después de la coma y en su lugar encuentra el corchete de cierre. Esta es una variante de los más amplios errores «Unexpected token» de JSON.parse.

Arréglalo ahora —— sin instalación

Si tienes un string JSON con comas finales que necesitas arreglado inmediatamente, JSON Fix las elimina automáticamente junto con cualquier otro problema común —— comillas simples, keys sin comillas, literales Python, comentarios JavaScript. Pega tu JSON, haz clic en Repair & Format y copia JSON limpio de vuelta. Sin cuenta, sin subida, ningún dato deja tu navegador.