Trabalhando com JSON em TypeScript: parsing e serialização de dados

Introdução

JSON (JavaScript Object Notation) é um formato leve de troca de dados, amplamente utilizado no desenvolvimento web para transmitir informações entre o cliente e o servidor. TypeScript, sendo um superconjunto estritamente tipado de JavaScript, fornece ferramentas poderosas para trabalhar com JSON de forma segura e conveniente. Neste artigo, veremos detalhadamente como realizar parsing e serialização de JSON em TypeScript, usar tipos para garantir a correção dos dados e evitar erros típicos.

O trabalho correto com JSON é criticamente importante para criar aplicações confiáveis e escaláveis. TypeScript permite não apenas transformar strings JSON em objetos e vice-versa, mas também garantir que a estrutura e os tipos de dados correspondam ao esperado. Isso é especialmente útil ao trabalhar com APIs, arquivos de configuração e bancos de dados.

Fundamentos do parsing de JSON em TypeScript

Parsing de JSON é o processo de converter uma string JSON em um objeto TypeScript. Para isso, utiliza-se o método global JSON.parse(). No entanto, ao contrário do JavaScript, no TypeScript podemos especificar o tipo esperado do resultado, o que torna o código mais previsível.

Parsing simples sem tipos

Exemplo básico de parsing de uma string JSON:

const jsonString = '{"name": "Анна", "age": 30, "city": "Москва"}';
const user = JSON.parse(jsonString);
console.log(user.name); // "Анна"

Neste caso, o TypeScript inferirá o tipo any para a variável user, o que reduz a segurança de tipos. É melhor usar a especificação explícita de tipo.

Parsing com especificação de tipo via interface

A abordagem mais correta é definir uma interface e usá-la durante o parsing:

interface User {
  name: string;
  age: number;
  city: string;
}

const jsonString = '{"name": "Анна", "age": 30, "city": "Москва"}';
const user: User = JSON.parse(jsonString);
console.log(user.name); // TypeScript sabe que é string

Essa abordagem permite que a IDE forneça autocompletar e verifique os tipos em tempo de compilação.

Tratamento de erros de parsing

Strings JSON podem ser inválidas, por isso é importante tratar exceções:

function safeParseJSON<T>(json: string): T | null {
  try {
    return JSON.parse(json) as T;
  } catch (error) {
    console.error('Erro ao fazer parsing do JSON:', error);
    return null;
  }
}

const invalidJson = '{"name": "Анна", age: 30}'; // JSON inválido
const result = safeParseJSON<User>(invalidJson);
if (result) {
  console.log(result.name);
} else {
  console.log('Não foi possível fazer o parsing do JSON');
}

A função safeParseJSON aceita um parâmetro genérico, permitindo reutilizá-la para diferentes tipos de dados.

Serialização de objetos em JSON

Serialização é o processo inverso de converter um objeto TypeScript em uma string JSON. Para isso, utiliza-se o método JSON.stringify(). TypeScript não adiciona novas funcionalidades a este método, mas ajuda a controlar quais dados entram na string final.

Serialização básica

const user: User = {
  name: "Иван",
  age: 25,
  city: "Санкт-Петербург"
};

const jsonString = JSON.stringify(user);
console.log(jsonString); // {"name":"Иван","age":25,"city":"Санкт-Петербург"}

Uso de replacer para filtrar campos

O segundo parâmetro de JSON.stringify() é uma função replacer, que permite controlar quais campos incluir no resultado:

const jsonStringFiltered = JSON.stringify(user, (key, value) => {
  if (key === 'age') {
    return undefined; // Exclui o campo age
  }
  return value;
});
console.log(jsonStringFiltered); // {"name":"Иван","city":"Санкт-Петербург"}

Isso é útil quando é necessário ocultar dados sensíveis ou reduzir o tamanho da informação transmitida.

Formatação com space