100 % locale — i tuoi dati non lasciano mai il tuo browser

JSON in Dart — fromJson e toJson già scritti

Trasforma un campione JSON in classi Dart. Le chiavi originali vivono nei fromJson e toJson generati: la mappatura è codice che si legge e si debugga.

Istantaneo Privato Zero cookie

Input JSON

Output Dart

Che cosa fa questo strumento

Un campione JSON diventa classi Dart, ciascuna con una fabbrica fromJson e un metodo 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(),
      };
}

Niente build_runner, niente annotazioni, nessun file part generato: la corrispondenza è lì, sotto gli occhi, e puoi cambiarla.

La chiave non se ne va mai

Un nome di campo Dart non porta trattini e non comincia con una cifra, e class è riservato. Quando un nome deve cambiare, entrambi i versi conservano la chiave:

  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_,
      };

Poiché la corrispondenza è codice e non una convenzione, nulla viene indovinato a runtime — e leggi ciò che sarà inviato prima di inviarlo.

Liste e oggetti annidati

Una lista di oggetti diventa una classe a parte, e la corrispondenza la percorre:

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

Una lista di scalari usa cast, meno costoso: (json['tags'] as List<dynamic>).cast<String>().

Ciò che un campione non può dire

Ogni campo è final e required, e nessuno è annullabile — perché il documento aveva un valore per ciascuno. Una chiave mancante diventa così un TypeError alla decodifica, che nomina il campo, invece di un null che viaggia per tre schermate prima di rompersi.

Solo un null dà dynamic, che accetta tutto e non controlla nulla. Una lista vuota o mista dà List<dynamic> per lo stesso motivo. Sono i tre punti da rivedere appena hai un secondo carico.

Privato per progettazione

Tutto viene eseguito localmente nel browser con JavaScript. I tuoi dati non vengono mai caricati, quindi lo strumento è sicuro per contenuti sensibili e funziona anche offline.

Domande frequenti

Servono json_serializable o build_runner?
No. La fabbrica `fromJson` e il metodo `toJson` sono scritti per intero: la classe funziona con `jsonDecode` e nient’altro. Se il tuo progetto usa già json_serializable, il suo codice generato fa lo stesso lavoro con le annotazioni — questa uscita è la versione che puoi leggere senza lanciare un build.
Che succede se a runtime manca una chiave?
Il cast solleva. `json['id'] as int` su una chiave assente è un `null` convertito a `int`, quindi un `TypeError` che nomina il campo. È il fallimento rumoroso, ed è quello giusto: un campione in cui la chiave c’era sempre non può dirti che è opzionale. Porta il campo a `int?` e togli il `required` quando lo saprai.
Posso disattivare i metodi JSON?
Sì — l’impostazione lascia la classe con i suoi campi e il costruttore. Serve quando incolli in una base che genera la serializzazione altrove, o quando la classe è un semplice portatore di valori che non incontra mai JSON.

Convertitori correlati