​​原地址​​

void main()
{
import std.stdio : writeln;

static foreach(number; [1, 2, 3, 4, 5])
{
writeln(number);
}
}
void main()
{
import std.stdio : writeln;

writeln(1);
writeln(2);
writeln(3);
writeln(4);
writeln(5);
}

​static foreach​​不会创建​​域​​,其在​​编译时​​如上展开.因而可能有问题,因此一般用​​{{|}}​​来配合​​静每一​​:

void main()
{
import std.stdio : writeln;

static foreach(number; [1, 2, 3])
{{
int 复杂式 = number + number;
writeln(复杂式);
}}
}
//展开为:
void main()
{
import std.stdio : writeln;

{
int 复杂式 = 1 + 1;
writeln(复杂式);
}

{
int 复杂式 = 2 + 2;
writeln(复杂式);
}

{
int 复杂式 = 3 + 3;
writeln(复杂式);
}
}

​别名​​,可与​​任意符号(如函数)​​一起用,而不仅是​​类型​​.

struct SomeStruct
{
int a;
}

alias SStruct = SomeStruct;

void main()
{
// 只是别名.
SStruct a = SomeStruct(200);
}

​清单常量​​:仅在​​编译时​​存在的​​不变变量​​.出现时,复制它.与​​普通​​变量一样,只是有​​枚​​前缀:

enum float PI = 3.14;
enum AGE = 200;
//可自动推导.

他们是​​编译时​​存储,且​​静如​​可访问的,因而​​重要且有用​​.注意:

enum MyArray = [1, 2, 3, 4];
//1,表示数组时,
static immutable MyArray = [1, 2, 3, 4];
//2,只表示1个时,这样就只复制一次,从而`s 是 t`.
void main()
{
auto s = MyArray;
auto t = MyArray;//1,会复制2次,
assert(s !is t);
}

​清单常量​​可为​​模板​​.因而我们可实现自己的​​特征​​.

enum myIsBoolean(T) = is(T == bool);
//可为模板.

enum isStringABoolean = myIsBoolean!string; // 假
enum isBooleanABoolean = myIsBoolean!bool; // 真

static assert(!isStringABoolean);
static assert(isBooleanABoolean);

有点类似​​C++​​的​​概念​​了.现在​​序化构​​,先检查是否是​​原始类型​​:

enum isPrimitiveType(T) = isNumeric!T || is(T == bool) || is(T == string);

现在这样:

JSONValue serialise(T)(T value)
{
static if(isPrimitiveType!T)
{
return JSONValue(value);
}
else static if(is(T == struct))
{
JSONValue toReturn;

// 用`的元组`来遍历成员.
static foreach(member; T.tupleof)
{{
alias MemberType = typeof(member);
pragma(msg, MemberType.stringof);
}}//{{}}来避免展开问题.

return toReturn;//
}
}

先是​​类型​​,接着取​​名字​​:

{{
alias MemberType = typeof(member);

// 编译器可推导为串.
const MemberName = __traits(identifier, member);
pragma(msg,MemberName~"是"~MemberType.stringof~"类型");
}}

用​​插件​​来将:

MemberType memberValue = mixin("value." ~ MemberName);

转为:

string memberValue = value.name;
int memberValue = value.age;

最后,​​{{}}​​中内容为:

{{
alias MemberType = typeof(member);
const MemberName = __traits(identifier, member);
MemberType memberValue = mixin("value." ~ MemberName);

// toReturn是个`数格`,用`成员名`为键,`成员值`为值.
toReturn[MemberName] = serialise(memberValue);
}}

​数格值​​对象,就是个​​统一对象​​.所有类型均​​归一​​化为该类型.

void main()
{
import std.stdio;

// 用`动`指定类型
auto json = serialise(Person("Bradley", 20));
writeln(json);

/*
输出:
{"age":20,"name":"Bradley"}
*/
}

接着,​​解序化​​结构:

T deserialise(T)(JSONValue json)
{
/* 前面原始类型省略了*/
else static if(is(T == struct))
{
T toReturn;//返回类型.

static foreach(member; T.tupleof)
{{
alias MemberType = typeof(member);
const MemberName = __traits(identifier, member);

MemberType memberValue = deserialise!MemberType(json[MemberName]);
// 整个语句是`插件`,所以`插件`中也要有`分号`;
mixin("toReturn." ~ MemberName ~ " = memberValue;");
// 如:
// toReturn.name = memberValue;
// toReturn.age = memberValue;
}}

return toReturn;
}
/**/
}

测试:

void main()
{
import std.stdio : writeln;

auto json = serialise(Person("Bradley", 20));
writeln("数格: ", json);

auto person = deserialise!Person(json);
writeln("人: ", person);

/*
输出:
数格: {"age":20,"name":"Bradley"}
人: Person("Bradley", 20)
*/
}

本站由小牛团队全力维护,小牛十年了,大家已经步入中年 。本站源码全部经过团队成员测试并调试,价格可能比其它网站略贵几元钱,不解释!
小牛资源 » 02序化构_fqbqrr

发表评论

全站资源亲测可用,价格略高几元,不解释

立即查看 了解详情