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

Os erros de validação JSON podem ser frustrantes e demorados de depurar. Seja ao lidar com respostas de API, ficheiros de configuração ou trocas de dados, compreender os erros JSON comuns e como corrigi-los é essencial para todo o programador.

Compreender a Validação JSON

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

• Falhas de parsing em aplicações
• Rejeições de pedidos API
• Erros de carregamento de configuração
• Corrupção de dados durante a transferência
• Falhas de aplicação em produção

Os Erros de Validação JSON Mais Comuns

1. Erros de Sintaxe

Vírgulas Finais

Um dos erros JSON mais frequentes:

// ❌ INVALID - Trailing comma
{
  "name": "John",
  "age": 30,
}

// ✅ VALID - No trailing comma
{
  "name": "John",
  "age": 30
}

Aspas em Falta

O JSON requer aspas duplas à volta de todas as strings:

// ❌ INVALID - Unquoted keys and single quotes
{
  name: 'John',
  age: 30
}

// ✅ VALID - Double quotes required
{
  "name": "John",
  "age": 30
}

Parênteses Colchetes/Chaves Não Fechados

Parênteses colchetes desequilibrados causam falhas de parsing:

// ❌ INVALID - Missing closing brace
{
  "users": [
    {"name": "John"},
    {"name": "Jane"}
  
// ✅ VALID - Properly closed
{
  "users": [
    {"name": "John"},
    {"name": "Jane"}
  ]
}

2. Erros de Tipo de Dados

Valores Inválidos

O JSON tem regras estritas sobre valores válidos:

// ❌ INVALID - undefined, functions, comments
{
  "name": "John",
  "age": undefined,           // Use null instead
  "callback": function() {},  // Functions not allowed
  // "comment": "not allowed" // Comments not supported
}

// ✅ VALID - Proper JSON values
{
  "name": "John",
  "age": null,
  "isActive": true
}

Problemas de Formato Numérico

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

// ❌ INVALID - Various number format issues
{
  "decimal": .5,        // Must start with digit
  "hex": 0xFF,          // Hex not supported
  "octal": 0777,        // Octal not supported
  "infinity": Infinity  // Infinity not supported
}

// ✅ VALID - Proper number formats
{
  "decimal": 0.5,
  "integer": 255,
  "negative": -42,
  "scientific": 1.23e10
}

3. Erros de Estrutura

Chaves Duplicadas

Embora alguns parsers permitam chaves duplicadas, trata-se de JSON inválido:

// ❌ INVALID - Duplicate keys
{
  "name": "John",
  "age": 30,
  "name": "Jane"  // Duplicate key
}

// ✅ VALID - Unique keys
{
  "firstName": "John",
  "lastName": "Doe",
  "age": 30
}

Aninhamento Indevido

O JSON tem limites na profundidade de aninhamento e estrutura:

// ❌ PROBLEMATIC - Too deeply nested
{
  "level1": {
    "level2": {
      "level3": {
        "level4": {
          "level5": {
            // ... continues beyond practical limits
          }
        }
      }
    }
  }
}

// ✅ BETTER - Flatter structure
{
  "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:

// ❌ PROBLEMATIC - Special characters
{
  "name": "José",           // May cause issues in some systems
  "emoji": "😀",           // Emoji can be problematic
  "currency": "€100"       // Currency symbols
}

// ✅ SAFER - Escaped Unicode
{
  "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 de Parser Comuns

1. Erros de "Token Inesperado"

Erro: Unexpected token ',' at position 25 Causa: Normalmente vírgulas finais ou pontuação mal colocada Correção: Verifique vírgulas extra, pontos e vírgulas ou outra pontuação

2. "Fim Inesperado da Entrada JSON"

Erro: Unexpected end of JSON input Causa: Estrutura JSON incompleta, parênteses colchetes de fecho em falta Correção: Verifique se todos os parênteses colchetes e chaves estão devidamente fechados

3. Erros de "Carácter Inválido"

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

Estratégias de Depuração

1. Validação Linha a Linha

// JavaScript debugging approach
function validateJSONSteps(jsonString) {
  try {
    JSON.parse(jsonString);
    console.log("✅ Valid JSON");
  } catch (error) {
    console.error("❌ Invalid JSON:", error.message);
    
    // Find approximate error location
    const lines = jsonString.split('\n');
    const errorPosition = extractPosition(error.message);
    
    if (errorPosition) {
      console.log(`Error near position ${errorPosition}`);
    }
  }
}

2. Construção Incremental

// Start simple and build up
{
  "step1": "basic object"
}

// Add complexity gradually
{
  "step1": "basic object",
  "step2": {
    "nested": "object"
  }
}

// Continue until error is found
{
  "step1": "basic object",
  "step2": {
    "nested": "object"
  },
  "step3": [
    "array",
    "elements"
  ]
}

Validação de Schema

Fundamentos do JSON Schema

O JSON Schema fornece validação estrutural para 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 Schema

Problemas comuns de validação de schema:

// ❌ Schema validation failures
{
  "name": "",           // Too short (minLength: 1)
  "age": -5,            // Below minimum (minimum: 0)
  "email": "invalid",   // Invalid email format
  "extra": "property"   // Not allowed (additionalProperties: false)
}

// ✅ Schema compliant
{
  "name": "John Doe",
  "age": 30,
  "email": "john@example.com"
}

Testes e Prevenção

Testes Automatizados de Validação

// Example test suite for JSON validation
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 - Formatação e validação simultâneas
• JSONLint - Validador online popular

Ferramentas de Linha de Comandos:

# Using jq for validation
echo '{"valid": "json"}' | jq .

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

# Using 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 ESLint

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

Hooks Pré-Commit

#!/bin/sh
# Validate all JSON files before commit
find . -name "*.json" -exec python -m json.tool {} \; > /dev/null

Lista de Verificação de Resolução de Problemas

Passos de Diagnóstico Rápido

1. Verifique os básicos de sintaxe:

   • Todas as strings entre aspas duplas
   • Sem vírgulas finais
   • Parênteses colchetes e chaves equilibrados
   • 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. Utilize ferramentas de validação:

   • Validador JSON online
   • Verificação de linha de comandos
   • Validação de schema se aplicável

Estratégias de Recuperação

Quando o JSON Está Corrompido

// Attempt to recover malformed JSON
function attemptJSONRecovery(malformedJSON) {
  const fixes = [
    // Remove trailing commas
    json => json.replace(/,(\s*[}\]])/g, '$1'),
    
    // Fix single quotes
    json => json.replace(/'/g, '"'),
    
    // Add missing quotes to keys
    json => json.replace(/(\w+):/g, '"$1":'),
  ];
  
  for (const fix of fixes) {
    try {
      const fixed = fix(malformedJSON);
      JSON.parse(fixed);
      return fixed; // Success!
    } catch (e) {
      continue; // Try next fix
    }
  }
  
  throw new Error('Unable to recover JSON');
}

Conclusão

Os erros de validação JSON são comuns, mas evitáveis com o conhecimento e ferramentas adequados. Ao compreender os padrões de erro mais frequentes, implementar fluxos de trabalho de validação adequados e utilizar técnicas de depuração apropriadas, pode reduzir drasticamente os problemas relacionados com JSON nos seus projetos.

Lembre-se: A prevenção é melhor do que a depuração. Implemente a validação no início do seu processo de desenvolvimento e utilize ferramentas automatizadas para detetar erros antes de chegarem à produção.

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