flutter 序列化

If you intend to save user data to the shared preferences or local storage in your Flutter application, you will need to serialize it manually.

如果打算将用户数据保存到Flutter应用程序中的共享首选项或本地存储中，则需要手动对其进行序列化。

This is because both methods only support a limited selection of primitive object types and your object will probably not fall into any category. To do this we will be using the dart:convert decoder with its jsonEncode/jsonDecode methods, so make sure to import it into your project.

这是因为这两种方法仅支持有限的原始对象类型选择，并且您的对象可能不会属于任何类别。 为此，我们将使用dart：convert解码器及其jsonEncode / jsonDecode方法，因此请确保将其导入到您的项目中。

To do this, import the class in your main dart file:

为此，将类导入到您的主dart文件中：

import 'dart:convert';

如何在Dart中建立模型类 (How to build a Model Class in Dart)

To allow our object to become enabled for decoding/encoding we first need to create a Model class for it. This class will represent the object and it’s fields and have the important methods which will do the heavy work of encoding/decoding. The first one is called fromJson and the second one is called toJson. We will show various examples of complex objects and how to serialize them, but for the beginning, we’ll start with a simple one.

为了使我们的对象能够进行解码/编码，我们首先需要为其创建一个Model类。 此类将表示对象及其字段，并具有将进行繁重的编码/解码工作的重要方法。 第一个称为fromJson ，第二个称为toJson 。 我们将展示复杂对象的各种示例以及如何序列化它们，但首先，我们将从一个简单的示例开始。

We’ll imagine we have a doughnut shop, where we have various doughnuts. Each doughnut is an object that contains the following keys:

我们将想象我们有一家甜甜圈店，那里有各种甜甜圈。 每个甜甜圈都是一个包含以下键的对象：

• Name - String名称-字串
• Filling - String填充-字符串
• Topping - String打顶-字符串
• Price - Double价格-双倍

In Dart, it would like this:

在Dart中，它是这样的：

class Doughnut {final String name;final String filling;final String topping;final double price;Doughnut(this.name, this.filling, this.topping, this.price);Doughnut.fromJson(Map<String, dynamic> json): name = json['name'],filling = json['filling'],topping = json['topping'],price = json['price'];Map<String, dynamic> toJson() => {'name' : name,'filling' : filling,'topping' : topping,'price' : price};
}

You may have noticed a weird type in there called dynamic. Dynamic signifies an unknown type in the dart language, one which will be realized during runtime. Think of it as similar to the Object type in Java, which all types inherit from. Any object can be cast into dynamic to invoke methods on it. If no type is declared for a variable or a return type for a method, it is assumed to be dynamic.

您可能已经注意到其中有一种叫做dynamic的怪异类型。 动态表示Dart语言中的未知类型，该类型将在运行时实现。 可以认为它类似于Java中所有类型都继承自的对象类型。 任何对象都可以转换为动态对象以调用其上的方法。 如果没有声明变量的类型或方法的返回类型，则假定它是动态的。

如何在Flutter中对数据进行序列化和反序列化 (How to Serialize and De-Serialize Data in Flutter)

Now that we have our model class, we can use it to serialized and de-serialize our data. Below is an example of just how to do that.

现在我们有了模型类，我们可以使用它来对数据进行序列化和反序列化。 以下是如何执行此操作的示例。

Creating a doughnut object is simple:

创建一个甜甜圈对象很简单：

Doughnut myDoughnut = new Doughnut("Glazed", "None", "Sprinkles", 2.99);

And now we can serialize it by using jsonEncode:

现在我们可以使用jsonEncode对其进行序列化：

String encodedDoughnut = jsonEncode(myDoughnut);

Under the hood, jsonEncode calls our own toJson method that we created in our doughnut model class. The same also applies for jsonDecode as it calls the fromJson method.

在后台，jsonEncode调用我们自己的在donut模型类中创建的toJson方法。 jsonDecode也是如此，因为它调用fromJson方法。

In string form, our doughnut object, now looks like this:

以字符串形式，我们的甜甜圈对象现在看起来像这样：

{"name":"Glazed","filling":"None","topping":"Sprinkles","price":2.99}

And after we decode it,

在我们解码之后

Map<String, dynamic> decodedDoughnut = jsonDecode(encodedDoughnut);

we will get:

我们将获得：

{name: Glazed, filling: None, topping: Sprinkles, price: 2.99}

Did you notice the subtle differences?

您注意到细微的差异了吗？

The decoded object is now a Map with keys of string type and values of dynamic type. If we want to convert this data type back to our original object, we need to access the properties of the map:

现在，已解码的对象是一个Map，其中包含字符串类型的键和动态类型的值。 如果要将此数据类型转换回我们的原始对象，则需要访问地图的属性：

Doughnut newDoughnut = new Doughnut(decodedDoughnut["name"], decodedDoughnut["filling"], decodedDoughnut["topping"], decodedDoughnut["price"]);

如何在Dart中序列化数组 (How to Serialize Arrays in Dart)

Life is not as simple as a doughnut(if only, right?), so we have to take into account that we won’t always be dealing with parameter types that are simple. Let’s assume that the toppings field is not a String, but is an Array of strings. First, let’s redefine the toppings field:

生活并不像甜甜圈那么简单(如果只有，是吧？)，因此我们必须考虑到，我们将不会总是处理简单的参数类型。 假设toppings字段不是String，而是字符串数组。 首先，让我们重新定义浇头字段：

String topping => List<String> toppings;

Then, in our fromJson method we will have to do the following:

然后，在我们的fromJson方法中，我们将必须执行以下操作：

Doughnut.fromJson(Map<String, dynamic> json) {name = json['name'];filling = json['filling'];var toppingsFromJson = json['toppings'];toppings = new List<String>.from(toppingsFromJson);price = json['price'];}

Notice, how we have a temporary variable to first extract the value from the json variable and then we explicitly convert the value to our toppings list original type. We have to do this since at first, the type for the value of toppings is dynamic and dart does not know which type it is explicitly.

请注意，我们如何拥有一个临时变量以首先从json变量中提取值，然后将其显式转换为浇头列表原始类型。 我们必须这样做，因为起初，浇头值的类型是动态的，而dart不知道它是哪种类型。

复杂物体 (Complex Objects)

No one ever buys only one doughnut, right? That would be useless. Let’s imagine we have a dozen. So now we are dealing with a list of objects of Doughnut type. To serialize/de-serialize a list of objects we will use the model class above, but we will need to create a different model class to handle the list.

没有人只买一个甜甜圈，对吗？ 那将是无用的。 假设我们有一打。 因此，现在我们正在处理“甜甜圈”类型的对象列表。 要序列化/反序列化对象列表，我们将使用上面的模型类，但是我们将需要创建一个不同的模型类来处理该列表。

import 'package:serialization_example/models/doughnut.dart';class DoughnutList {final List<Doughnut> doughnuts;DoughnutList(this.doughnuts);DoughnutList.fromJson(Map<String, dynamic> json): doughnuts = json['doughnuts'] != null ? List<Doughnut>.from(json['doughnuts']) : null;Map<String, dynamic> toJson()  =>{'doughnuts': doughnuts,};}

As you can see, we now have a model class that has a field of type List that holds Doughnut objects.

如您所见，我们现在有了一个模型类，该模型类具有一个包含Donut对象的List类型的字段。

Similar to the example above, to serialize the object we use the jsonEncode method and when we want to decode the object we have to perform the following:

与上面的示例类似，要序列化对象，我们使用jsonEncode方法，当我们想对对象进行解码时，我们必须执行以下操作：

Map<String, dynamic> decodedDoughnuts = jsonDecode(encodedJson);
List<dynamic> decodedJson =  decodedDoughnuts['doughnuts'];
decodedJson.map((elem) => jsonDecode(elem));

To see all that we covered in this article, head over to the repository on GitHub.

要查看我们在本文中介绍的所有内容，请转到GitHub上的存储库 。

翻译自: https://www.freecodecamp.org/news/serialize-object-flutter/

flutter 序列化