Erros de Validação JSON: Guia Completo de Solução de Problemas

Erros de validação JSON podem ser frustrantes e demorados para depurar. Seja lidando com respostas de API, arquivos de configuração ou trocas de dados, entender erros comuns de JSON e como corrigi-los é essencial para todo desenvolvedor.

Entendendo a Validação JSON

A validação JSON garante que sua estrutura de dados siga a sintaxe e regras de formatação corretas do JSON. JSON inválido pode causar:

• Falhas de análise em aplicações
• Rejeições de requisições de API
• Erros de carregamento de configuração
• Corrupção de dados durante a transferência
• Falhas de aplicação em produção

Erros de Validação JSON Mais Comuns

1. Erros de Sintaxe

Vírgulas Finais

Um dos erros de JSON mais frequentes:

// ❌ INVÁLIDO - Vírgula final
{
  "name": "John",
  "age": 30,
}

// ✅ VÁLIDO - Sem vírgula final
{
  "name": "John",
  "age": 30
}

Aspas Faltando

O JSON exige aspas duplas ao redor de todas as strings:

// ❌ INVÁLIDO - Chaves sem aspas e aspas simples
{
  name: 'John',
  age: 30
}

// ✅ VÁLIDO - Aspas duplas obrigatórias
{
  "name": "John",
  "age": 30
}

Colchetes/Chaves Não Fechados

Colchetes não correspondentes causam falhas de análise:

// ❌ INVÁLIDO - Chave de fechamento ausente
{
  "users": [
    {"name": "John"},
    {"name": "Jane"}
  
// ✅ VÁLIDO - Devidamente fechado
{
  "users": [
    {"name": "John"},
    {"name": "Jane"}
  ]
}

2. Erros de Tipo de Dados

Valores Inválidos

O JSON tem regras estritas sobre valores válidos:

// ❌ INVÁLIDO - undefined, funções, comentários
{
  "name": "John",
  "age": undefined,           // Use null em vez disso
  "callback": function() {},  // Funções não permitidas
  // "comment": "not allowed" // Comentários não suportados
}

// ✅ VÁLIDO - Valores JSON adequados
{
  "name": "John",
  "age": null,
  "isActive": true
}

Problemas de Formato Numérico

Os números do JSON devem seguir regras específicas de formato:

// ❌ INVÁLIDO - Vários problemas de formato numérico
{
  "decimal": .5,        // Deve começar com dígito
  "hex": 0xFF,          // Hex não suportado
  "octal": 0777,        // Octal não suportado
  "infinity": Infinity  // Infinity não suportado
}

// ✅ VÁLIDO - Formatos numéricos adequados
{
  "decimal": 0.5,
  "integer": 255,
  "negative": -42,
  "scientific": 1.23e10
}

3. Erros de Estrutura

Chaves Duplicadas

Embora alguns analisadores permitam chaves duplicadas, isso é JSON inválido:

// ❌ INVÁLIDO - Chaves duplicadas
{
  "name": "John",
  "age": 30,
  "name": "Jane"  // Chave duplicada
}

// ✅ VÁLIDO - Chaves únicas
{
  "firstName": "John",
  "lastName": "Doe",
  "age": 30
}

Aninhamento Inadequado

O JSON tem limites de profundidade de aninhamento e estrutura:

// ❌ PROBLEMÁTICO - Aninhado profundamente demais
{
  "level1": {
    "level2": {
      "level3": {
        "level4": {
          "level5": {
            // ... continua além dos limites práticos
          }
        }
      }
    }
  }
}

// ✅ MELHOR - Estrutura mais plana
{
  "user": {
    "id": 123,
    "profile": {
      "name": "John",
      "preferences": ["dark-mode", "notifications"]
    }
  }
}

Problemas Avançados de Validação

Problemas de Codificação de Caracteres

Problemas de Codificação Comuns:

// ❌ PROBLEMÁTICO - Caracteres especiais
{
  "name": "José",           // Pode causar problemas em alguns sistemas
  "emoji": "😀",           // Emojis podem ser problemáticos
  "currency": "€100"       // Símbolos de moeda
}

// ✅ MAIS SEGURO - Unicode escapado
{
  "name": "Jos\u00e9",
  "emoji": "😀",
  "currency": "\u20ac100"
}

Validação de Dados Grandes

Considerações de Desempenho:

{
  "metadata": {
    "size": "large",
    "validation": {
      "strategy": "streaming",
      "chunkSize": 1024,
      "timeout": 30000
    }
  },
  "data": {
    "note": "Large arrays should be validated in chunks"
  }
}

Mensagens de Erro e Depuração

Mensagens de Erro Comuns de Analisadores

1. Erros de "Unexpected token"

Erro: Unexpected token ',' at position 25 Causa: Geralmente vírgulas finais ou pontuação mal posicionada Correção: Verifique vírgulas extras, ponto e vírgula ou outra pontuação

2. "Unexpected end of JSON input"

Erro: Unexpected end of JSON input Causa: Estrutura JSON incompleta, colchetes de fechamento ausentes Correção: Verifique se todos os colchetes e chaves estão devidamente fechados

3. Erros de "Invalid character"

Erro: Invalid character at position 15 Causa: Caracteres inválidos como caracteres de controle ou aspas erradas Correção: Verifique caracteres invisíveis, tipos de aspas errados

Estratégias de Depuração

1. Validação Linha por Linha

// Abordagem de depuração em JavaScript
function validateJSONSteps(jsonString) {
  try {
    JSON.parse(jsonString);
    console.log("✅ Valid JSON");
  } catch (error) {
    console.error("❌ Invalid JSON:", error.message);
    
    // Encontre a localização aproximada do erro
    const lines = jsonString.split('\n');
    const errorPosition = extractPosition(error.message);
    
    if (errorPosition) {
      console.log(`Error near position ${errorPosition}`);
    }
  }
}

2. Construção Incremental

// Comece simples e construa gradualmente
{
  "step1": "basic object"
}

// Adicione complexidade gradualmente
{
  "step1": "basic object",
  "step2": {
    "nested": "object"
  }
}

// Continue até encontrar o erro
{
  "step1": "basic object",
  "step2": {
    "nested": "object"
  },
  "step3": [
    "array",
    "elements"
  ]
}

Validação de Esquema

Noções Básicas de JSON Schema

O JSON Schema fornece validação estrutural além da sintaxe:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 100
    },
    "age": {
      "type": "integer",
      "minimum": 0,
      "maximum": 150
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  },
  "required": ["name", "email"],
  "additionalProperties": false
}

Erros de Validação de Esquema

Problemas comuns de validação de esquema:

// ❌ Falhas de validação de esquema
{
  "name": "",           // Muito curto (minLength: 1)
  "age": -5,            // Abaixo do mínimo (minimum: 0)
  "email": "invalid",   // Formato de email inválido
  "extra": "property"   // Não permitido (additionalProperties: false)
}

// ✅ Compatível com esquema
{
  "name": "John Doe",
  "age": 30,
  "email": "john@example.com"
}

Testes e Prevenção

Testes Automatizados de Validação

// Exemplo de suíte de testes para validação JSON
const testCases = [
  {
    name: "Valid user object",
    json: '{"name": "John", "age": 30}',
    expectValid: true
  },
  {
    name: "Trailing comma",
    json: '{"name": "John", "age": 30,}',
    expectValid: false
  },
  {
    name: "Single quotes",
    json: "{'name': 'John', 'age': 30}",
    expectValid: false
  }
];

testCases.forEach(test => {
  const isValid = isValidJSON(test.json);
  console.assert(
    isValid === test.expectValid,
    `Test failed: ${test.name}`
  );
});

Melhores Práticas para Prevenção

Ferramentas e Recursos

Ferramentas de Validação

Validadores Online:

• JSON Validator - Validação abrangente com detalhes de erro
• JSON Formatter - Formate e valide simultaneamente
• JSONLint - Validador online popular

Ferramentas de Linha de Comando:

# Usando jq para validação
echo '{"valid": "json"}' | jq .

# Usando Python
python -m json.tool file.json

# Usando Node.js
node -e "JSON.parse(require('fs').readFileSync('file.json'))"

Extensões de Editor:

• VS Code: Validação JSON integrada
• Sublime Text: Pacote JSON Reindent
• Vim: Plugins JSON com validação

Integração no Desenvolvimento

Regras do ESLint

// .eslintrc.js
module.exports = {
  rules: {
    'json/*': ['error', 'allowComments']
  }
};

Hooks Pré-Commit

#!/bin/sh
# Valide todos os arquivos JSON antes do commit
find . -name "*.json" -exec python -m json.tool {} \; > /dev/null

Lista de Verificação para Solução de Problemas

Passos Rápidos de Diagnóstico

1. Verifique os básicos de sintaxe:

   • Todas as strings em aspas duplas
   • Sem vírgulas finais
   • Colchetes e chaves correspondentes
   • Sequências de escape válidas

2. Valide tipos de dados:

   • Sem valores undefined
   • Sem funções ou comentários
   • Formatos numéricos adequados
   • Valores booleanos são true/false

3. Teste a estrutura:

   • Sem chaves duplicadas
   • Profundidade de aninhamento razoável
   • Caracteres Unicode válidos

4. Use ferramentas de validação:

   • Validador JSON online
   • Verificação de linha de comando
   • Validação de esquema, se aplicável

Estratégias de Recuperação

Quando o JSON Está Corrompido

// Tente recuperar JSON malformado
function attemptJSONRecovery(malformedJSON) {
  const fixes = [
    // Remova vírgulas finais
    json => json.replace(/,(\s*[}\]])/g, '$1'),
    
    // Corrija aspas simples
    json => json.replace(/'/g, '"'),
    
    // Adicione aspas ausentes às chaves
    json => json.replace(/(\w+):/g, '"$1":'),
  ];
  
  for (const fix of fixes) {
    try {
      const fixed = fix(malformedJSON);
      JSON.parse(fixed);
      return fixed; // Sucesso!
    } catch (e) {
      continue; // Tente a próxima correção
    }
  }
  
  throw new Error('Unable to recover JSON');
}

Conclusão

Erros de validação JSON são comuns, mas podem ser evitados com o conhecimento e ferramentas adequadas. Ao entender os padrões de erro mais frequentes, implementar fluxos de trabalho de validação adequados e usar técnicas de depuração apropriadas, você pode reduzir drasticamente os problemas relacionados a JSON em seus projetos.

Lembre-se: Prevenção é melhor que depuração. Implemente validação no início do seu processo de desenvolvimento e use ferramentas automatizadas para capturar erros antes que cheguem à produção.

Precisa de ajuda para validar seu JSON? Experimente nossa Ferramenta de Validador JSON para análise detalhada de erros e sugestões.