Question 1

How does Dart 3 sound null safety work when converting JSON to Dart models?

Accepted Answer

Dart 3 enforces sound null safety, meaning types are non-nullable by default unless explicitly annotated with a question mark (`?`). When converting JSON, the generator inspects field values: if a field contains `null` or is omitted across objects in an array, it is declared as a nullable type (e.g., `final String? nickname;`) and instantiated as an optional constructor parameter (`this.nickname`). Fields with non-null values are declared non-nullable (`final String id;`) and marked with the `required` keyword in the constructor (`required this.id`). This guarantees that no runtime null-pointer exceptions occur once data is parsed.

Question 2

What is the difference between json_serializable code generation and manual factory constructors?

Accepted Answer

`json_serializable` is the recommended approach for large Flutter projects. It uses Dart's build system (`build_runner`) to automatically generate serialization boilerplate in a separate `.g.dart` file based on `@JsonSerializable()` annotations. This reduces handwritten code and prevents deserialization bugs when schemas change. Manual factory constructors (`Model.fromJson` and `model.toJson`), by contrast, write the parsing logic directly inside your class using native `Map<String, dynamic>` type casts. Manual factories require zero external dependencies and work immediately without running a build runner.

Question 3

How should numeric values (int vs double) be handled to avoid runtime CastError?

Accepted Answer

In JSON, all numbers are formatted similarly, but Dart strictly separates 64-bit integer (`int`) and 64-bit float (`double`). If an API returns an integer (e.g., `10`) for a field expected to be a floating-point number (`double`), direct casting via `json["price"] as double` will throw a runtime `_CastError` in Dart. Our generator solves this by casting numeric fields to Dart's base numeric class (`num`) first: `(json["price"] as num).toDouble()` or `(json["price"] as num?)?.toDouble()`. This safely accepts both `10` and `10.5` without crashes.

Question 4

How are ISO-8601 date strings detected and parsed into Dart DateTime objects?

Accepted Answer

When the generator encounters string values matching standard ISO-8601 or RFC 3339 formats (such as `2026-09-06T12:00:00Z`), it assigns the field a `DateTime` type. In manual mode, it generates `DateTime.parse(json["createdAt"] as String)` in the constructor and `createdAt.toIso8601String()` during serialization. In `json_serializable` mode, the code generator automatically utilizes built-in DateTime converters.

Question 5

How does the converter handle snake_case API keys and Dart reserved keywords?

Accepted Answer

JSON APIs commonly use `snake_case` (e.g. `user_id`, `is_active`) or kebab-case keys, whereas Dart style conventions mandate `lowerCamelCase` for class fields (`userId`, `isActive`). The generator transforms all keys into idiomatic camelCase identifiers while adding `@JsonKey(name: "user_id")` or referencing the original string key in manual `json["user_id"]` lookups. If a JSON key matches a Dart reserved keyword (such as `default`, `class`, `is`, `in`, `switch`, or `continue`), the generator renames the identifier safely (e.g., `defaultValue` or `inValue`) to prevent compilation errors.

Question 6

How are deeply nested JSON objects and arrays (List<T>) mapped into separate Dart classes?

Accepted Answer

When an input JSON property contains an object or an array of objects, the generator decomposes each unique structure into its own independent PascalCase Dart class. The parent class references the child class by name (e.g., `final Address address;` or `final List variants;`). In manual `fromJson` factories, nested arrays are parsed using collection transforms like `(json["variants"] as List).map((e) => VariantItem.fromJson(e as Map)).toList()`.

Question 7

How do I configure build_runner and json_annotation in my Flutter pubspec.yaml?

Accepted Answer

To use `json_serializable` in Flutter or Dart, add `json_annotation` under `dependencies` and both `build_runner` and `json_serializable` under `dev_dependencies` in your `pubspec.yaml`:

```yaml
dependencies:
  flutter:
    sdk: flutter
  json_annotation: ^4.9.0

dev_dependencies:
  build_runner: ^2.4.9
  json_serializable: ^6.8.0
```

After saving your generated Dart model file (e.g., `lib/models/user.dart`), execute `dart run build_runner build --delete-conflicting-outputs` in your terminal to generate the `user.g.dart` companion file.

Question 8

Why does Flutter avoid runtime reflection (dart:mirrors) for JSON serialization?

Accepted Answer

Flutter compiles Dart code Ahead-Of-Time (AOT) to native ARM machine code for iOS and Android. Dynamic runtime reflection (via `dart:mirrors`) prevents dead-code stripping (tree shaking), substantially increasing mobile binary size and degrading performance. Because `dart:mirrors` is disabled in Flutter runtimes, Flutter relies exclusively on static compile-time code generation (`build_runner` + `json_serializable` or `freezed`) or explicit handwritten factory constructors.

Popular Developer Tools tools

How to JSON to Dart Online

JSON to Dart Features

Supported Formats & Dialects

Mastering JSON to C# Class Serialization: System.Text.Json, Records & .NET Best Practices

Mastering JSON to Dart & Flutter Serialization: Null Safety, json_serializable & Freezed

Mastering JSON to Go Struct Serialization: encoding/json, Struct Tags & Custom Unmarshaling

Mastering JSON to Rust Struct Serialization: Serde, Derives & Zero-Copy Parsing

Frequently Asked Questions

Developer Reference & Learning Hubs

JSON to Dart Converter — Null-Safe Dart Class Generator

JSON to Dart