Como validar JSON: Guia completa com exemplos

JSON (JavaScript Object Notation) é a piedra angular das APIs web modernas, os arquivos de configuração e o intercambio de datos. Mas um JSON inválido pode causar fallos na aplicação, integraciones de API quebradas e horas de depuração frustrante. Esta guia te guiará através de todo lo que necessitas saber para validar JSON, desde verificaciones básicas de sintaxe até validação avanzada com Schema usando exemplos do mundo real.

Por que é importante a validação JSON

O JSON inválido é uma das fuentes mais comuns de erros em aplicaciones web. Uma coma mal colocada, uma clave sem comillas o uma coma final podem causar que JSON.parse() lance um SyntaxError, bloqueando todo o pipeline de datos. A validação detecta estes erros temprano, antes de que se propaguen através de tua sistema e causen fallos posteriores.

Mais lá de a correcção sintáctica, a validação também asegura que os datos JSON se ajusten a a estrutura esperada. Uma API pode devolver JSON válido mas com campos requeridos faltantes, tipos de datos incorrectos o valores fora de rangos aceitáveis. A validação com Schema resolve estes problemas estructurales.

Regras de sintaxe JSON

Antes de profundizar nas ferramentas de validação, é crucial compreender as regras que fazem que JSON seja válido. JSON tem uma sintaxe estricta definida por RFC 8259, e inclusive uma violação de um solo carácter pode invalidar todo o documento.

As cadenas devem usar comillas doveis

Todos os valores de cadena e as claves de objeto devem estar entre comillas doveis. As comillas simples no são um delimitador de cadena JSON válido, um error comum dois desenvolvedores que vêm de JavaScript.

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

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

As claves de objeto devem levar comillas

A diferença dois literales de objeto de JavaScript, JSON requer que todas as claves de objeto estén entre comillas doveis. As claves sem comillas são um error de sintaxe.

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

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

No se permitem comas finales

JSON no permite comas depois do último elemento de um objeto o array. Este é outro error comum, especialmente ao editar JSON manualmente.

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

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

No se admitem comentarios

JSON no soporta comentarios. Nem os comentarios de uma única linha // nem os de múltiples linhas /* */ são válidos em JSON. Se necessitas documentação, usa um arquivo separado o formatos como JSONC.

Erros comuns de validação JSON

Compreender os erros mais comuns te ajuda a detectarlos e solucionarlos rápidamente. Aquí estão os erros que encontrarás com mais frecuencia:

• Token inesperado: Generalmente causado por comillas simples, claves sem comillas o comas finales. O mensaje de error inclui a ubicação onde falló o análisis.
• Fin inesperado de a entrada JSON: A cadena JSON está incompleta o vazia. Isto ocurre frequentemente quando as requisições de red devolvem uma respuesta vazia.
• Carácter no espaço em branco inesperado: Conteúdo extra depois do valor JSON principal, como um segundo objeto no envolvido em um array.
• Número inválido: Números com ceros a a izquierda (exceto 0 solo), notação hexadecimal o valores NaN/Infinity no são JSON válido.

Validar JSON em JavaScript

A forma mais simple de validar JSON em JavaScript é envolver JSON.parse() em um bloque try-catch. Se o JSON é inválido, o método lanza um 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 em Python

Python proporciona o módulo json com json.loads() para analizar cadenas JSON. Similar a JavaScript, o JSON inválido genera um json.JSONDecodeError com informação detalhada de ubicação.

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}

Validação com JSON Schema

A validação sintáctica solo te diz se o JSON está bem formado. JSON Schema te permite definir a estrutura esperada e validar os datos contra ela. Os Schemas especifican campos requeridos, tipos de datos, rangos de valores, patrones de cadena e estruturas 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 }
  }
}

Os validadores JSON Schema populares incluem Ajv para JavaScript, jsonschema para Python e json-schema-validator para Java. Estas bibliotecas validan datos JSON contra tua Schema e generan mensajes de error detalhados para cada violação.

Ferramentas de validação JSON online

Quando necessitas verificar rápidamente um documento JSON sem escrever código, os validadores online são a opção mais rápida. Proporcionam retroalimentação instantánea com resaltado de erros e números de linha.

Melhores práticas de validação JSON

• Valida temprano: Verifica o JSON nos límites do sistema (como endpoints API e funções de importação de arquivos) antes de que os datos ingresen a a lógica de negócio.
• Usa validação com Schema: Mais lá de a sintaxe, usa JSON Schema para validar a estrutura de datos, detectando campos faltantes, tipos incorrectos e valores fora de rango.
• Proporciona mensajes de error claros: Quando a validação falha, inclui a ruta do campo, o tipo esperado e o valor real para ajudar a os usuarios a corregir problemas rápidamente.
• Valida tanto no cliente como no servidor: A validação do lado do cliente proporciona retroalimentação instantánea, enquanto que a validação do lado do servidor asegura a segurança e integridade dois dados.
• Automatiza a validação em CI/CD: Usa ferramentas como ajv-cli o jsonschema para validar arquivos de experimenta JSON e arquivos de configuração em tua pipeline de construção.
• Registra os erros de validação: Registra os fallos de validação com contexto para identificar patrones e corregir as causas raíz nos productores de datos.