O que é JSON e como você o usa?

Publicados: 2022-08-14
Imagem do texto "JSON" sobreposto em um monitor de computador
Maria Vonotna/Shutterstock.com

JSON (JavaScript Object Notation) é um formato padronizado para representar dados estruturados. Embora o JSON tenha surgido da linguagem de programação JavaScript, agora é um método onipresente de troca de dados entre sistemas. A maioria das APIs modernas aceita solicitações JSON e emite respostas JSON, por isso é útil ter um bom conhecimento prático do formato e de seus recursos.

Neste artigo, explicaremos o que é JSON, como ele expressa diferentes tipos de dados e as maneiras de produzi-lo e consumi-lo em linguagens de programação populares. Também abordaremos algumas das limitações do JSON e as alternativas que surgiram.

Noções básicas de JSON

O JSON foi originalmente concebido por Douglas Crockford como um formato sem estado para comunicação de dados entre navegadores e servidores. No início dos anos 2000, os sites estavam começando a buscar dados extras de forma assíncrona de seu servidor, após o carregamento inicial da página. Como um formato baseado em texto derivado do JavaScript, o JSON simplificou a busca e o consumo de dados nesses aplicativos. A especificação acabou sendo padronizada como ECMA-404 em 2013.

JSON é sempre transmitido como uma string. Essas strings podem ser decodificadas em uma variedade de tipos de dados básicos, incluindo números, booleanos, matrizes e objetos. Isso significa que hierarquias e relacionamentos de objetos podem ser preservados durante a transmissão e, em seguida, remontados na extremidade receptora de uma maneira apropriada para o ambiente de programação.

Um exemplo básico de JSON

Esta é uma representação JSON de uma postagem de blog: 

 {
    "id": 1001,
    "title": "O que é JSON?",
    "autor": {
        "id": 1,
        "nome": "James Walker"
    },
    "tags": ["api", "json", "programação"],
    "publicado": falso,
    "publishedTimestamp": null
}

Este exemplo demonstra todos os tipos de dados JSON. Ele também ilustra a concisão dos dados formatados em JSON, uma das características que os torna tão atraentes para uso em APIs. Além disso, o JSON é relativamente fácil de ler como está, ao contrário de formatos mais detalhados, como XML.

Tipos de dados JSON

Seis tipos de dados podem ser representados nativamente em JSON:

  • Strings – Strings são escritas entre aspas duplas; caracteres podem ser escapados usando barras invertidas.
  • Números – Os números são escritos como dígitos sem aspas. Você pode incluir um componente fracionário para denotar um float. A maioria das implementações de análise JSON assume um número inteiro quando não há ponto decimal presente.
  • Booleanos – Os valores literais true e false são suportados.
  • Nulo – O valor literal null pode ser usado para significar um valor vazio ou omitido.
  • Arrays – Um array é uma lista simples denotada por colchetes. Cada elemento na lista é separado por uma vírgula. As matrizes podem conter qualquer número de itens e podem usar todos os tipos de dados suportados.
  • Objetos – Os objetos são criados por chaves. Eles são uma coleção de pares chave-valor em que as chaves são strings, entre aspas duplas. Cada chave tem um valor que pode receber qualquer um dos tipos de dados disponíveis. Você pode aninhar objetos para criar hierarquias em cascata. Uma vírgula deve seguir cada valor, significando o fim desse par chave-valor.

Os analisadores JSON convertem automaticamente esses tipos de dados em estruturas apropriadas ao seu idioma. Você não precisa converter manualmente o id para um inteiro, por exemplo. A análise de toda a string JSON é suficiente para mapear os valores de volta ao formato de dados original.

Semântica e Validação

O JSON tem certas regras que precisam ser respeitadas ao codificar seus dados. Strings que não aderem à sintaxe não poderão ser analisadas pelos consumidores.

É particularmente importante prestar atenção às aspas em torno de strings e chaves de objeto. Você também deve garantir que uma vírgula seja usada após cada entrada em um objeto ou array. O JSON não permite uma vírgula à direita após a última entrada - incluir involuntariamente uma é uma causa comum de erros de validação. A maioria dos editores de texto destacará problemas de sintaxe para você, ajudando a descobrir erros.

Apesar desses pontos de viagem comuns, o JSON é um dos formatos de dados mais fáceis de escrever à mão. A maioria das pessoas acha a sintaxe rápida e conveniente quando se familiariza com ela. Em geral, o JSON tende a ser menos propenso a erros do que o XML, onde tags de abertura e fechamento incompatíveis, declarações de esquema inválidas e problemas de codificação de caracteres geralmente causam problemas.

Designando conteúdo JSON

A extensão .json é normalmente usada quando JSON é salvo em um arquivo. O conteúdo JSON tem o tipo MIME padronizado application/json , embora text/json às vezes seja usado por motivos de compatibilidade. Hoje em dia você deve confiar em application/json para cabeçalhos HTTP Accept e Content-Type .

A maioria das APIs que usam JSON encapsulará tudo em um objeto de nível superior: 

 {
    "erro": 1000
}

No entanto, isso não é necessário – um tipo literal é válido como o nó de nível superior em um arquivo, portanto, os exemplos a seguir também são JSON válidos: 

 1000 
 verdadeiro 
 nulo

Eles vão decodificar para seus respectivos escalares em sua linguagem de programação.

Trabalhando com JSON

A maioria das linguagens de programação tem suporte JSON integrado. Veja como interagir com dados JSON em alguns ambientes populares.

JavaScript

Em JavaScript, os JSON.stringify() e JSON.parse() são usados ​​para codificar e decodificar strings JSON: 

 post const = {
    código : 1001 ,
    title : "O que é JSON?" ,
    autor : {
        identificação : 1 ,
        nome : "James Walker"
    }
} ;

const codificadoJson = JSON. stringify ( post ) ;

// {"id": 1001, "title": "O que é JSON?", ...}
console. log ( encodedJson ) ;

const decodificadoJson = JSON. parse ( encodedJson ) ;

// James Walker
console. log ( decodedJson. autor . nome ) ;

PHP

As funções equivalentes em PHP são json_encode() e json_decode() : 

 $postagem = [
    "id" => 1001 ,
    "title" => "O que é JSON?" ,
    "autor" => [
        "id" => 1 ,
        "nome" => "James Walker"
    ]
] ;

$encodedJson = json_encode ( $post ) ;

// {"id": 1001, "title": "O que é JSON?", ...}
echo $encodedJson ;

$decodedJson = json_decode ( $encodedJson , true ) ;

// James Walker
echo $decodedJson [ "autor" ] [ "nome" ] ;

Pitão

Python fornece json.dumps() e json.loads() para serializar e desserializar respectivamente: 

 importar json

posto = {
    "id" : 1001 ,
    "title" : "O que é JSON?" ,
    "autor" : {
        "id" : 1 ,
        "nome" : "James Walker"
    }
}

codificadoJson = json. despejos ( post )

# {"id": 1001, "title": "O que é JSON?", ...}
print ( encodedJson )

decodificadoJson = json. carrega ( encodedJson )

#James Walker
print ( decodedJson [ "autor" ] [ "nome" ] )

Rubi

Ruby oferece JSON.generate e JSON.parse : 

 requer "json"

posto = {
    "id" => 1001 ,
    "title" => "O que é JSON?" ,
    "autor" => {
        "id" => 1 ,
        "nome" => "James Walker"
    }
}

codificadoJson = JSON. gerar ( postar )

# {"id": 1001, "title": "O que é JSON?", ...}
coloca codificadoJson

decodificadoJson = JSON. parse ( encodedJson )

#James Walker
puts decodedJson [ "autor" ] [ "nome" ]

Limitações de JSON

JSON é um formato leve que se concentra em transmitir os valores dentro de sua estrutura de dados. Isso torna a análise rápida e fácil de trabalhar, mas significa que há desvantagens que podem causar frustração. Aqui estão alguns dos maiores problemas.

Sem comentários

Os dados JSON não podem incluir comentários. A falta de anotações reduz a clareza e força você a colocar a documentação em outro lugar. Isso pode tornar o JSON inadequado para situações como arquivos de configuração, onde as modificações não são frequentes e os propósitos dos campos podem não ser claros.

Sem esquemas

O JSON não permite definir um esquema para seus dados. Não há como impor que id seja um campo inteiro obrigatório, por exemplo. Isso pode levar a estruturas de dados malformadas involuntariamente.

Sem referências

Os campos não podem referenciar outros valores na estrutura de dados. Isso geralmente causa repetição que aumenta o tamanho do arquivo. Voltando ao exemplo de postagem de blog anterior, você pode ter uma lista de postagens de blog da seguinte forma: 

 {
    "Postagens": [
        {
            "id": 1001,
            "title": "O que é JSON?",
            "autor": {
                "id": 1,
                "nome": "James Walker"
            }
        },
        {
            "id": 1002,
            "title": "O que é SaaS?",
            "autor": {
                "id": 1,
                "nome": "James Walker"
            }
        }
    ]
}

Ambas as postagens têm o mesmo autor, mas as informações associadas a esse objeto tiveram que ser duplicadas. Em um mundo ideal, as implementações do analisador JSON seriam capazes de produzir a estrutura mostrada acima a partir de uma entrada semelhante à seguinte: 

 {
    "Postagens": [
        {
            "id": 1001,
            "title": "O que é JSON?",
            "autor": "{{ .autores.james }}"
        },
        {
            "id": 1002,
            "title": "O que é SaaS?",
            "autor": "{{ .autores.james }}"
        }
    ],
    "autores": {
        "James": {
            "id": 1,
            "nome": "James Walker"
        }
    }
}

No momento, isso não é possível com JSON padrão.

Nenhum tipo de dados avançado

Os seis tipos de dados suportados omitem muitos tipos comuns de valor. O JSON não pode armazenar datas, horas ou pontos de geolocalização nativamente, portanto, você precisa decidir seu próprio formato para essas informações.

Isso causa discrepâncias inconvenientes e casos extremos. Se seu aplicativo lida com timestamps como strings, como 2022-07-01T12:00:00+00:00 , mas uma API externa apresenta o tempo como segundos após a época do Unix – 1657287000 – você precisará lembrar quando usar cada um dos formatos.

Alternativas JSON

YAML é a principal alternativa JSON. É um superconjunto do formato que possui uma apresentação mais legível, tipos de dados personalizados e suporte para referências. Destina-se a abordar a maioria dos desafios de usabilidade associados ao JSON.

O YAML teve ampla adoção para arquivos de configuração e dentro de DevOps, IaC e ferramentas de observabilidade. É usado com menos frequência como formato de troca de dados para APIs. A relativa complexidade do YAML significa que é menos acessível aos recém-chegados. Pequenos erros de sintaxe podem causar falhas de análise confusas.

Os buffers de protocolo (protobufs) são outro concorrente JSON emergente projetado para serializar dados estruturados. Protobufs têm declarações de tipo de dados, campos obrigatórios e suporte para a maioria das principais linguagens de programação. O sistema está ganhando popularidade como uma forma mais eficiente de transmissão de dados em redes.

Resumo

JSON é um formato de representação de dados baseado em texto que pode codificar seis tipos de dados diferentes. O JSON se tornou um elemento básico do ecossistema de desenvolvimento de software; é suportado por todas as principais linguagens de programação e se tornou a escolha padrão para a maioria das APIs REST desenvolvidas nas últimas duas décadas.

Embora a simplicidade do JSON seja parte de sua popularidade, ela também impõe limitações ao que você pode alcançar com o formato. A falta de suporte para esquemas, comentários, referências de objetos e tipos de dados personalizados significa que alguns aplicativos descobrirão que superam o que é possível com JSON. Alternativas mais jovens, como YAML e Protobuf, ajudaram a enfrentar esses desafios, enquanto o XML continua sendo um concorrente para aplicativos que desejam definir um esquema de dados e não se importam com a verbosidade.