100 % local — seus dados nunca saem do seu navegador

JSON para Dart — fromJson e toJson já escritos

Transforme uma amostra JSON em classes Dart. As chaves originais vivem nos fromJson e toJson gerados: o mapeamento é código que dá para ler e depurar.

Instantâneo Privado Zero cookies

Entrada JSON

Saída Dart

O que esta ferramenta faz

Uma amostra JSON vira classes Dart, cada uma com uma fábrica fromJson e um método toJson.

{ "id": 1, "firstName": "Ada", "address": { "city": "Paris" } }
class Root {
  final int id;
  final String firstName;
  final Address address;

  Root({required this.id, required this.firstName, required this.address});

  factory Root.fromJson(Map<String, dynamic> json) => Root(
        id: json['id'] as int,
        firstName: json['firstName'] as String,
        address: Address.fromJson(json['address'] as Map<String, dynamic>),
      );

  Map<String, dynamic> toJson() => <String, dynamic>{
        'id': id,
        'firstName': firstName,
        'address': address.toJson(),
      };
}

Sem build_runner, sem anotações, sem arquivo part gerado: o mapeamento está ali, à vista, e você pode mudá-lo.

A chave nunca vai embora

Um nome de campo do Dart não leva hífen nem começa por dígito, e class é reservado. Quando um nome precisa mudar, os dois sentidos guardam a chave:

  final String contentType;
  final int class_;

  factory Root.fromJson(Map<String, dynamic> json) => Root(
        contentType: json['content-type'] as String,
        class_: json['class'] as int,
      );

  Map<String, dynamic> toJson() => <String, dynamic>{
        'content-type': contentType,
        'class': class_,
      };

Como o mapeamento é código e não convenção, nada é adivinhado em execução — e você lê o que será enviado antes de enviar.

Listas e objetos aninhados

Uma lista de objetos vira uma classe à parte, e o mapeamento a percorre:

        items: (json['items'] as List<dynamic>)
            .map((e) => ItemsItem.fromJson(e as Map<String, dynamic>))
            .toList(),

Uma lista de escalares usa cast, mais barato: (json['tags'] as List<dynamic>).cast<String>().

O que uma amostra não consegue dizer

Todo campo é final e required, e nenhum aceita nulo — porque o documento trazia um valor para cada um. Uma chave ausente vira assim um TypeError na decodificação, que nomeia o campo, em vez de um null que viaja três telas antes de quebrar.

Só um null dá dynamic, que aceita tudo e não confere nada. Uma lista vazia ou mista dá List<dynamic> pela mesma razão. São os três lugares que valem uma revisita assim que você tiver uma segunda carga.

Privado por padrão

Tudo é executado localmente no seu navegador com JavaScript. Os seus dados nunca são enviados para um servidor, o que torna a ferramenta segura para conteúdo sensível e funciona offline.

Perguntas frequentes

Preciso de json_serializable ou build_runner?
Não. A fábrica `fromJson` e o método `toJson` são escritos por inteiro: a classe funciona com `jsonDecode` e nada mais. Se o seu projeto já usa json_serializable, o código gerado por ele faz o mesmo trabalho com anotações — esta saída é a versão que você lê sem rodar um build.
O que acontece se uma chave faltar em execução?
O cast lança. `json['id'] as int` numa chave ausente é um `null` convertido para `int`, ou seja um `TypeError` que nomeia o campo. É a falha alta, e é a certa: uma amostra em que a chave sempre estava não pode dizer que ela é opcional. Passe o campo para `int?` e tire o `required` quando souber.
Posso desligar os métodos JSON?
Pode — o ajuste deixa a classe com os campos e o construtor. É útil quando você cola numa base que gera a serialização em outro lugar, ou quando a classe é um simples portador de valores que nunca encontra JSON.

Conversores relacionados