Validador JSON

O que é Validação JSON?

JSON (JavaScript Object Notation) é um formato leve para troca de dados amplamente utilizado, projetado para ser legível por humanos e fácil de interpretar e gerar por máquinas. Seu propósito principal é representar dados estruturados — objetos, arrays, strings, números, booleanos e nulos — de forma independente da linguagem.

A validação de JSON é o processo de verificar programaticamente se um documento JSON está correto tanto sintaticamente quanto estruturalmente. Isso envolve a verificação de dois aspectos principais:

• Validação Sintática: Garantir que o texto bruto siga a gramática formal conforme definido pela especificação ECMA-404 JSON. Analisadores sintáticos na maioria das linguagens de programação modernas (por exemplo, JSON.parse() em JavaScript, json.loads() em Python, JSONDecoder em Java) esperam uma sintaxe válida e lançarão erros caso a entrada esteja malformada.
• Validação Estrutural (Schema): Além da sintaxe, a validação de esquema verifica se os dados JSON correspondem a uma estrutura esperada, incluindo tipos de dados, propriedades obrigatórias, restrições de valor e objetos/arrays aninhados. A validação de esquema é geralmente realizada usando JSON Schema, que define regras para determinar quais dados são considerados válidos.

Por que Validar JSON?

A validação de JSON é fundamental sempre que dados são serializados para transmissão, armazenamento ou comunicação entre serviços. As principais razões incluem:

• Prevenção de Erros: Detecte e reporte erros de sintaxe (por exemplo, vírgulas faltando, colchetes não fechados, caracteres ilegais) antecipadamente—antes de tentar processar os dados.
• Integridade e Segurança dos Dados: Rejeite cargas JSON malformadas ou maliciosas, ajudando a prevenir falhas no backend, ataques de injeção ou corrupção de dados.
• Segurança de Tipos: Implemente tipagem rigorosa—garantindo, por exemplo, que um campo esperado como booleano não seja enviado como string, ou que UUIDs, e-mails e números estejam no formato correto.
• Compatibilidade Multilíngue: Garanta que o JSON gerado em um ambiente (por exemplo, Node.js) seja consumido com segurança em outro (por exemplo, Python, Go, Java), evitando erros de serialização e desserialização.
• Manutenção e Robustez: Estruturas de dados validadas melhoram a rastreabilidade e reduzem o risco de erros difíceis de depurar em arquivos de configuração, logs ou requisições/respostas de API.
• Privacidade e Segurança: A validação pode ser realizada inteiramente no lado do cliente (no navegador), evitando que dados brutos ou sensíveis saiam do dispositivo do usuário para validação.

Erros Comuns de Validação JSON (com Exemplos Detalhados)

Chaves Sem Aspas

Todas as chaves em objetos JSON devem ser strings entre aspas duplas.

{ name: "Alice" }

{ "name": "Alice" }

Muitos formatos semelhantes ao JSON (por exemplo, literais de objetos JavaScript) permitem chaves sem aspas, mas o JSON padrão não permite.

Aspas Simples

Strings JSON devem usar apenas aspas duplas; aspas simples não são permitidas.

{ 'name': 'Bob' }

{ "name": "Bob" }

Usar aspas simples resultará em erros de análise em todas as bibliotecas JSON compatíveis.

Vírgulas Finais

Sem vírgula após o último item em um objeto ou array.

{
  "a": 1,
  "b": 2,
}

{
  "a": 1,
  "b": 2
}

Vírgulas finais podem funcionar em JavaScript, mas não em analisadores JSON estritos.

Escape Incorreto de Caracteres

Aspas e caracteres especiais dentro de strings devem ser escapados usando uma barra invertida.

{ "quote": "Tom disse \"olá\"" }

{ "quote": "Tom disse \"olá\"" }

Outras sequências de escape incluem \\ para a barra invertida, \n para quebras de linha e \t para tabulações.

Tipos de Dados Incorretos

Strings não devem ser usadas para números, valores booleanos ou nulos.

{ "enabled": "verdadeiro", "count": "10" }

{ "enabled": true, "count": 10 }

JSON diferencia entre booleanos, números e strings—garanta que o tipo correto seja utilizado.

Chaves Não Primitivas

As chaves de um objeto JSON devem sempre ser strings; não é possível usar números, valores booleanos ou outros tipos como chaves.

{ 123: "abc" }

{ "123": "abc" }

Chaves Duplicadas

Embora permitido pela especificação JSON, chaves duplicadas são uma fonte comum de erros.

{ "name": "Alice", "name": "Bob" }

A maioria dos analisadores manterá apenas o último valor ("Bob"), descartando silenciosamente os anteriores.

Uso de Comentários

O JSON padrão não permite comentários, embora alguns editores os suportem.

{
  // Informações do usuário
  "name": "Alice"
}

{
  "name": "Alice"
}

Validação de Schema: Aplicando Estrutura e Tipos de Dados

JSON Schema é um padrão poderoso para definir e validar a estrutura esperada de documentos JSON. Ele permite que você especifique:

• Campos obrigatórios (`required`)
• Tipos de dados (`type`: string, número, booleano, objeto, array, nulo)
• Formatos de string (`format`: email, uuid, data-hora, etc.)
• Correspondência de padrões para strings (`pattern`)
• Intervalos numéricos (`mínimo`, `máximo`)
• Validação do comprimento do array e dos itens (`minItems`, `maxItems`, `items`)
• Validação aninhada para objetos e arrays
• Restrições de enumeração (`enum`)

Exemplo: Esquema de Usuário (Rascunho-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

O que isso impõe:

• id deve ser uma string UUID válida.
• o nome deve ser uma string não vazia.
• o email deve corresponder ao formato padrão de email.
• is_active (opcional) deve ser um valor booleano.
• Nenhuma propriedade além daquelas definidas acima é permitida.

Exemplo Prático: Validando Respostas da API do Stripe

Suponha que você receba respostas JSON da API do Stripe (por exemplo, PaymentIntent). A validação de schema garante que você nunca processe dados incompletos ou com tipos incorretos.

{
  "type": "objeto",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "intencao_pagamento" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "requer_metodo_pagamento",
      "requer_confirmacao",
      "processando",
      "sucedido",
      "cancelado"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• o ID deve começar com "pi_"
• o objeto deve ser sempre "payment_intent"
• o valor deve ser um número inteiro maior ou igual a 1
• a moeda deve ser uma string de três letras (por exemplo, "usd", "eur")
• o status deve ser um dos valores especificados

Benefícios

• Detecção Precoce de Erros: Identifique mudanças críticas na API ou dados incompletos antes que afetem a lógica do seu negócio.
• Testes Automatizados: Use esquemas em pipelines de CI/CD para validar respostas reais e simuladas.
• Consistência entre equipes: Padronize contratos de dados entre frontend, backend e APIs de terceiros.

A validação adequada de JSON — abrangendo tanto a sintaxe quanto o esquema — previne erros sutis, assegura as melhores práticas e protege suas aplicações contra entradas malformadas ou maliciosas. Seja em arquivos de configuração, cargas úteis de API ou mensagens entre serviços, uma validação robusta é fundamental para sistemas de software modernos.

Privacidade e Segurança

Todas as validações e verificações de esquema são realizadas localmente no seu navegador. Nenhum dado é enviado ou registrado. Seu JSON permanece totalmente privado.

Exemplos de Código para Validação de JSON

Veja como validar JSON em várias linguagens de programação usando bibliotecas integradas ou frameworks populares. Estes exemplos demonstram tanto a validação de sintaxe quanto a validação de esquema.

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{"name":"Alice","age":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{"name":"Alice","age":30}";
    try {
      var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

Sobre esta ferramenta