许多运行时值可以被序列化或反序列化,使用 haxe.Serializer 和 haxe.Unserializer 类。都支持两种用法:
创建一个实例,并不断的调用 serialize / unserialize 方法来处理多个值。
调用它们的静态 run 方法来 序列化/反序列化 一个单独的值。
下面的例子演示了第一种用法:
~~~
import haxe.Serializer;
import haxe.Unserializer;
class Main {
static function main() {
var serializer = new Serializer();
serializer.serialize("foo");
serializer.serialize(12);
var s = serializer.toString();
trace(s); // y3:fooi12
var unserializer = new Unserializer(s);
trace(unserializer.unserialize()); // foo
trace(unserializer.unserialize()); // 12
}
}
~~~
序列化的结果(这里存储在局部变量 s)是一个 String,并且可以被任意甚至远程地传递。它的格式以 序列化格式(第10.8.1节)描述。
## 支持的值
* null
* Bool, Int 和 Float (包括无穷值和 NaN)
* String
* Date
* haxe.io.Bytes (编码为 base64)
* Array 和 List
* haxe.ds.StringMap, haxe.ds.IntMap 和 haxe.ds.ObjectMap
* 匿名结构
* Haxe 类实例(并不是原生的)
* 枚举实例
## 序列化配置
序列化可以以两种方式配置。对于一个静态变量,可以被设置来改变所有 haxe.Serializer 实例,一个成员变量可以被设置来影响一个特定实例:
* USE_CACHE,userCache : 如果为 true,重复的结构或类/枚举实例被参照序列化。这可以避免递归数据的无限循环更长的序列化时间。默认,对象缓存是禁用的;然而字符串总是被缓存。
* USE_ENUM_INDEX,useEnumIndex : 如果为 true ,枚举构造函数被它们的索引序列化而不是它们的名字。这可以使结果字符串更短,但是如果 枚举构造函数在反序列化之前被插入到这个类型,将会打断。这个行为默认是禁止的。
## 反序列化行为
如果序列化结果被存储,之后使用于反序列化,必须注意当使用类和枚举实例时要保持兼容性。之后重要的是准确理解反序列化如何实现的。
* 做反序列化的地方类型必须在运行时可以获得的。如果无用代码消除被激活,只是通过序列化使用的类型可能会被删除。
* 每个 Unserializer 都有一个成员变量 resolver ,用于通过名字解析类和枚举。Unserializer 一经创建,它被设置为 Unserializer.DEFAULT_RESOLVER 。它和实例成员都可以被设置为一个定制 分析器。
* 类使用 resolver.resolveClass(name) 通过名字解析。实例然后被使用 Type.createEmptyInstance 创建,这意味着 这个类构造函数没有被调用。最终,实例字段根据序列化的值被设置。
* 枚举使用 resolver.resolveEnum(name)通过名字及诶系。枚举实例然后被使用 Type.createEnum创建,如果可用,则使用序列化的参数值。如果构造函数参数由于序列化被改变,结果是未指定的。
## 自定义的(反)序列化
如果一个类定义了成员方法 hxSerialize,这个方法被序列化器调用,允许对类的自定义序列化。同样,如果一个类定义了成员方法 hxUnserialize,它被反序列化器调用:
~~~
import haxe.Serializer;
import haxe.Unserializer;
class Main {
var x:Int;
var y:Int;
static function main() {
var s = Serializer.run(new Main(1, 2));
var c:Main = Unserializer.run(s);
trace(c.x); // 1
trace(c.y); // -1
}
function new(x, y) {
this.x = x;
this.y = y;
}
@:keep
function hxSerialize(s:Serializer) {
s.serialize(x);
}
@:keep
function hxUnserialize(u:Unserializer) {
x = u.unserialize();
y = -1;
}
}
~~~
在这个例子中,我们决定要忽略成员变量 y的值,并且不序列化它。相反,我们在 hxUnserialize中默认它为 -1 。两个方法都使用 @:keep 元数据注解,以防止无用代码消除删除它们,因为它们在代码中从未恰当的引用。
查看 Serializer 和 Unserializer API 文档了解详细内容。
- 空白目录
- 1.Haxe介绍
- 1.1.Haxe是什么
- 1.2.关于本文档
- 1.2.1.作者及贡献者
- 1.2.2.License
- 1.3Hello World
- 1.4.Haxe的历史
- 2.类型
- 2.1.基本类型
- 2.1.1.数值类型
- 2.1.2.溢出
- 2.1.3.数值运算符
- 2.1.4.Bool类型
- 2.1.5.Void类型
- 2.2.为空性
- 2.2.1.可选参数和为空性
- 2.3.类实例
- 2.3.1.类的构造函数
- 2.3.2.继承
- 2.3.3.接口
- 2.4.枚举实例
- 2.4.1.Enum构造函数
- 2.4.2.使用枚举
- 2.5.匿名结构
- 2.5.1.结构值的JSON形式
- 2.5.2. 结构类型的类记法
- 2.5.3.可选字段
- 2.5.4.性能影响
- 2.6.函数类型
- 2.6.1.可选参数
- 2.6.2.默认值
- 2.7.动态类型
- 2.7.1.Dynamic使用类型参数
- 2.7.2.实现Dynamic
- 2.8.抽象类型
- 2.8.1.隐式类型转换
- 2.8.2.运算符重载
- 2.8.3.数组访问
- 2.8.4.选择函数
- 2.8.5.枚举抽象类型
- 2.8.6.转发抽象类型字段
- 2.8.7.核心类型抽象
- 2.9.单形
- 3.类型系统
- 3.1.Typedef
- 3.1.1.扩展
- 3.2.类型参数
- 3.2.1.约束
- 3.3.泛型
- 3.3.1.泛型类型参数解释
- 3.4.变异
- 3.5.统一
- 3.5.1.类/接口 之间
- 3.5.2.结构子类型化
- 3.5.3.单形
- 3.5.4.函数返回
- 3.5.5.通用基本类型
- 3.6.类型推断
- 3.6.1.由上而下推断
- 3.6.2.局限
- 3.7.模块和路径
- 3.7.1.模块子类型
- 3.7.2.Import
- 3.7.3.解析顺序
- 4.类字段
- 4.1.变量
- 4.2.属性
- 4.2.1.常见访问标识符组合
- 4.2.2.对类型系统的影响
- 4.2.3.getter和setter的规则
- 4.3.方法
- 4.3.1.重写方法
- 4.3.2.变异和访问修饰符的影响
- 4.4.访问修饰符
- 4.4.1.可见性
- 4.4.2.Inline
- 4.4.3.Dynamic
- 4.4.4.Override
- 4.4.5.Static
- 5.表达式
- 5.1.块
- 5.2.常量
- 5.3.二元操作符
- 5.4.一元操作符
- 5.5.数组声明
- 5.6.对象声明
- 5.7.字段访问
- 5.8.数组访问
- 5.9.函数调用
- 5.10.var
- 5.11.局部函数
- 5.12.new
- 5.13.for
- 5.14.while
- 5.15.do-while
- 5.16.if
- 5.17.switch
- 5.18.try/catch
- 5.19.return
- 5.20.break
- 5.21.continue
- 5.22.throw
- 5.23.类型转换
- 5.23.1.不安全转换
- 5.23.2.安全转换
- 5.24.类型检查
- 6.语言特性
- 6.1.条件编译
- 6.2.Externs
- 6.3.静态扩展
- 6.3.1.标准库中的静态扩展
- 6.4.模式匹配
- 6.4.1.介绍
- 6.4.2.枚举匹配
- 6.4.3.变量捕获
- 6.4.4.结构匹配
- 6.4.5.数组匹配
- 6.4.6.Or 模式
- 6.4.7.守护
- 6.4.8.多个值的匹配
- 6.4.9.提取器
- 6.4.10.穷尽性检查
- 6.4.11.无效的模式检查
- 6.5.字符串插值
- 6.6.数组推导
- 6.7.迭代器
- 6.8.函数绑定
- 6.9.元数据
- 6.10.访问控制
- 6.11.内联构造函数
- 7.编译器用法
- 7.1.编译器标记
- 8.编译器功能
- 8.1.内建编译器元数据
- 8.2.无用代码消除
- 8.3.编译器服务
- 8.3.1.概述
- 8.3.2.字段访问完成
- 8.3.3.调用参数完成
- 8.3.4.类型路径完成
- 8.3.5.使用完成
- 8.3.6.位置完成
- 8.3.7.顶级完成
- 8.3.8.完成服务
- 8.4.资源
- 8.4.1.嵌入资源
- 8.4.2.检索文本资源
- 8.4.3.检索二进制资源
- 8.4.4.实现细节
- 8.5.运行时类型信息
- 8.5.1.RTTI 结构
- 8.6.静态分析仪
- 9.宏
- 9.1.宏上下文
- 9.2.参数
- 9.2.1.ExprOf
- 9.2.2.常数表达式
- 9.2.3.其它的参数
- 9.3.具体化
- 9.3.1.表达式具体化
- 9.3.2.类型具体化
- 9.3.3.类具体化
- 9.4.工具
- 9.5.类型构建
- 9.5.1.枚举构建
- 9.5.2.@:autoBuild
- 9.5.3.@:genericBuild
- 9.6.限制
- 9.6.1.Macro-in-Macro
- 9.6.2.静态扩展
- 9.6.3.构建顺序
- 9.6.4.类型参数
- 9.7.初始化宏
- 10.标准库
- 10.1.字符串
- 10.2.数据结构
- 10.2.1.数组
- 10.2.2.向量
- 10.2.3.列表
- 10.2.4.GenericStack
- 10.2.5.Map
- 10.2.6.Option
- 10.3.正则表达式
- 10.3.1.匹配
- 10.3.2.分组
- 10.3.3.替换
- 10.3.4.分割
- 10.3.5.Map
- 10.3.6.实现细节
- 10.4.Math
- 10.4.1.特殊数值
- 10.4.2.数学错误
- 10.4.3.整数数学
- 10.4.4.扩展
- 10.5.Lambda
- 10.6.模板
- 10.7.反射
- 10.8.序列化
- 10.8.1.格式化序列化
- 10.9.Xml
- 10.9.1.开始使用Xml
- 10.9.2.解析Xml
- 10.9.3.编码Xml
- 10.10.Json
- 10.10.1.解析JSON
- 10.10.2.编码JSON
- 10.10.3.实现细节
- 10.11.Input/Output
- 10.12.Sys/sys
- 10.13.远程处理
- 10.13.1.远程连接
- 10.13.2.实现细节
- 10.14.单元测试
- 11.Haxelib
- 11.1.Haxe编译器使用库
- 11.2.haxelib.json
- 11.2.1.版本控制
- 11.2.2.依赖关系
- 11.3.extraParams.hxml
- 11.4.使用Haxelib
- 12.目标平台细节
- 12.1.JavaScript
- 12.1.1.开始使用Haxe/JavaScript
- 12.1.2.使用外部JavaScript库
- 12.1.3.注入原生JavaScript
- 12.1.4.JavaScript untyped函数
- 12.1.5.调试JavaScript
- 12.1.6.JavaScript目标元数据
- 12.1.7.为JavaScript暴露Haxe类
- 12.1.8.使用 require函数加载外部类
- 12.2.Flash
- 12.2.1.开始使用Haxe/Flash
- 12.2.2.嵌入资源
- 12.2.3.使用外部Flash库
- 12.2.4.Flash目标元数据
- 12.3.Neko
- 12.4.PHP
- 12.4.1.开始使用Haxe/PHP
- 12.4.2.PHP untyped函数
- 12.5.C++
- 12.5.1.Using C++定义
- 12.5.2.Using C++ 指针
- 12.6.Java
- 12.7.C#
- 12.8.Python