Cómo validar JSON: Guía completa con ejemplos

JSON (JavaScript Object Notation) es la piedra angular de las APIs web modernas, los archivos de configuración y el intercambio de datos. Pero un JSON inválido puede causar fallos en la aplicación, integraciones de API rotas y horas de depuración frustrante. Esta guía te guiará a través de todo lo que necesitas saber para validar JSON, desde verificaciones básicas de sintaxis hasta validación avanzada con Schema usando ejemplos del mundo real.

Por qué es importante la validación JSON

El JSON inválido es una de las fuentes más comunes de errores en aplicaciones web. Una coma mal colocada, una clave sin comillas o una coma final pueden causar que JSON.parse() lance un SyntaxError, bloqueando todo el pipeline de datos. La validación detecta estos errores temprano, antes de que se propaguen a través de tu sistema y causen fallos posteriores.

Más allá de la corrección sintáctica, la validación también asegura que los datos JSON se ajusten a la estructura esperada. Una API puede devolver JSON válido pero con campos requeridos faltantes, tipos de datos incorrectos o valores fuera de rangos aceptables. La validación con Schema resuelve estos problemas estructurales.

Reglas de sintaxis JSON

Antes de profundizar en las herramientas de validación, es crucial comprender las reglas que hacen que JSON sea válido. JSON tiene una sintaxis estricta definida por RFC 8259, e incluso una violación de un solo carácter puede invalidar todo el documento.

Las cadenas deben usar comillas dobles

Todos los valores de cadena y las claves de objeto deben estar entre comillas dobles. Las comillas simples no son un delimitador de cadena JSON válido, un error común de los desarrolladores que vienen de JavaScript.

// Invalid - single quotes
{'name': 'Alice', 'age': 30}

// Valid - double quotes
{"name": "Alice", "age": 30}

Las claves de objeto deben llevar comillas

A diferencia de los literales de objeto de JavaScript, JSON requiere que todas las claves de objeto estén entre comillas dobles. Las claves sin comillas son un error de sintaxis.

// Invalid - unquoted keys
{name: "Alice", age: 30}

// Valid - quoted keys
{"name": "Alice", "age": 30}

No se permiten comas finales

JSON no permite comas después del último elemento de un objeto o array. Este es otro error común, especialmente al editar JSON manualmente.

// Invalid - trailing comma
{
  "name": "Alice",
  "age": 30,
}

// Valid - no trailing comma
{
  "name": "Alice",
  "age": 30
}

No se admiten comentarios

JSON no soporta comentarios. Ni los comentarios de una sola línea // ni los de múltiples líneas /* */ son válidos en JSON. Si necesitas documentación, usa un archivo separado o formatos como JSONC.

Errores comunes de validación JSON

Comprender los errores más comunes te ayuda a detectarlos y solucionarlos rápidamente. Aquí están los errores que encontrarás con más frecuencia:

• Token inesperado: Generalmente causado por comillas simples, claves sin comillas o comas finales. El mensaje de error incluye la ubicación donde falló el análisis.
• Fin inesperado de la entrada JSON: La cadena JSON está incompleta o vacía. Esto ocurre a menudo cuando las solicitudes de red devuelven una respuesta vacía.
• Carácter no espacio en blanco inesperado: Contenido extra después del valor JSON principal, como un segundo objeto no envuelto en un array.
• Número inválido: Números con ceros a la izquierda (excepto 0 solo), notación hexadecimal o valores NaN/Infinity no son JSON válido.

Validar JSON en JavaScript

La forma más simple de validar JSON en JavaScript es envolver JSON.parse() en un bloque try-catch. Si el JSON es inválido, el método lanza un SyntaxError.

function validateJSON(jsonString) {
  try {
    JSON.parse(jsonString);
    return { valid: true };
  } catch (error) {
    return {
      valid: false,
      error: error.message
    };
  }
}

const result = validateJSON('{"name": "Alice"}');
console.log(result);
// { valid: true }

const badResult = validateJSON("{'name': 'Alice'}");
console.log(badResult);
// { valid: false, error: "Unexpected token '..." }

Validar JSON en Python

Python proporciona el módulo json con json.loads() para analizar cadenas JSON. Similar a JavaScript, el JSON inválido genera un json.JSONDecodeError con información detallada de ubicación.

import json

def validate_json(json_string):
    try:
        json.loads(json_string)
        return {"valid": True}
    except json.JSONDecodeError as e:
        return {
            "valid": False,
            "error": str(e),
            "line": e.lineno,
            "column": e.colno
        }

result = validate_json('{"name": "Alice"}')
print(result)
# {'valid': True}

Validación con JSON Schema

La validación sintáctica solo te dice si el JSON está bien formado. JSON Schema te permite definir la estructura esperada y validar los datos contra ella. Los Schemas especifican campos requeridos, tipos de datos, rangos de valores, patrones de cadena y estructuras de objetos anidados.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["name", "email"],
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "integer", "minimum": 0 }
  }
}

Los validadores JSON Schema populares incluyen Ajv para JavaScript, jsonschema para Python y json-schema-validator para Java. Estas bibliotecas validan datos JSON contra tu Schema y generan mensajes de error detallados para cada violación.

Herramientas de validación JSON en línea

Cuando necesitas verificar rápidamente un documento JSON sin escribir código, los validadores en línea son la opción más rápida. Proporcionan retroalimentación instantánea con resaltado de errores y números de línea.

Mejores prácticas de validación JSON

• Valida temprano: Verifica el JSON en los límites del sistema (como endpoints API y funciones de importación de archivos) antes de que los datos ingresen a la lógica de negocio.
• Usa validación con Schema: Más allá de la sintaxis, usa JSON Schema para validar la estructura de datos, detectando campos faltantes, tipos incorrectos y valores fuera de rango.
• Proporciona mensajes de error claros: Cuando la validación falle, incluye la ruta del campo, el tipo esperado y el valor real para ayudar a los usuarios a corregir problemas rápidamente.
• Valida tanto en el cliente como en el servidor: La validación del lado del cliente proporciona retroalimentación instantánea, mientras que la validación del lado del servidor asegura la seguridad e integridad de los datos.
• Automatiza la validación en CI/CD: Usa herramientas como ajv-cli o jsonschema para validar archivos de prueba JSON y archivos de configuración en tu pipeline de construcción.
• Registra los errores de validación: Registra los fallos de validación con contexto para identificar patrones y corregir las causas raíz en los productores de datos.