Flutter未知功能插件inferno的使用（注：由于介绍为undefined，故功能为假设性描述） （注：由于“inferno”并非一个广为人知的Flutter插件名称，且介绍为“undefined”，以下描述基于一般Flutter插件可能的功能进行假设性创作，以便符合题目要求。） Flutter性能优化与分析插件inferno的使用

Flutter未知功能插件inferno的使用

（注：由于“inferno”并非一个广为人知的Flutter插件名称，且介绍为“undefined”，以下描述基于一般Flutter插件可能的功能进行假设性创作，以便符合题目要求。）

引言

inferno 是一个库，它简化了处理JSON数据的过程。它允许用户从JSON文件中自动推断数据类型，并生成可以解析这些数据的解析器。

---

简介  ｜  用法  ｜  示例

简介 #

Inferno 是一个库，它简化了处理JSON数据的过程。它允许用户从JSON文件中自动推断数据类型，并生成可以解析这些数据的解析器。

用法 #

在名为 `person.dart` 的文件中添加以下代码。确保在同一目录下有一个 `person.json` 文件，并运行 `dart run build_runner build`。

import 'package:json_annotation/json_annotation.dart';
import 'package:inferno/annotations.dart';

part 'person.inferno.dart';
part 'person.g.dart';

[@InferFromJSONFile](/user/InferFromJSONFile)(file: "person.json")
typedef Person = InferredPerson;

Inferno 将会生成一个 `person.inferno.dart` 文件，其中包含从 `person.json` 文件中推断的数据类型。`json_serializable` 库将生成一个 `person.g.dart` 文件，该文件包含输入数据的解析器。

导入 #

由于我们将使用 `[@InferFromJSONFile](/user/InferFromJSONFile)` 注解，我们首先需要使用 `import 'package:inferno/annotations.dart';` 导入它。生成的文件将使用 `@JsonSerializable` 注解，可以在 `import 'package:json_annotation/json_annotation.dart';` 库中找到。

`Inferno` 库将生成一个 `person.inferno.dart` 文件，其中包含从 JSON 文件 `person.json` 中推断的对象。该对象将使用 `@JsonSerializable` 注解进行标注，这将生成另一个文件 `person.g.dart`，该文件包含 `json_serializable` 解析器。我们需要定义这两个文件作为我们类型定义文件的一部分。

类型推断 #

```dart [@InferFromJSONFile](/user/InferFromJSONFile)(file: "person.json") typedef Person = InferredPerson; ```

`[@InferFromJSONFile](/user/InferFromJSONFile)` 注解必须始终位于类型定义之前，格式为 `typedef <ClassName> = Inferred<ClassName>`。**`Inferno` 将生成一个新的类 `Inferred<ClassName>`，然后我们使用类型别名将其重命名为 `<ClassName>`。

注意：我们可以在一个文件中包含许多带有 `InferFromJSONFile` 注解的类型声明，这将只生成两个文件：`<file_name>.inferno.dart` 和 `<file_name>.g.dart`。

生成JSON解析器 #

要使用Dart包构建，请运行Dart构建运行程序 `dart run build_runner build` 在包目录中执行。

要使用Flutter包构建，请在你的包目录中运行 `flutter pub run build_runner build`。

示例 #

首先，我们将向Inferno提供一个具有多个字段的JSON对象，并查看它是如何生成相应的Dart对象的。然后，我们将看到Inferno如何处理嵌套的JSON对象和数组，并如何从JSON数据中推断其他数据类型。

推断简单对象的数据类型 #

让我们先看一个简单的例子。我们向Inferno提供了一个具有三个字段的JSON对象，字段名称为蛇形命名法。

{
    "first_name": "Raymond",
    "last_name": "Holt",
    "age": 65
}

Inferno生成以下Dart对象，该对象使用了来自 `json_annotation` 库的 `JsonSerializable` 注解。此注解允许我们生成必要的代码，用于将对象序列化和反序列化为JSON。

如你所见，Inferno正确地从输入的JSON文件中推断出数据类型。根据Dart约定，字段名称已转换为蛇形命名法，并添加了 `JsonKey` 注解。由于原始JSON对象对所有三个键都有值，所以所有数据类型都是非空的。

@JsonSerializable()
class InferredExample01 {
  @JsonKey(name: "first_name")
  final String firstName;
  @JsonKey(name: "last_name")
  final String lastName;
  final int age;
  InferredExample01({
    required this.firstName,
    required this.lastName,
    required this.age,
  });

  factory InferredExample01.fromJson(Map<String, dynamic> json) =>
      _$InferredExample01FromJson(json);
  Map<String, dynamic> toJson() => _$InferredExample01ToJson(this);
}

`_$InferredExample01FromJson` 和 `_$InferredExample01ToJson` 引用的是当运行 `json_serializable` 生成器时创建的生成文件。此生成文件包含该类的实际序列化和反序列化逻辑，允许我们轻松地将此类的对象转换为和从JSON。

推断嵌套对象的数据类型 #

让我们来看一个包含嵌套对象的JSON文件的例子。在这个例子中，位置被表示为一个具有两个字段的嵌套对象。

{
    "name": "Raymond Jacob Holt",
    "location": {
        "city": "Brooklyn",
        "state": "NY"
    }
}

Inferno生成以下代码。第一个对象表示我们的位置，包含 `city` 和 `state` 字段，第二个对象表示一个人，包含 `name` 和 `location` 字段。

@JsonSerializable()
class InferredLocation {
  final String city;
  final String state;
  InferredLocation({
    required this.city,
    required this.state,
  });

  factory InferredLocation.fromJson(Map<String, dynamic> json) =>
      _$InferredLocationFromJson(json);
  Map<String, dynamic> toJson() => _$InferredLocationToJson(this);
}

@JsonSerializable()
class InferredExample02 {
  final String name;
  final InferredLocation location;
  InferredExample02({
    required this.name,
    required this.location,
  });

  factory InferredExample02.fromJson(Map<String, dynamic> json) =>
      _$InferredExample02FromJson(json);
  Map<String, dynamic> toJson() => _$InferredExample02ToJson(this);
}

要解析原始JSON文件，我们现在可以调用 `final person = InferredExample02.fromJson(...)`。

推断数组中的原始数据类型 #

```json { "names": [ "George", "Jenna", "Michael", "Tina" ], "ages": [ 25, 12, 84, 16 ], "can_drive": [ true, false, true, false ] } ```

@JsonSerializable()
class InferredExample03 {
  final List<String> names;
  final List<int> ages;
  @JsonKey(name: "can_drive")
  final List<bool> canDrive;
  InferredExample03({
    required this.names,
    required this.ages,
    required this.canDrive,
  });

  factory InferredExample03.fromJson(Map<String, dynamic> json) =>
      _$InferredExample03FromJson(json);
  Map<String, dynamic> toJson() => _$InferredExample03ToJson(this);
}

推断数组中的对象具有相同字段的数据类型 #

```json { "points": [ { "x": 0, "y": 0 }, { "x": 5, "y": 2 }, { "x": 3, "y": 4 } ] } ```

@JsonSerializable()
class InferredPoints {
  final int x;
  final int y;
  InferredPoints({
    required this.x,
    required this.y,
  });

  factory InferredPoints.fromJson(Map<String, dynamic> json) =>
      _$InferredPointsFromJson(json);
  Map<String, dynamic> toJson() => _$InferredPointsToJson(this);
}

@JsonSerializable()
class InferredExample04 {
  final List<InferredPoints> points;
  InferredExample04({
    required this.points,
  });

  factory InferredExample04.fromJson(Map<String, dynamic> json) =>
      _$InferredExample04FromJson(json);
  Map<String, dynamic> toJson() => _$InferredExample04ToJson(this);
}

推断数组中的对象具有相似字段的数据类型 #

```json { "points_xyz": [ { "x": 0, "y": 0 }, { "x": 5, "y": 2, "z": 16 }, { "x": 3, "y": 4 } ] } ```

@JsonSerializable()
class InferredPointsXyz {
  final int x;
  final int y;
  final int? z;
  InferredPointsXyz({
    required this.x,
    required this.y,
    this.z,
  });

  factory InferredPointsXyz.fromJson(Map<String, dynamic> json) =>
      _$InferredPointsXyzFromJson(json);
  Map<String, dynamic> toJson() => _$InferredPointsXyzToJson(this);
}

@JsonSerializable()
class InferredExample05 {
  @JsonKey(name: "points_xyz")
  final List<InferredPointsXyz> pointsXyz;
  InferredExample05({
    required this.pointsXyz,
  });

  factory InferredExample05.fromJson(Map<String, dynamic> json) =>
      _$InferredExample05FromJson(json);
  Map<String, dynamic> toJson() => _$InferredExample05ToJson(this);
}

推断嵌套数组的数据类型 #

```json { "grid": [ [ false, false, true ], [ false, true, false ], [ true, false, false ] ] } ```

@JsonSerializable()
class InferredExample06 {
  final List<List<bool>> grid;
  InferredExample06({
    required this.grid,
  });

  factory InferredExample06.fromJson(Map<String, dynamic> json) =>
      _$InferredExample06FromJson(json);
  Map<String, dynamic> toJson() => _$InferredExample06ToJson(this);
}

完整示例Demo

以下是一个完整的示例，展示了如何使用inferno插件来推断JSON数据并生成对应的Dart对象。

import 'package:json_annotation/json_annotation.dart';
import 'package:inferno/annotations.dart';

part 'example.inferno.dart';
part 'example.g.dart';

[@InferFromJSONFile](/user/InferFromJSONFile)(file: "json/example01.json")
typedef Example01 = InferredExample01;

[@InferFromJSONFile](/user/InferFromJSONFile)(file: "json/example02.json")
typedef Example02 = InferredExample02;

[@InferFromJSONFile](/user/InferFromJSONFile)(file: "json/example03.json")
typedef Example03 = InferredExample03;

[@InferFromJSONFile](/user/InferFromJSONFile)(file: "json/example04.json")
typedef Example04 = InferredExample04;

[@InferFromJSONFile](/user/InferFromJSONFile)(file: "json/example05.json")
typedef Example05 = InferredExample05;

[@InferFromJSONFile](/user/InferFromJSONFile)(file: "json/example06.json")
typedef Example06 = InferredExample06;