前言【原创不易，请尊重版权】

适用版本：v10【本文首发于唐霜的博客】

TySheMo是为解决前端数据层问题而生原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net的模式库。TySheMo这个单词由Typ本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】e Schema Modal三个单词缩写【未经授权禁止转载】原创内容，盗版必究。而成。你可以使用TySheMo在前端代码未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】中完成数据类型和结构检查，在前端构建领域【版权所有，侵权必究】转载请注明出处：www.tangshuang.net模型。

和TypeScript不同，TySheM【本文首发于唐霜的博客】【作者：唐霜】o的类型检查是运行时的，而非编译时的，因著作权归作者所有，禁止商业用途转载。转载请注明出处：www.tangshuang.net此是两个不同的工具。

如果你在开发一个业务系统，比如围绕某个具【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】体的销售、物流、物业、采购等等业务，那么【转载请注明来源】【转载请注明来源】你很有可能需要tyshemo。它是为业务【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net系统而生的，简单说，这里指的业务系统，是未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。具有非常强业务属性，作为一个公司的全部或原创内容，盗版必究。转载请注明出处：www.tangshuang.net部分收益的来源，该业务在在线系统上进行操未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。作时，不允许出错。之所以会开发tyshe未经授权，禁止复制转载。【本文首发于唐霜的博客】mo，是因为我发现，现有的前端开发，在怎【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】么维护数据的可靠性这一点上，极其匮乏。前【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net端应用由于数据的类型、格式、字段逻辑等原【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】因造成的bug数不胜数。大部分前端开发者原创内容，盗版必究。【版权所有，侵权必究】都没有认真考虑过前端数据层的问题，甚至，【原创内容，转载请注明出处】未经授权，禁止复制转载。他们根本不知道应用开发还需要分层考虑。正【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。是这一点，让我认真对待tyshemo这个本文作者：唐霜，转载请注明出处。【作者：唐霜】库。

目前，tyshemo这个库，已经在腾讯内【未经授权禁止转载】本文作者：唐霜，转载请注明出处。多个业务系统中在使用，随着需求的增多，我未经授权，禁止复制转载。未经授权，禁止复制转载。会在现有的基础上持续迭代更新。

概念【版权所有】唐霜 www.tangshuang.net

由于它是一个模式库，在设计时，我从前端领原创内容，盗版必究。【转载请注明来源】域模型的实际声明模式出发，创建了一些概念【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。。只有掌握这些概念之后，你才能更好的使用本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】这个库。

这些概念包括：原型、规则、类型、元、模式【版权所有】唐霜 www.tangshuang.net【作者：唐霜】、模型。

原型【作者：唐霜】

原型（Prototype）是用来描述数据【转载请注明来源】【原创不易，请尊重版权】的原子属性或特征方式。什么是“原子属性”著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】，就是作为一个数据，在计算机中，它是怎么【作者：唐霜】【本文首发于唐霜的博客】被对待的，即一个变量是如何对待的，以什么【本文受版权保护】【本文受版权保护】方式存储和运算它。

举一个例子，我们在代码中常会写 原创内容，盗版必究。var a ＝ 10 这样的代码，这时候，我们知道 a 是一著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。个数值，在浏览器或其他环境中，js 引擎本文版权归作者所有，未经授权不得转载。【本文受版权保护】会按照数值型数据对它进行存储和运算。但是【原创内容，转载请注明出处】【本文受版权保护】，你怎么知道 a 是一个数值呢？我的意思【本文首发于唐霜的博客】原创内容，盗版必究。是，计算机怎么知道它是一个数值呢？这是由【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。 a 的原子属性决定的。一个 js 中的【版权所有】唐霜 www.tangshuang.net【本文受版权保护】数值，它具备数值模型的特征，并且拥有数值【本文受版权保护】【访问 www.tangshuang.net 获取更多精彩内容】模型上的一些接口。数值可以进行精度求值，【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。可以进行小数位计算等，这些特定的特征使得本文作者：唐霜，转载请注明出处。【未经授权禁止转载】程序运行时，a 按照数值进行存储和运算。

在 js 中，基本的数据类型有 6 种：著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。number, string, bool【本文首发于唐霜的博客】【转载请注明来源】ean, null, undefined【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.net, symbol. 未来 js 还会出现原创内容，盗版必究。本文作者：唐霜，转载请注明出处。 bigint，甚至还会有 bigflo【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。at 这样的新数据类型。这些基础的数据类原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net型构成了 js 世界的原子属性。同样的道转载请注明出处：www.tangshuang.net原创内容，盗版必究。理，在 TySheMo 的体系里，对一个【未经授权禁止转载】本文作者：唐霜，转载请注明出处。数据的原型进行判定，是一切的基础。问题在原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】于，怎么去判定一个原型呢？实际上，我们要找到一种方法，可以判断某个变量是否转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。符合某种原型，比如，我们常见的 typeof 就是一本文作者：唐霜，转载请注明出处。【未经授权禁止转载】种判断方法。但在 TySheMo 的体系未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】里，typeof 这种方法不适用。

TySheMo 判定一个变量是否符合某个本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。原型主要通过创建一个判定逻辑，返回 tr【原创内容，转载请注明出处】未经授权，禁止复制转载。ue 或者 false。这个过程主要依托【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】 TySheMo 内建的接口，你可以使用【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】 js 的原生接口作为原型，也可以使用 本文作者：唐霜，转载请注明出处。【版权所有，侵权必究】TySheMo 内置的原型。

在学习下面的 Prototype 的使用【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。方法之后你可以创建自己的原型，用来作为数【转载请注明来源】本文版权归作者所有，未经授权不得转载。据类型判定的原子属性判定方法。

规则转载请注明出处：www.tangshuang.net

属性规则（Rule，本文简称“规则”）是【访问 www.tangshuang.net 获取更多精彩内容】【作者：唐霜】在一个对象中，属性的存在形式和值的逻辑的本文版权归作者所有，未经授权不得转载。【转载请注明来源】描述。属性规则用于对象属性的类型进行逻辑【版权所有，侵权必究】未经授权，禁止复制转载。判定，它的主要效果是根据对象本身的特征或原创内容，盗版必究。【本文受版权保护】人为逻辑，决定当前属性是否必须存在，或者【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。当前属性应该以怎样的方式进行类型判定。也【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】因为规则是对属性的描述，所以，只有在 D原创内容，盗版必究。原创内容，盗版必究。ict、Tuple 中可以使用规则。

在下文学习完 Rule 之后，你可以通过【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】它定义自己的任意规则。

类型【访问 www.tangshuang.net 获取更多精彩内容】

数据类型（Type，本文简称“类型”），【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.net是指一个变量的本质特征，TySheMo 著作权归作者所有，禁止商业用途转载。【转载请注明来源】中的类型关注数据结构，以及结构上每个节点原创内容，盗版必究。【原创内容，转载请注明出处】的类型。什么是“变量的本质特征”呢？就是【原创内容，转载请注明出处】【作者：唐霜】你需要知道这个变量，它的内在结构，以及嵌转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】套在它结构节点上的更深层级的类型。

复杂类型由原型和规则构成。【关注微信公众号：wwwtangshuangnet】

例如，你称呼一个小男孩是一个“人”，这里原创内容，盗版必究。【原创不易，请尊重版权】的“人”就是“小男孩”的本质特征，“人”【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。所拥有的结构体系，“小男孩”也应该拥有，【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net否则“小男孩”就不是“人”。明白这一点之【原创不易，请尊重版权】【本文受版权保护】后，“人”拥有什么结构，“一个小男孩”就转载请注明出处：www.tangshuang.net【未经授权禁止转载】会拥有什么结构，而且还会在“人”的共性上【本文首发于唐霜的博客】【原创不易，请尊重版权】多出一些特征。如果将“小男孩”视为一个变【未经授权禁止转载】【原创不易，请尊重版权】量，那么“人”就是他的数据类型。他具备“【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。人”的结构，以及人“可以说话”“可以走路本文作者：唐霜，转载请注明出处。【转载请注明来源】”等方法。

从某种意义上讲，原型也是一种类型，但是由【原创内容，转载请注明出处】【版权所有】唐霜 www.tangshuang.net于原型是原子层面的，它无法描述有结构的数原创内容，盗版必究。本文作者：唐霜，转载请注明出处。据，只能描述无结构的数据。举个例子，原型【本文首发于唐霜的博客】【原创不易，请尊重版权】可以指出某个变量应该是一个数组，但是，它【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。无法描述这个数据的内部结构，无法描述数组本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】内每个元素的类型。

现在我们要反过来思考，作为“人”这个概念【本文受版权保护】【版权所有】唐霜 www.tangshuang.net，怎么去检测这个小男孩是不是“人”。一个【未经授权禁止转载】【未经授权禁止转载】数据类型，如何去判别一个变量是不是该数据【本文受版权保护】【关注微信公众号：wwwtangshuangnet】类型？在 TySheMo 中，我们需要借【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。助“类型容器”著作权归作者所有，禁止商业用途转载。来实现这个目的。数据类型本身无法用代码来【转载请注明来源】【本文受版权保护】表述（这句话有误，因为我们定义一个 cl原创内容，盗版必究。转载请注明出处：www.tangshuang.netass 本质上就是在定义一个数据类型），【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。但是，我们可以通过一个类型容器，使得数据本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。类型是可以被表达的。而要得到这个类型容器【转载请注明来源】【本文首发于唐霜的博客】，就是 TySheMo 提供的 Type【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net。

TySheMo 将抽象的“数据类型”进行【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】提炼，用“类型容器”这个可以用代码表达的【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】东西代替。

【本文受版权保护】【作者：唐霜】【本文受版权保护】原创内容，盗版必究。

基于 Type，我们可以定义任意的数据类【作者：唐霜】本文版权归作者所有，未经授权不得转载。型。等你学了 Type 的使用方法之后，【原创内容，转载请注明出处】【未经授权禁止转载】你也可以定义自己的数据类型了。

元【本文受版权保护】

元（Meta）是指对一个字段的描述，即字【未经授权禁止转载】【关注微信公众号：wwwtangshuangnet】段的元数据。对应 SQL 数据库中字段结本文作者：唐霜，转载请注明出处。【未经授权禁止转载】构的各个配置项。Meta 是对模型字段的本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。描述，tyshemo 目标是完成前端数据【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net建模，前端数据建模主要目标是解决在业务数未经授权，禁止复制转载。【版权所有，侵权必究】据进行展示和交互时，保持其准确性。所以，【转载请注明来源】【版权所有】唐霜 www.tangshuang.net在 tyshemo 中，我们用 Meta【原创内容，转载请注明出处】未经授权，禁止复制转载。 来描述一个字段，通过阅读这个 Meta【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。，可以了解系统中该字段的各个方面。

元由多个属性（Attribute）组成，【版权所有，侵权必究】【转载请注明来源】每一个方面的描述就是一个 Attribu【版权所有，侵权必究】【版权所有，侵权必究】te。类型是其中的一个属性，除了类型之外【本文受版权保护】本文版权归作者所有，未经授权不得转载。，还有字段默认值、是否必填、是否禁用、校转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。验逻辑等属性。下文会详细阐述 Meta 【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】的用法。

模式原创内容，盗版必究。

模式（Schema）是指用于描述数据每个本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】属性的详细描述的集合。说的简单点，就是元【作者：唐霜】著作权归作者所有，禁止商业用途转载。数据的集合，有点类似 sql 数据库的结【原创不易，请尊重版权】【版权所有，侵权必究】构描述，“包含了那些字段，每个字段的结构【版权所有】唐霜 www.tangshuang.net【作者：唐霜】是怎样的”。模式开始针对业务场景进行抽象【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。。在业务代码中，我们对一个对象的每一个属【关注微信公众号：wwwtangshuangnet】【本文首发于唐霜的博客】性（类似字段）进行描述（类似字段结构），【本文受版权保护】【访问 www.tangshuang.net 获取更多精彩内容】得到的一个完整的数据描述就是 Schem【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.neta。

模式由多个元组成。【访问 www.tangshuang.net 获取更多精彩内容】

TySheMo 的模式是一个 js cl著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】ass，可以用来定义一个对象数据包含了那【作者：唐霜】转载请注明出处：www.tangshuang.net些属性字段，每个属性的具体逻辑是怎样的。【未经授权禁止转载】转载请注明出处：www.tangshuang.net它并不关心实际的数据是怎样的，它关心的是【原创内容，转载请注明出处】【版权所有】唐霜 www.tangshuang.net数据的抽象逻辑。当数据还不存在时，这个数本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net据的每个字段要符合哪些逻辑。它相当于是一【作者：唐霜】原创内容，盗版必究。个无状态的武器库，用来控制数据应该如何产著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】生、变化和读取。

在 TySheMo 中，通过 Schem【作者：唐霜】【本文首发于唐霜的博客】a 这个类来创建一个 schema 实例转载请注明出处：www.tangshuang.net原创内容，盗版必究。。一个 schema 实例是无状态的，它转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】不保存数据，它就像一个管道一样，接收数据【作者：唐霜】【转载请注明来源】，并处理数据，输出一个完全符合校验逻辑，本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】不会报错的数据。通过下文对 Schema本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。 的学习，你可以快速掌握这项技术。

模型【本文受版权保护】

数据模型是一个数据管理器，它通过内部状态本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。管理着数据，在你需要使用的时候从中取出数原创内容，盗版必究。本文作者：唐霜，转载请注明出处。据，也可以更新数据。TySheMo 的 本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.netModel 是基于 Schema 的，也转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net就是说，一个 Model 它必须保持着一本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】个 schema 实例，用来作为模型提供【本文受版权保护】未经授权，禁止复制转载。数据的抽象结构的基础，通过 schema本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】，模型中的数据变化具有非常严格控制逻辑，【本文首发于唐霜的博客】原创内容，盗版必究。不会让用户随便就能对数据进行任意值的修改原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。和提交。除此之外，TySheMo Mod【本文受版权保护】转载请注明出处：www.tangshuang.netel 还提供数据观察和响应能力，在调用模【未经授权禁止转载】未经授权，禁止复制转载。型的更新方法之后，你所设置的观察回调会被本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】执行。

Model 将会是和业务代码结合紧密的一著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。个东西，因此，当我在设计 Model 时本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net，所站在的角度就不再是纯粹的技术抽象层面【原创不易，请尊重版权】【本文受版权保护】去思考问题，而是更多的要考虑实际的业务场【关注微信公众号：wwwtangshuangnet】【原创内容，转载请注明出处】景。我们可以想象一种业务场景，就是从后端原创内容，盗版必究。【未经授权禁止转载】拿到数据后，通过数据模型，将后端给的数据本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。回写到模型中，这样，我可以在不做任何多余未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。操作的情况下，让数据高可用。

在设计时，我将一个模型设计为 Model【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。 的继承类，也就是如下的写法：

import { Model } from 'tyshemo'

class SomeModel extends Model {
  static some = {
    type: String,
    default: '',
  }
}

这样，创建一个模型之后，你需要实例化这个本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。模型为一个具体的对象，才能使用这个模型。【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。这主要是考虑到：1. 模型不应该在应用一原创内容，盗版必究。未经授权，禁止复制转载。运行时就消耗内存，而是在使用的时候再去实【关注微信公众号：wwwtangshuangnet】【本文首发于唐霜的博客】例化出来。2. 同一个模型可能在同一个页【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。面需要实例化多个。

这样的设计也是经过了实践验证的。这有利于【本文受版权保护】【转载请注明来源】我们不断的去扩展模型，根据不同的业务场景原创内容，盗版必究。转载请注明出处：www.tangshuang.net和实际的代码逻辑来进行控制。

总而言之，模型是业务中，对数据进行管理、【原创内容，转载请注明出处】【版权所有】唐霜 www.tangshuang.net使用的对象。也是 TySheMo 的最顶未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net层设计。

Store原创内容，盗版必究。

在模型中，我们需要保管一个状态，用来存放【作者：唐霜】本文版权归作者所有，未经授权不得转载。数据。而在 TySheMo 中，这个用来本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。保管数据的状态容器，就是 Store。S【版权所有】唐霜 www.tangshuang.net【作者：唐霜】tore 是基于响应式编程所开发的状态容本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】器，它是可观察的，开发者可以根据它内部的【转载请注明来源】【版权所有，侵权必究】状态变化来决定做什么事情。在 TyShe【本文首发于唐霜的博客】【未经授权禁止转载】Mo 中，每一个 Model 内部都有一本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。个 Store 的实例，用来管理和存储模【本文首发于唐霜的博客】【本文首发于唐霜的博客】型上的数据。但是 Store 也可以脱离原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。 Model 单独使用，这样，作为开发者【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】，你可以根据自己的需要来使用 TyShe【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】Mo 中的 Store 管理自己的数据。

在后面的章节中，我们有详细的教程告诉你如【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。何使用 Store。

小结未经授权，禁止复制转载。

TySheMo 从微观的数据规则到宏观的【原创不易，请尊重版权】【原创不易，请尊重版权】数据模型，给出了一个完成的前端数据建模的【转载请注明来源】原创内容，盗版必究。实现。Tyshemo 的知识体系，大致为转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。一个层层递进的设计：

                               Validator      Store ----+
                                   |                    |
Prototype ----+                    |                    |
              |                    |                    |
              +------ Type ------ Meta ----- Schema ----+--> Model
              |        |
Rule ---------+        |
                       |
                +------+------+
                |             |
                v             v
               Ty       Parser, Mocker

TySheMo 体系结构，它们处于数据的【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】：Prototype 原子级别；Rule原创内容，盗版必究。【本文首发于唐霜的博客】 逻辑级别；Type 校验级别；Meta著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】 字段级别；Schema 结构级别；Mo未经授权，禁止复制转载。【作者：唐霜】del 应用级别（包含了 Store 这【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】个响应式的状态管理工具）。

这样的设计不仅将每一个层级的概念提炼后仍【原创不易，请尊重版权】【本文首发于唐霜的博客】然具有可行性，同时还符合我们对建模的认知著作权归作者所有，禁止商业用途转载。【作者：唐霜】。经过抽象之后的概念，完全脱离了业务逻辑本文作者：唐霜，转载请注明出处。【本文受版权保护】，形成一个可以脱离实际需求，完全服务于建原创内容，盗版必究。转载请注明出处：www.tangshuang.net模的 js 模块。这有利于在任何业务中，【本文受版权保护】转载请注明出处：www.tangshuang.net如果有需要，都可以把 TySheMo 拿转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net过来用，而不会受到限制。

快速入门【关注微信公众号：wwwtangshuangnet】

本章主要教会你如何快速的在你的项目中使用著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】 TySheMo。

安装【访问 www.tangshuang.net 获取更多精彩内容】

npm i tyshemo

引入到项目未经授权，禁止复制转载。

tyshemo 这个 npm 包提供了多著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】种被引用的方式。

 import { Model } from 'tyshemo' // webpack构建环境中使用

const { Model } = require('tyshemo') // nodejs等环境中使用

tyshemo 导出的默认方式是 com本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】monjs，但是它的源码不是纯的 ES6【作者：唐霜】【版权所有】唐霜 www.tangshuang.net 源码，它引入了第三方 npm 库，所以【本文受版权保护】【未经授权禁止转载】，不能直接在 ES6 系统中直接使用，需【访问 www.tangshuang.net 获取更多精彩内容】【本文首发于唐霜的博客】要通过构建工具打包。

为了方便使用，tyshemo 输出一个完【作者：唐霜】著作权归作者所有，禁止商业用途转载。整的 bundle 文件，以 umd 规【作者：唐霜】【原创不易，请尊重版权】范导出接口，可以直接在页面引入。

<script src="/node_modules/tyshemo/dist/tyshemo.min.js"></script>
<script>
const { Model } = window['tyshemo']
</script>

因为遵循 umd 规范，所以你可以在 r【转载请注明来源】【转载请注明来源】equire.js 等 amd 规范的框转载请注明出处：www.tangshuang.net【转载请注明来源】架中使用 bundle 方式。另外，你可著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】以使用 dist/ty.min.js，如【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】果你只需要使用到类型系统，而不需要其他部【本文首发于唐霜的博客】原创内容，盗版必究。件的话。ty 是 TySheMo 的类型【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net系统，你可以使用它完成类型系统的构建，以本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。及 tyshemo-service 的搭【本文首发于唐霜的博客】【作者：唐霜】配使用。

使用【版权所有】唐霜 www.tangshuang.net

TySheMo 有很多接口。我们在业务中【版权所有】唐霜 www.tangshuang.net【转载请注明来源】最常用的是两个，一个是利用类型校验能力，原创内容，盗版必究。【转载请注明来源】对拿到的数据进行检验。另一个则是使用 M【作者：唐霜】【原创不易，请尊重版权】odel 在业务中管理数据，确保数据的可转载请注明出处：www.tangshuang.net【版权所有，侵权必究】靠性。

数据类型校验本文作者：唐霜，转载请注明出处。

// person.type.js

import { Dict, List, Range } from 'tyshemo'

export PersonDict = new Dict({
  name: String,
  age: Number,
})

export PersonList = new List([PersonDict])

export PersonResponse = new Dict({
  code: new Range({ min: 0, max: 100000, minBound: true }),
  data: PersonList,
})

// 业务代码 person.service.js

import { PersonResponse } from './person.type.js'

export getPersons(params) {
  // 当从用户接口返回的数据不符合 PersonResponse 定义时，会报错
  return fetch('xxx', params).then(res => res.json()).then((data) => {
    PersonResponse.assert(data) // 当类型校验失败时，会抛出错误，你可以在 catch 中捕获该错误提示
    return data
  })
}

数据规整化【原创不易，请尊重版权】

在你的业务代码中使用后台返回的数据直接渲转载请注明出处：www.tangshuang.net【作者：唐霜】染？No！你应该建立自己的数据模型，该数未经授权，禁止复制转载。【未经授权禁止转载】据模型拥有你渲染需要的字段，后台返回的数本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net据作为源输入到模型中，经过解析和调整，由【版权所有】唐霜 www.tangshuang.net【本文受版权保护】模型输出统一规格的数据，这样，未来你的接【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。口数据发生变化，你只需要在模型的解析方法未经授权，禁止复制转载。【未经授权禁止转载】中进行调整，而无需修改渲染层面的数据来适本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。应。

import { Model } from 'tyshemo'

export class PersonModel extends Model {
  static name = {
    type: String,
    default: 'unknow',
  }
  static age = {
    type: Number,
    default: 0,
  }
}

export class PersonPage extends React.Component {
  constructor(props) {
    super(props)

    const person = new PersonModel()
    this.person = person

    // 监听 model 中的数据变化，当数据发生变化时，强制重新渲染组件
    person.watch('*', () => this.forceUpdate())
  }
  grow() {
    直接修改模型属性，由于其内部的响应式系统，会触发上面 watch 所绑定的回调函数，从而触发 this.forceUpdate，最终带来视图重绘
    this.person.age ++
  }
  render() {
    const { name, age } = this.person
    return (
      <div>
        <span>{name}</span>
        <span onClick={() => this.grow()}>{age}</span>
      </div>
    )
  }
}

在下文中，我会详细的去讲解 Model 【本文首发于唐霜的博客】【未经授权禁止转载】的接口，学习完之后，你就可以理解上面这段原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】代码是怎么工作的了。

原型未经授权，禁止复制转载。

你可以使用 js 原生接口（标准库或特定【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。结构）作为原型：

• String: 字符串【版权所有】唐霜 www.tangshuang.net
著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】
• Number: 数字，不包含 未经授权，禁止复制转载。NaN "123" 和 本文版权归作者所有，未经授权不得转载。Infinity
本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。
• Boolean: 【转载请注明来源】true 或 本文版权归作者所有，未经授权不得转载。false
【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net
• Object: 字面量对象，例如【本文首发于唐霜的博客】{} 需要注意的是，用 class 实例化的【转载请注明来源】【版权所有】唐霜 www.tangshuang.net对象不符合本原型
【版权所有，侵权必究】【版权所有，侵权必究】【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】
• Array: 字面量数组，例如 【关注微信公众号：wwwtangshuangnet】[]
著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。
• Function: 函数【访问 www.tangshuang.net 获取更多精彩内容】
【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。
• RegExp: 正则表达式转载请注明出处：www.tangshuang.net
【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。
• /[0-9]/（正则表达式实例）: 字符【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】串，必须符合正则表达式的检查，它会用正则【本文首发于唐霜的博客】【未经授权禁止转载】表达式的 test 方法作为判定逻辑
【作者：唐霜】【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】
• Symbol: symbol【转载请注明来源】
本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net
• NaN: NaN （数字）注意，js 原【关注微信公众号：wwwtangshuangnet】【作者：唐霜】生的 isNaN 会把字符串等非数字判定【转载请注明来源】【本文首发于唐霜的博客】为 true，TySheMo 做了优化，【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】会返回 false
未经授权，禁止复制转载。【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。
• Infinity【关注微信公众号：wwwtangshuangnet】
转载请注明出处：www.tangshuang.net【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net
• Date: Date 的实例本文作者：唐霜，转载请注明出处。
【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。
• Promise: Promise 的实例
未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net

上面的规则利用了 js 原生的能力来进行【原创不易，请尊重版权】【本文首发于唐霜的博客】判断，虽然上面列举了不多，但是，任何一个实例对象，都可以用它的类来作为原【转载请注明来源】原创内容，盗版必究。型，例如 let some = new 【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。Some() 中 Some 作为 som转载请注明出处：www.tangshuang.net【转载请注明来源】e 的原型。因此，基于这种内置逻辑，其实原型是有无【本文受版权保护】著作权归作者所有，禁止商业用途转载。穷多的。

使用 TySheMo 内置原型：未经授权，禁止复制转载。

• Int: 整数【本文受版权保护】
【转载请注明来源】【作者：唐霜】【未经授权禁止转载】
• Float: 小数原创内容，盗版必究。
【本文受版权保护】【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】
• Negative: 负数【本文受版权保护】
本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。【原创不易，请尊重版权】
• Positive: 正数【未经授权禁止转载】
本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。未经授权，禁止复制转载。
• Finity: 有穷数（相对于 InFi原创内容，盗版必究。【作者：唐霜】nity 无穷数，无符号 ∞）
本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。
• Zero: 零【版权所有】唐霜 www.tangshuang.net
【转载请注明来源】转载请注明出处：www.tangshuang.net【未经授权禁止转载】原创内容，盗版必究。
• Natural: 自然数本文作者：唐霜，转载请注明出处。
【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。【原创不易，请尊重版权】
• Numeric: 数字型字符串，例如 &【作者：唐霜】转载请注明出处：www.tangshuang.net#8220;123”
本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。
• String8: 长度最大为 8 位的字【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。符串
著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。本文作者：唐霜，转载请注明出处。
• String16: 长度最大为 16 的本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。字符串
【转载请注明来源】未经授权，禁止复制转载。【作者：唐霜】著作权归作者所有，禁止商业用途转载。【转载请注明来源】
• String32: 长度最大为 32 的本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。字符串
本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。原创内容，盗版必究。转载请注明出处：www.tangshuang.net
• String64: 长度最大为 64 的原创内容，盗版必究。未经授权，禁止复制转载。字符串
【本文受版权保护】转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。【本文受版权保护】本文版权归作者所有，未经授权不得转载。
• String128: 长度最大为 128【转载请注明来源】本文作者：唐霜，转载请注明出处。 的字符串
【作者：唐霜】【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】
• Null: null本文版权归作者所有，未经授权不得转载。
原创内容，盗版必究。【未经授权禁止转载】【作者：唐霜】
• Undefined: undefined
【未经授权禁止转载】【原创内容，转载请注明出处】【原创不易，请尊重版权】
• None: null|undefined
【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】【未经授权禁止转载】
• Any: 任何值本文版权归作者所有，未经授权不得转载。
转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。【本文受版权保护】

在具体写代码的时候，这些原型总是位于数据原创内容，盗版必究。转载请注明出处：www.tangshuang.net校验链的最末端。

类型【作者：唐霜】

本章详细讲解类型容器的使用。前文讲到，类原创内容，盗版必究。未经授权，禁止复制转载。型容器是 TySheMo 对数据的结构类本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】型的具体化，帮助开发者判断某个变量是否符【关注微信公众号：wwwtangshuangnet】【未经授权禁止转载】合某种结构类型。

TySheMo 中内置了 6 种常见的结【版权所有】唐霜 www.tangshuang.net【本文受版权保护】构类型。Dict, List, Tupl【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】e, Enum, Range, Mapp原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】ing, 其中最常用的莫过于 Dict 【原创不易，请尊重版权】【原创不易，请尊重版权】和 List。我们在 TySheMo 体原创内容，盗版必究。【作者：唐霜】系下使用类型容器，不是去定义某个数据结构转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net，而是用来判断某个变量是否符合某个结构类转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】型。

TySheMo 中创建类型容器的基础是 【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.netType 类，Dict, List, T本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。uple, Enum, Range, M【本文受版权保护】【关注微信公众号：wwwtangshuangnet】apping 全都是基于Type 扩展出【版权所有，侵权必究】【原创内容，转载请注明出处】来的。

Type【访问 www.tangshuang.net 获取更多精彩内容】

作为类型容器的基础，Type 类创建基于未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。 Prototype 的类型容器。也就是【作者：唐霜】【本文受版权保护】说，在进行实例化的时候，你应该传入 pr【本文受版权保护】转载请注明出处：www.tangshuang.netototype 作为参数。

const SomeType = new Type(String)

但是在实际编程的时候，你不会这样去做，我【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net们 100% 只会用到 Dict, Li【未经授权禁止转载】【本文受版权保护】st, Tuple, Enum, Ran未经授权，禁止复制转载。未经授权，禁止复制转载。ge, Mapping. 在这些扩展出来著作权归作者所有，禁止商业用途转载。【作者：唐霜】的类型中，每个节点，可以直接接收 pro著作权归作者所有，禁止商业用途转载。【本文受版权保护】totype，而无需自己写一个 new 【原创内容，转载请注明出处】【访问 www.tangshuang.net 获取更多精彩内容】Type。

得到一个类型容器之后，你就可以使用类型容【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.net器的方法进行类型校验了。下方的方法是 D【本文受版权保护】原创内容，盗版必究。ict, List, Tuple, En【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】um, Range, Mapping 都未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。具备的。

assert【未经授权禁止转载】

断言某个值是否符合当前类型。【原创不易，请尊重版权】

import { Dict } from 'tyshemo'

const SomeDict = new Dict({
  name: String,
  age: Number,
})

SomeDict.assert({
  name: 'tomy',
  age: 10,
})

assert 方法不返回任何内容，但是它著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】会在断言失败时使用 throw 抛出错误【原创内容，转载请注明出处】未经授权，禁止复制转载。，中断程序执行。

catch【原创内容，转载请注明出处】

catch 方法用于抓取类型校验过程中的【本文受版权保护】【作者：唐霜】错误，如果错误发生，返回错误（一个 Ty未经授权，禁止复制转载。转载请注明出处：www.tangshuang.netpeError 实例），如果没有错误，返【本文受版权保护】【本文首发于唐霜的博客】回 null。

const error = SomeDict.catch({
  name: 'tomy',
  age: 10,
})

test【关注微信公众号：wwwtangshuangnet】

test 方法用于判定校验是否通过，通过【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。返回 true，不通过返回false。

const data = {
  name: 'some',
  age: 0,
}
if (SomeDict.test(data)) {
  // do something
}

track本文版权归作者所有，未经授权不得转载。

track 方法返回一个 Promise【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】 实例，在校验过程中会抓取错误，如果错误本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。发生，会 reject 抛出错误，如果通【转载请注明来源】著作权归作者所有，禁止商业用途转载。过，则 resolve null。

SomeDict.track({
  name: null,
}).catch(error => console.log(error))

trace【访问 www.tangshuang.net 获取更多精彩内容】

trace 方法和 track 方法的使【作者：唐霜】【关注微信公众号：wwwtangshuangnet】用是一模一样的，但是 trace 在进行【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net数据校验的时间点上不同。track 会在【原创内容，转载请注明出处】原创内容，盗版必究。你输入数据的时候进行校验，而 trace【本文受版权保护】未经授权，禁止复制转载。 会在一个异步执行中去校验数据，也就是延【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】后校验。这样做的好处是，在一些数据类型不【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。影响业务的场景中，你仅想知道数据是否符合转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。类型，而不想让校验过程阻塞界面渲染，就可著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】以使用 trace 替代 track。

但是，你需要注意的是，由于是异步校验，如未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】果你在异步任务没有执行之前修改了传入的数【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.net据，就会发生不可预测的问题，因为当异步校【本文受版权保护】【访问 www.tangshuang.net 获取更多精彩内容】验开始时，已经不是要校验原始数据了。

Strict/strict/toBeSt【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。rict

严格模式主要是为规则设定的。在严格模式下【原创不易，请尊重版权】【转载请注明来源】，某些规则会失效，例如 ifexist。本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】严格模式会带来如下影响：

• Dict 检测的对象的字段不能多也不能少【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net，必须是完全重合的
本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。【本文受版权保护】
• Dict, Tuple 中 ifexis转载请注明出处：www.tangshuang.net【作者：唐霜】t 无效
【原创内容，转载请注明出处】原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】

其中 Strict 和 strict 是原创内容，盗版必究。原创内容，盗版必究。属性，它们是完全一样的，只是为了给开发者【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】提供不同大小写使用习惯的选择。

const SomeStrictDict = SomeDict.Strict

你会得到一个全新的 Dict 实例，这个【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net实例复用了原来实例的配置参数，但是和原来【原创内容，转载请注明出处】【作者：唐霜】的实例没有任何关系。

toBeStrict 是一个方法。调用它【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】，你会将当前这个实例转化为一个严格模式的【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】实例。

SomeDict.toBeStrict(true)

在使用时，应该小心。因为一般情况下，我们【版权所有，侵权必究】未经授权，禁止复制转载。经常复用定义好的类型容器，如果你在业务中【版权所有】唐霜 www.tangshuang.net【转载请注明来源】修改了严格模式，可能导致在另外的地方的校原创内容，盗版必究。【本文首发于唐霜的博客】验会失败。一般仅仅在一次性使用一个类型容原创内容，盗版必究。本文作者：唐霜，转载请注明出处。器时，可能用到 toBeStrict.

Dict原创内容，盗版必究。

Dict 用于校验字典结构，对应 js 【本文首发于唐霜的博客】原创内容，盗版必究。中的对象，和 python 中的 dic本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。t。在实例化时，你必须传入一个对象，这个【原创不易，请尊重版权】【本文首发于唐霜的博客】对象规定了所有内部结构，你可以通过阅读内原创内容，盗版必究。转载请注明出处：www.tangshuang.net部结构就可以了解后台 api 应该返回什未经授权，禁止复制转载。【原创不易，请尊重版权】么数据给你。基于这种想法，TySheMo著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。 可以作为前后端确定返回数据结构和类型的【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。一个协商工具。

const SomeDict = new Dict({
  name: String,
  age: 10,
})
const OtherDict = new Dict({
  some: SomeDict, // 复用定义好的类型
  other: ifexist(SomeDict), // 使用规则
  total: ifnotmatch(Number, 0), // 通过 ifnotmatch 可以在类型校验失败时设置默认值
})

可以说，Dict 是我们用到最多的一种类【版权所有，侵权必究】【未经授权禁止转载】型。它的使用场景及其广泛，而且有非常高的未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。复用需求，因此，在 Type 的基础上，原创内容，盗版必究。【本文受版权保护】Dict 还拥有另外 2 个方法。

extend【版权所有】唐霜 www.tangshuang.net

扩展当前 dict 得到一个新 dict本文作者：唐霜，转载请注明出处。【转载请注明来源】。新 dict 天生拥有当前 dict 【版权所有，侵权必究】【原创不易，请尊重版权】的全部属性，但是你可以通过传入新的属性值著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。进行覆盖，同时，你可以传入原本没有的属性【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net来添加属性。

const Some2Dict = SomeDict.extend({
  age: Numeric, // 修改一个原有属性
  height: Number, // 添加一个新属性
})

extract【未经授权禁止转载】

从当前 dict 中提炼部分属性得到一个【原创内容，转载请注明出处】【本文受版权保护】新 dict。新 dict 的属性一定是未经授权，禁止复制转载。【关注微信公众号：wwwtangshuangnet】原 dict 属性的子集。如果你需要该属转载请注明出处：www.tangshuang.net【转载请注明来源】性被提炼，只需要设置为 true 即可。

const Some3Dict = Some2Dict.extract({
  // some3 将只有 name 和 height 这两个属性
  name: true,
  height: true,
})

你可以将 extract 和 exten著作权归作者所有，禁止商业用途转载。【作者：唐霜】d 连起来用，起到一定的效果。

const Some4Dict = Some2Dict.extract({
  name: true,
  height: true,
}).extend({
  weight: Number,
})

这在一些必要的场景下非常有用，可以减少代转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。码量，但同时又可以非常明晰的知道一个 d【本文首发于唐霜的博客】【本文首发于唐霜的博客】ict 都必须拥有那些校验规则。

List本文作者：唐霜，转载请注明出处。

List 用于校验列表结构，对数组进行检【原创不易，请尊重版权】未经授权，禁止复制转载。查，对应 python 中的 list。【作者：唐霜】【本文首发于唐霜的博客】在 js 中，一个数组的内部结构是随意的【原创不易，请尊重版权】【转载请注明来源】，但是，在真实的业务场景中，一个列表总是【本文首发于唐霜的博客】【本文受版权保护】要求内部元素是具备结构化特征的。一个列表【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net中的元素，往往只会有一种类型，而不会像 【本文受版权保护】著作权归作者所有，禁止商业用途转载。js 的数组中一样，任意类型都可以。

const SomeList = new List([SomeDict])

这样规定之后，要求被检查的数组的每一个元未经授权，禁止复制转载。【作者：唐霜】素必须符合 SomeDict 类型。

const SomeList = new List([SomeDict, Some2Dict])

这样规定之后，要求被检查的数组的元素，必【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。须是 SomeDict 或 Some2D转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】ict 中任意一种类型，适合列表中有多种【版权所有，侵权必究】【原创内容，转载请注明出处】结构类型的时候用。

List 结构往往对应后台输出的数组，因未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。此，如果这个数组中一个元素都没有，也不会【作者：唐霜】著作权归作者所有，禁止商业用途转载。引发错误。因为正常业务中，数组中不存在数【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net据是常有的事。

Tuple【本文首发于唐霜的博客】

Tuple 用于校验元组结构，对数组进行【本文首发于唐霜的博客】原创内容，盗版必究。检查，对应 python 中的 tupl本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。e。在业务场景中，我们有时需要一个数组的转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】元素个数是确定的，每一个位置上元素的类型【版权所有，侵权必究】转载请注明出处：www.tangshuang.net也是确定的。例如对函数的参数列表进行检查【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。的时候，Tuple 则是最佳的选择。

const SomeTupe = new Tuple([String, Number])

function some(...args) {
  SomeTuple.assert(args)
}

Tuple 的末尾元素可以使用 ifex【原创内容，转载请注明出处】【本文受版权保护】ist，非末尾元素使用 ifexist 【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】无意义。

Enum本文作者：唐霜，转载请注明出处。

Enum 表示枚举，被校验的值必须符合被【作者：唐霜】著作权归作者所有，禁止商业用途转载。枚举的值中的某一个。在业务场景中，实际上【本文首发于唐霜的博客】【未经授权禁止转载】我们可能经常用到 Enum，因为我们要检未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net验的数据，经常只要符合两种类型的其中之一未经授权，禁止复制转载。【关注微信公众号：wwwtangshuangnet】即可。

const SomeEnum = new Enum([Number, Numeric]) // 数字或则数字形式的字符串都行

Range本文版权归作者所有，未经授权不得转载。

Range 表示区间，被校验的数字必须在【转载请注明来源】本文作者：唐霜，转载请注明出处。规定的区间内。这个类型比较少用到。

const SomePercent = new Range({
  min: 0,
  max: 100,
  minBound: true, // 是否包含最小值，默认 true
  maxBound: false, // 是否包含最大值，默认 true
})

Mapping【作者：唐霜】

Mapping 表示映射关系表，可用于规【转载请注明来源】本文版权归作者所有，未经授权不得转载。定结构单一的对象类型结构。例如：

const SomeMapping = new Mapping({
  key: Numeric, // 属性名的类型
  value: Number, // 属性值的类型
})

可用于检查类似如下数据：【本文受版权保护】

{
  201908: 12,
  201909: 20,
  201910: 19
}

这种 key-value 类型规律且单一【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。的对象，且最重要的是 key 是在规律性【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。变化的，可以用 Mapping 来检查。

规则原创内容，盗版必究。

TySheMo 体系中的属性规则，仅适用【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。于 Dict 和 Tuple。为什么呢？【转载请注明来源】原创内容，盗版必究。只有 Dict 和 Tuple 中我们可【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。以确定属性，List 虽然也是数组，但是【原创内容，转载请注明出处】未经授权，禁止复制转载。它的元素个数是不定的，是一个弹性结构，无原创内容，盗版必究。原创内容，盗版必究。法运用属性规则。

你必须在属性的位置上使用这些规则，而不能未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】直接传给 Type 构造器。

const SomeDict = new Dict({
  some: ifexist(String),
})
const SomeTuple = new Tuple([
  Number,
  ifexist(String),
])

Tuple 相当于有确定的索引号的对象，本文版权归作者所有，未经授权不得转载。【本文受版权保护】因此，可以使用规则。但是在使用一些规则的本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】时候，要考虑它存在的意义，例如 ifex【本文受版权保护】原创内容，盗版必究。ist 仅适用末尾的元素，非末尾元素使用【版权所有，侵权必究】【作者：唐霜】无意义。

内置规则【本文受版权保护】

TySheMo 的内置规则全部是函数，规本文作者：唐霜，转载请注明出处。【本文受版权保护】则函数一般接收原型、类型和规则作为参数。原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】它们包含：

lazy【本文受版权保护】

异步规则。当一个类型需要异步加载的时候，【作者：唐霜】本文版权归作者所有，未经授权不得转载。可以使用该规则。它接收一个函数，用于返回本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】最终的类型。在最终的类型返回之前，所有的【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。校验都会被直接通过。

const SomeType = new Dict({
  some: lazy(fetchType), // 定义一个 fetchType 函数，用于从服务端抓取数据类型
})

在 fetchType 没有完成之前，s【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。ome 属性相当于遵循 Any。fetc原创内容，盗版必究。【转载请注明来源】hType也可以是一个同步函数，用于同步【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.net生成规则。

shouldmatch【访问 www.tangshuang.net 获取更多精彩内容】

必须满足传入的类型，如果不满足，则会抛出转载请注明出处：www.tangshuang.net【版权所有，侵权必究】传入的 message 作为错误信息。

const SomeType = new Dict({
  some: shouldmatch(String, '{keyPath} 必须是一个字符串'),
})

shouldnotmatch未经授权，禁止复制转载。

和 shouldmatch 相反，检查时【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net，不能是传入的类型，如果符合传入的类型，【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】反而会抛出错误，并用传入的 messag转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.nete 作为错误信息。

const SomeType = new Dict({
  some: shouldnotmatch(String, '{keyPath} 不能是一个字符串'),
})

match【本文受版权保护】

同时满足多条规则。match 接收一个数【本文首发于唐霜的博客】未经授权，禁止复制转载。组，但比较常用的场景是搭配 should转载请注明出处：www.tangshuang.net【作者：唐霜】match 和 shouldnotmat【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】ch 这两个规则来用。

const SomeType = new Dict({
  some: match([
    shouldmatch(String, '必须是一个字符串'),
    shouldmatch(Numeric, '必须是一个数字'),
  ]),
})

这样可以起到根据不同类型错误返回不同错误未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。提示的效果。

determine未经授权，禁止复制转载。

判定规则。用于根据不同的情况使用不同的规原创内容，盗版必究。转载请注明出处：www.tangshuang.net则。例如，你想先判定数据中是否存在某个字转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。段，如果存在的话，使用某个类型，如果不存【本文受版权保护】【转载请注明来源】在的话使用另外一个类型。

const SomeType = new Dict({
  some: determine(data => 'type' in data, String, Any),
})

它接收的参数为：未经授权，禁止复制转载。

• fn 用于接收当前节点的父值，返回 tr【版权所有，侵权必究】【本文首发于唐霜的博客】ue|false
【原创不易，请尊重版权】【作者：唐霜】【原创不易，请尊重版权】原创内容，盗版必究。转载请注明出处：www.tangshuang.net
• A 当 fn 返回 true 时所使用的原创内容，盗版必究。未经授权，禁止复制转载。类型
未经授权，禁止复制转载。【作者：唐霜】本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。
• B 当 fn 返回 false 时所使用著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】当类型
【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。

ifexist【版权所有，侵权必究】

根据属性存在情况进行校验。当属性不存在时著作权归作者所有，禁止商业用途转载。【转载请注明来源】，不进行任何校验。当属性存在时，必须符合【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。传入的类型。ifexist 是一个非常重【本文受版权保护】【作者：唐霜】要的规则，它可以让属性更加灵活。而且由于【版权所有，侵权必究】原创内容，盗版必究。规则本身是可以嵌套的，你还可以在 ife【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】xist 里面嵌套另外一个规则，例如 i未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.netfnotmatch。

const SomeType = new Dict({
  some: ifexist(String), // some 属性可以不存在，如果存在，必须是一个 String
})

ifnotmatch【访问 www.tangshuang.net 获取更多精彩内容】

如果被校验的属性不符合类型，则用传入的参【作者：唐霜】【版权所有】唐霜 www.tangshuang.net数作为默认值进行替代。

const SomeType = new Dict({
  some: ifnotmatch(Number, 0), // 如果 some 属性值不是 Number，那么直接将 some 属性设置为 0
})

它的第二个参数可以是一个函数，如果是一个原创内容，盗版必究。【本文首发于唐霜的博客】函数的话，会在校验失败时，执行该函数，并【本文首发于唐霜的博客】【版权所有，侵权必究】把该函数的返回结果作为默认值。

ifmatch【本文受版权保护】

和 ifnotmatch 相反，当接收到【未经授权禁止转载】【转载请注明来源】到值和传入到类型一致时，第二个参数会被使原创内容，盗版必究。【版权所有，侵权必究】用。

shouldexist转载请注明出处：www.tangshuang.net

判定该属性是否必须存在。它接收一个函数用本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。来进行判定如，如果返回 true，当被检【转载请注明来源】【作者：唐霜】查的数据没有该属性，就会报错。如果返回 本文作者：唐霜，转载请注明出处。【版权所有，侵权必究】false，当被检查的数据没有该属性，不本文作者：唐霜，转载请注明出处。【未经授权禁止转载】会报错。但无论返回 true 或 fal本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.netse，只要该属性存在，都应该满足传入的第【版权所有，侵权必究】【未经授权禁止转载】二个参数的类型。该函数接收的参数和 de本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】termine 规律一致。

const SomeType = new Dict({
  some: shouldexist(data => !!data.should, String),
})

shouldnotexist【作者：唐霜】

和 shuldexist 相反，当函数返【版权所有，侵权必究】【关注微信公众号：wwwtangshuangnet】回 true 时，不允许该属性存在，当函【原创内容，转载请注明出处】【版权所有，侵权必究】数返回 fasle 时，该属性可存在也可【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net不存在，存在时必须满足传入的类型。

const SomeType = new Dict({
  some: shouldnotexist(data => !!data.shouldnot, String),
})

这个规则有点绕，需要你在实践中多尝试。【本文受版权保护】

instance未经授权，禁止复制转载。

校验值是否为传入的类的实例。在 TySh原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。eMo 中，类似 String, Boo【未经授权禁止转载】【原创内容，转载请注明出处】lean 这些系统自带的变量都被作为校验著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。使用的原型去了。但是，如果真的想去校验一原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net个 new String(‘【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。xx’) 是否是 Strin【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。g 的实例时，就需要用到 instanc本文作者：唐霜，转载请注明出处。【未经授权禁止转载】e。

const SomeType = new Dict({
  some: instance(String),
})

equal【转载请注明来源】

用于对对象等需要进行深度比较的值。【转载请注明来源】

const SomeType = new Dict({
  some: equal({ ok: true }),
})

nullable本文作者：唐霜，转载请注明出处。

允许被检查到值为 null。【访问 www.tangshuang.net 获取更多精彩内容】

const SomeType = dict({
  some: nullable(String), // null 或者 String
})

当 some 属性值为 null 时，不【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。会返回错误。

lambda【访问 www.tangshuang.net 获取更多精彩内容】

用于对属性方法进行重写，以此让该方法拥有【未经授权禁止转载】未经授权，禁止复制转载。参数和返回值校验的能力。lambda 规【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net则接收两个参数，第一个参数必须是一个 T本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.netuple 类型容器，用于对方法函数对传入未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net参数进行校验，第二个参数是用于对函数返回【原创不易，请尊重版权】【转载请注明来源】值进行校验的类型容器。

const SomeTuple = new Tuple([Number, Number])
const SomeType = new Dict({
  do: lambda(SomeTuple, Number),
})

为了方便起见，我将它的第一个参数允许传入【未经授权禁止转载】【转载请注明来源】一个数组，该数组会自动实例化为一个 Tu【未经授权禁止转载】【转载请注明来源】ple。

const SomeType = new Dict({ 
  do: lambda([Number, Number], Number), 
})

Rule本文作者：唐霜，转载请注明出处。

在学习了前面的所有内置规则之后，我们来学本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】习这些规则背后的 Rule 这个类。

const SomeRule = new Rule({
  name: 'Some',
  validate: v => v !== 0,
  message: 'value should not be 0.',
})

所有上述规则生成器函数的最后，都是返回一【本文受版权保护】【转载请注明来源】个 Rule 的实例。因此，你实际上可以【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】使用这些 Rule 实例来做一些事。

validate【版权所有】唐霜 www.tangshuang.net

validate 方法用于对数据进行校验本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。，并返回一个 error 或 null。

bind著作权归作者所有，禁止商业用途转载。

bind 方法用于绑定一个函数，当 va本文版权归作者所有，未经授权不得转载。【本文受版权保护】lidate 校验中返回了错误，这个函数【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。一定会执行，接收 error 实例。

在一些规则中，例如 ifnotmatch著作权归作者所有，禁止商业用途转载。【本文受版权保护】, ifmatch 中，数据会被校验和改【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net写。但是，如果你这个时候想要对被校验的原著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。始所抛出的错误进行监控时，可以使用 bi【转载请注明来源】【原创内容，转载请注明出处】nd 方法：

const SomeRule = ifnotmatch(Number, 0)
const SomeType = new Dict({ some: SomeRule, })

SomeRule.bind(error => console.log(error))

这样，无论任何情况下，你都可以抓取到 S【版权所有，侵权必究】【原创不易，请尊重版权】omeRule 校验失败时抛出的错误。

unbind本文作者：唐霜，转载请注明出处。

解除 bind 的函数。【本文首发于唐霜的博客】

Ty【本文首发于唐霜的博客】

Ty 是 TySheMo 中的类型系统的本文作者：唐霜，转载请注明出处。【本文受版权保护】快捷集成工具，它让校验接口更接近我们的编【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】程直觉，而且，在我们写代码过程中，有的时【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。候你需要通过编辑器搜索功能，一次性搜索出【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net某些特定的校验逻辑，直接使用 Type 原创内容，盗版必究。未经授权，禁止复制转载。实例进行校验会让这种操作很麻烦，而如果有转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net一个基于 Ty 开头的标识，搜索就会方便【本文首发于唐霜的博客】【本文首发于唐霜的博客】很多。

import {
  Ty,
  Numeric, // 获取原型
  Dict, // 获取类型
  ifexist, // 获取规则
} from 'tyshemo/cjs/ty'

上面是 tyshemo 类型系统的导出快【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。捷入口，通过 tyshemo/cjs/t【作者：唐霜】【原创不易，请尊重版权】y.js 这个文件，你可以使用有关 ty本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。shemo 中定义的类型系统的所有功能。著作权归作者所有，禁止商业用途转载。【转载请注明来源】另外，Ty 这个特殊接口，具有更令人喜欢【原创不易，请尊重版权】【本文首发于唐霜的博客】的方法可以使用。

if (Ty.is(10).of(Number)) {
  // do something
}

Ty 上提供了如下的便捷方法。这些方法，【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。大部分都是链式的，理解起来会比较舒服。

expect.to.be著作权归作者所有，禁止商业用途转载。

类似于 assert 的功能。【版权所有】唐霜 www.tangshuang.net

Ty.expect(10).to.be(Number)

你也可以使用它的别名 expect.to【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。.match 这样看上去更符合词语的意思【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】。

Ty.expect(10).to.match(Number)

两则之间仅仅是一个别名而已，作用完全相同本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】。

catch.by【原创不易，请尊重版权】

类似于 type 实例的 catch 功【转载请注明来源】【版权所有】唐霜 www.tangshuang.net能。

const error = Ty.catch(10).by(Numeric)

track.by【作者：唐霜】

类似于 track 功能。【版权所有，侵权必究】

Ty.track(10).by(Numeric).catch(error => console.log(error))

trace.by转载请注明出处：www.tangshuang.net

Ty.tracc(10).by(Numeric).catch(error => console.log(error))

is.typeof本文版权归作者所有，未经授权不得转载。

用于判断一个类型是否是某值的类型。【访问 www.tangshuang.net 获取更多精彩内容】

if (Ty.is(Number).typeof(10)) {
  ...
}

is.of【作者：唐霜】

用于判断一个值是否符合一个类型。【关注微信公众号：wwwtangshuangnet】

if (Ty.is(10).of(Number)) {
  ...
}

decorate.with【原创不易，请尊重版权】

这是一个高级功能，用于对 ES6+ 的 【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。class 进行修饰。你需要了解“装饰器转载请注明出处：www.tangshuang.net原创内容，盗版必究。”这种操作符之后再来使用。而且，就目前而【未经授权禁止转载】转载请注明出处：www.tangshuang.net言，使用装饰器要求你的编译工具支持。

它支持对属性、方法的输入和输出进行装饰。

@Ty.decorate.with(SomeDict) // 修饰 constructor
class Some {
  constructor(some) {
    this.data = some
  }
  
  @Ty.decorate.with(String) // 修饰属性
  // 当修改类实例的时候，会检查这个属性的类型
  name = ''

  @Ty.decorate.with([Number, Number], Number) // 修饰方法返回值
  // 对
  plus(a, b) {
    return a + b
  }
}

装饰器本身不会识别被装饰成员是属性还是方【转载请注明来源】【本文受版权保护】法，只能靠开发者传入对应的格式来控制。对著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】于属性而言，只接收一个值，作为类型。而如【未经授权禁止转载】【原创内容，转载请注明出处】果是函数，一定是接收参数列表和返回值的类本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。型。

除了用来对类进行装饰，还可以用来生成可监【原创内容，转载请注明出处】【访问 www.tangshuang.net 获取更多精彩内容】测对象和函数。

const fn = Ty.decorate((a, b) => a + b).with([Number, Number], Number)

fn(1, 2) // ok
fn('1', '2') // throw error

const o = Ty.decorate({}).with({
  name: String,
  age: Number,
})

o.name = 'xxx' // ok
o.name = null // throw error

Ty.decorate 既是一个函数，也【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。是一个装饰器宿主。

create未经授权，禁止复制转载。

在某些情况下，你并不知道你应该创建一个 【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。Dict 还是一个 List，Ty.cr【关注微信公众号：wwwtangshuangnet】【转载请注明来源】eate 帮助你完成这个任务。

const SomeType = Ty.create(unknown)

监听功能著作权归作者所有，禁止商业用途转载。

Ty 提供一个监听错误的功能。在一些特殊转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net的情况下，而要获得监听能力，你必须实例化【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】一个 Ty 对象：

const ty = new Ty()

此时，实例对象 ty 才拥有监听能力。本文作者：唐霜，转载请注明出处。

bind【本文受版权保护】

绑定一个函数，用于在监听到错误发生时执行【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。。这个函数接收一个 Error 实例，即转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。错误发生时的错误实例。

const watch = error => record(error) // 创建一个函数，用于和你的监控系统对接，将错误信息记录到监控系统中
ty.bind(watch)

unbind著作权归作者所有，禁止商业用途转载。

用于解绑一个监听函数。【本文受版权保护】

ty.unbind(watch)

silent原创内容，盗版必究。

是否开启安静模式。开启安静模式后，不会在【原创不易，请尊重版权】本文版权归作者所有，未经授权不得转载。阻断程序运行，不在控制台输出错误。一旦开本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。启安静模式，Ty 中使用 throw 抛【本文首发于唐霜的博客】【版权所有，侵权必究】出错误的地方将受到影响，例如 expec【作者：唐霜】【本文首发于唐霜的博客】t.to.be, track.by, t【作者：唐霜】【关注微信公众号：wwwtangshuangnet】race.by。

ty.silent(true)

一般来说，不建议开启安静模式，但是在监听【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。了错误的时候，你可以通过开启安静模式减少原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net报错。

错误【本文受版权保护】

当我们使用 TySheMo 的类型检查系转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net统去检查一个数据时，在检查到数据不符合类【访问 www.tangshuang.net 获取更多精彩内容】【原创内容，转载请注明出处】型结构时，会有错误抛出。这个错误 err未经授权，禁止复制转载。【本文首发于唐霜的博客】or 是一个错误实例，即 Error 的原创内容，盗版必究。【原创内容，转载请注明出处】实例。Type 的错误是一个 Error【作者：唐霜】本文作者：唐霜，转载请注明出处。 的子集，具有特殊的属性。

错误收集和展示【原创不易，请尊重版权】

TySheMo 内部检查时会收集所有错误本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net，而非遇到检查失败就立即停止后续检查。也【本文首发于唐霜的博客】【作者：唐霜】就是说，它是遍历整个被检查对象后才把错误【版权所有，侵权必究】未经授权，禁止复制转载。返回的。在返回的错误中，你可以通过打印错未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。误 message 查看所有错误。例如：

const SomeType = dict({
  a: ifexist(tuple([
    new Enum([String, Boolean]),
    Number,
  ])),
  b: {
    title: String,
    count: Number,
  },
  c: shouldmatch(dict({
    name: String,
    age: Number,
  }), '{keyPath} 不是一个用户。'),
})
test(() => SomeType.assert({
  a: [1],
  b: 'null',
  c: null,
}))

TySheMo 抛出的错误将是一个包含了未经授权，禁止复制转载。【作者：唐霜】该对象所有错误的信息。比如上面这个校验，【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。会抛出如下的错误：

它有4条信息，a[0], a[1], b【原创内容，转载请注明出处】【转载请注明来源】, c，告诉了你四个位置上具体是什么错误未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。。

错误信息模板【版权所有】唐霜 www.tangshuang.net

你可以看到，上面的错误信息，前 3 条使本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net用了内置的错误信息模板。你可以通过修改模【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.net板来调整内置信息模板。

import { TyError } from 'tyshemo'

TyError.defaultMessages = {
  ...TyError.defaultMessages,
  exception: '{keyPath} 位置错误。',
}

模板以键值对形式存在，包括如下：【版权所有】唐霜 www.tangshuang.net

• exception: 类型不匹配错误【关注微信公众号：wwwtangshuangnet】
【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】原创内容，盗版必究。转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net
• unexcepted: 类型不应该匹配，【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】一般由 shouldnotmatch 抛转载请注明出处：www.tangshuang.net【版权所有，侵权必究】出
【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net
• dirty: 数组长度不匹配，一般由 T【作者：唐霜】【原创内容，转载请注明出处】uple 抛出
【未经授权禁止转载】【未经授权禁止转载】本文作者：唐霜，转载请注明出处。
• overflow: 对象属性多余，数组个【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。数超出，一般是在“严格模式”下抛出
【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。
• missing: 缺少属性或数组元素未经授权，禁止复制转载。
转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net【本文受版权保护】原创内容，盗版必究。
• illegal: 对于 Mapping 本文作者：唐霜，转载请注明出处。【本文受版权保护】类型而言，key 的类型不符合时，该错误【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net模板被使用
【版权所有，侵权必究】【本文受版权保护】转载请注明出处：www.tangshuang.net【未经授权禁止转载】原创内容，盗版必究。
• notin: 对于 Enum 类型而言，本文作者：唐霜，转载请注明出处。【转载请注明来源】如果类型不在枚举列表中，该错误模板被使用
【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。【本文受版权保护】【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net

在消息值里面，你可以使用字符串模板例如上【原创不易，请尊重版权】【本文受版权保护】面示例代码里面的 {keyPath}，可【转载请注明来源】本文作者：唐霜，转载请注明出处。以用到的有：

• keyPath: 错误发生的位置路径转载请注明出处：www.tangshuang.net
未经授权，禁止复制转载。【作者：唐霜】本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】
• should: 错误发生位置应该是什么类【作者：唐霜】原创内容，盗版必究。型
本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net【版权所有，侵权必究】
• receive: 错误发生位置接收到什么本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。值
本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。【作者：唐霜】【原创不易，请尊重版权】

错误信息序列化【本文受版权保护】

当你的 should 或 receive【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。 过长的适合，你阅读起来非常麻烦，TyS【本文受版权保护】【本文首发于唐霜的博客】heMo 提供了可以换行展示的能力，这样【本文受版权保护】原创内容，盗版必究。可以方便你阅读，要开启这个功能，你只需要本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】：

import { TyError } from 'tyshemo'

TyError.shouldBreakLongMessage = true

开启这个功能之后，你的消息里面的对象、数【版权所有，侵权必究】未经授权，禁止复制转载。组，会自动进行换行，这样可以方便你阅读，原创内容，盗版必究。转载请注明出处：www.tangshuang.net可以更好的知道错误的详情。

你可以看到，开启之后，b 那条错误里面的【作者：唐霜】著作权归作者所有，禁止商业用途转载。对象换行了。

错误信息脱敏【访问 www.tangshuang.net 获取更多精彩内容】

在一些系统中，你希望你收到的错误信息进行本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net脱敏，而非把错误内容完整的展示出来。你需【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。要关闭对应的功能：

import { TyError } from 'tyshemo'

TyError.shouldHideSensitiveData = true

关闭之后，最终打印出来的值会被脱敏。字符【原创不易，请尊重版权】本文版权归作者所有，未经授权不得转载。串显示为 “***̶【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】1; 数字显示为 ***。

错误信息格式化著作权归作者所有，禁止商业用途转载。

针对单条错误，你希望对这一条错误信息进行未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net单独格式化。你可以通过 error.fo【作者：唐霜】【作者：唐霜】rmat 方法实现。

const error = SomeType.catch(some)
error.format({ templates, jointag, shouldbreak, shouldusesensitive, keyPathPrefix })

• templates: 错误信息模板转载请注明出处：www.tangshuang.net
著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】未经授权，禁止复制转载。原创内容，盗版必究。
• breaktag: 多条信息的连接字符串【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】，默认为 ‘\n’未经授权，禁止复制转载。原创内容，盗版必究。;，即每条信息单独成行
【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net
• breakline: 是否要自动序列化【版权所有】唐霜 www.tangshuang.net
著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】
• sensitive: 是否脱敏？默认 t【未经授权禁止转载】【原创不易，请尊重版权】rue，不脱敏
【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】
• keyPathPrefix: 错误路径的【原创不易，请尊重版权】【作者：唐霜】前缀，默认为 $. 作为路径前缀（你可以【版权所有，侵权必究】【原创内容，转载请注明出处】修改 TyError.keyPathPr【作者：唐霜】本文版权归作者所有，未经授权不得转载。efix 来实现全局修改）
【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。【转载请注明来源】

注意：格式化之后，error 的 mes【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.netsage 被永久化转变。

为了方便快速格式化，不要传入那么多参数，本文版权归作者所有，未经授权不得转载。【本文受版权保护】我提供了 error.trnaslate未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。 方法，只需要传入一个 message 【本文首发于唐霜的博客】原创内容，盗版必究。就可以替换掉内部的 message。

Parser著作权归作者所有，禁止商业用途转载。

基于描述语言的类型解析器。未经授权，禁止复制转载。

描述语言原创内容，盗版必究。

Parser 是用以解析基于字符串描述的【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。 Type 构造器。它的目标是，一个类型【本文首发于唐霜的博客】【本文首发于唐霜的博客】容器的配置，由服务端返回。它类似于一些描本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】述语言，用字符串描述类型结构。

例如，服务端返回了如下的 json 作为本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】类型结构描述：

{
  "__def__": [
    {
      "name": "book",
      "def": {
        "name": "string",
        "price": "float"
      }
    }
  ],
  "name": "string",
  "age": "number",
  "has_football": "?boolean",
  "sex": "0|1",
  "dot": "='xxx'",
  "belong": "?='animal'",
  "vioce": "!number",
  "num": "string,numeric",
  "parents": "[string,string]",
  "books": [
    {
      "name": "string",
      "age": "number"
    }
  ],
  "body": {
    "head": "boolean",
    "neck": "boolean"
  }
}

它完全是基于字符串的描述的。但是很明显，【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。你可以大致读懂它的描述内容。只是有些符号【版权所有，侵权必究】转载请注明出处：www.tangshuang.net代表什么意义，你还需要学一下而已。前端在原创内容，盗版必究。【本文受版权保护】拿到这样一段描述 json 之后，怎么把未经授权，禁止复制转载。【原创内容，转载请注明出处】它解析为一个类型容器呢？

import Parser from 'tyshemo/cjs/parser'

const parser = new Parser()
const SomeType = parser.parse(json)

这样你就可以将描述文本转化为可运行的类型著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】容器。

基本语法未经授权，禁止复制转载。

以JSON文件的形式作为DSL文件。【本文首发于唐霜的博客】

{
  属性名：表达式，
}

以一个对象的形式约束接口返回的数据结构和著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。节点上数据的类型。表达式可以包含如下内容【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net：

原始类型本文版权归作者所有，未经授权不得转载。

{
  "name": "string", // name字段为string类型
  "age": "number" // age字段为number类型
}

所有的原始类型有如下：【原创内容，转载请注明出处】

string: 字符串
string8: 长度不超过8的字符串
string16: 
string32: 
string64: 
string128: 
number: 数字
int: 整数
float: 小数
negative: 负数
positive: 正数
zero: 零
natural: 自然数
infinity: 数字，无限大/无限小
finity: 数字，有限数
nan: NaN,
boolean: true或false
null: 
undefined: 
none: null或undefined或nan
symbol: Symbol
function: Function
array: 不限制内部元素的数组
object: 不限制内部节点的对象
numeric: 数字形式的字符串
any: 
date: Date实例，注意，不是字符串形式的 '2021-01-22' 这种形式
promise: Promise实例
error: Error实例
regexp: RegExp实例

到具体项目中，可由前后端约定，在以上基础转载请注明出处：www.tangshuang.net【未经授权禁止转载】类型基础上进行补充或覆盖。

复合类型本文作者：唐霜，转载请注明出处。

支持如下复合类型：原创内容，盗版必究。

• 列表：【版权所有，侵权必究】
  • "string[]" 单一字符串形式，List 表达式，例如著作权归作者所有，禁止商业用途转载。【转载请注明来源】 “number[]R【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】21; 表示一个数字数组，这种表示优势是【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】简单易懂
  本文版权归作者所有，未经授权不得转载。【作者：唐霜】本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。
  • "[string]" 组合字符串形式，将 [] 放在字符串内【作者：唐霜】转载请注明出处：www.tangshuang.net部，用 | 分割 List 参数，例如 "[string|number]"
  著作权归作者所有，禁止商业用途转载。【本文受版权保护】转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】
  • ["string"] 数组形式，如果为一个数组，表示这是一个著作权归作者所有，禁止商业用途转载。【转载请注明来源】 List，内部元素遵循 List 参数原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。逻辑（enum），例如 [“本文作者：唐霜，转载请注明出处。【本文受版权保护】string”, ̶【本文受版权保护】【原创不易，请尊重版权】0;number”]，这种表未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。示优势是可以嵌套层级，例如内部嵌套对象
  【原创不易，请尊重版权】本文版权归作者所有，未经授权不得转载。【本文受版权保护】本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】
【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】【作者：唐霜】转载请注明出处：www.tangshuang.net
• 枚举：原创内容，盗版必究。"string|number" 枚举 Enum 表达式，例如 R【原创内容，转载请注明出处】【本文首发于唐霜的博客】20;string|numberR原创内容，盗版必究。【作者：唐霜】21; 表示可以是字符串或数组中的一种
【未经授权禁止转载】【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net
• 元组：本文版权归作者所有，未经授权不得转载。"(string,number)" 元组 Tuple 表达式，例如 【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】220;(string,number)&【原创不易，请尊重版权】本文版权归作者所有，未经授权不得转载。#8221;
未经授权，禁止复制转载。【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。
• 字典：未经授权，禁止复制转载。{...} Dict 表达式，例如 { prop1【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。: “string̶未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。1; }
著作权归作者所有，禁止商业用途转载。转载请注明出处：www.tangshuang.net【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】
• 映射：【转载请注明来源】"{numeric:string}" Mapping 表达式，注意 {} 是【原创内容，转载请注明出处】【版权所有，侵权必究】被放在字符串中，: 前面表示 key 的本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。类型，后面表示 value 的类型
【未经授权禁止转载】【转载请注明来源】【版权所有，侵权必究】原创内容，盗版必究。
• 域：【本文受版权保护】"10<->20" Range 表达式，它用 –【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。; 表示基础信息，< 表示包含最小【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。边界，> 表示最大边界，例如 12本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】->20 表示 (12,20]，3【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。-9 表示 (3,9)，30<-&【作者：唐霜】【未经授权禁止转载】gt;60 表示 [30,60]
本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net

{
  "names": "string[]", // 字符串列表
  "ids": "[number]", // 数字列表
  "dogs": ["object"], // 对象列表
  "uids": "[string|number]", // 列表元素可以是字符串也可以是数字
  "files": [{ "filename": "string" }, { "fileName": "string" }], // 列表元素是字典类型，可以是两种类型中的一种

  "color": "'red'|'blue'|'yellow'", // 枚举，只能从red, blue, yellow这三个字符串中取一个
  "no.": "numeric|number", // 枚举，数字字符串或纯数字

  "user": "(number,string)", // 元组，代表固定个数的数组，比如用户信息，这里用 [12233, 'tommy'] 即 [uid, username] 的形式返回

  "info": { // 字典，其内部结构遵循相同语法
    "name": "string",
    "age": "number"
  },

  "data": "{numeric:number}", // 映射，键必须是数字字符串，而值必须是数字，在一些统计场景下常用到，例如 { 2000: 9, 2001: 40, 2002: 90, 2003: 140 }

  "range": "10<->20" // 数字区间，range字段的值必须 >=10 & <=20
}

逻辑类型本文版权归作者所有，未经授权不得转载。

表示该字段和给定类型之间的关系，目前支持本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】5种：

• ? – 表示只在该字段存在的【作者：唐霜】【未经授权禁止转载】情况下进行类型约束，必须置于表达式最前面转载请注明出处：www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】，例如 “?number&#【作者：唐霜】【未经授权禁止转载】8221; 表示如果该属性存在，必须是一未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net个数字
【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。
• = – 表示必须全等给定的值【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。，必须置于描述最前面，例如 “【作者：唐霜】【本文受版权保护】;=’tomy'”【作者：唐霜】原创内容，盗版必究。; 表示该属性的值必须等于 “本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。;tomy”, 一般很少用到
【原创内容，转载请注明出处】【原创不易，请尊重版权】【原创不易，请尊重版权】
• ! – 表示该字段不能是给定本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net的类型，必须置于描述最前面，例如 著作权归作者所有，禁止商业用途转载。【作者：唐霜】220;!number” 表未经授权，禁止复制转载。原创内容，盗版必究。示不可以为一个数字
未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。
• , 连接多个规则 – 表示多【原创内容，转载请注明出处】【本文首发于唐霜的博客】个类型的并集，该字段必须同时满足这些类型【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】，例如 “string,nu本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。meric” 表示必须是字符【本文首发于唐霜的博客】【未经授权禁止转载】串，且必须是数字型字符串（注意：, 必须【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。是顶层的 “[string,未经授权，禁止复制转载。转载请注明出处：www.tangshuang.netnumber]” 这种是非顶【转载请注明来源】本文版权归作者所有，未经授权不得转载。层的，而且这个表达式无法被解释）
【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。【转载请注明来源】【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。
• & – 表示可以为空本文版权归作者所有，未经授权不得转载。【未经授权禁止转载】（空引用），例如 “&【未经授权禁止转载】【原创不易，请尊重版权】;number” 表示 &#【本文首发于唐霜的博客】原创内容，盗版必究。8220;null|numberR本文版权归作者所有，未经授权不得转载。【作者：唐霜】21;
本文版权归作者所有，未经授权不得转载。【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。

{
  "name": "?string",
  "age": "&number",
  "type": "='dog'",
  "id": "string,numeric",
  "data": "!undefined",
  "some": "?&string"
}

前三种规则必须置于描述最前面，? 可以和【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。其他规则混用，例如 “?=&转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】#8217;tomy'” 表【未经授权禁止转载】转载请注明出处：www.tangshuang.net示如果存在该属性，必须等于字符串 原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】216;tomy’。

逻辑类型的优先级高于复合类型，例如 &#【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】8220;string,number|n原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。umeric” 解释之后是 本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。string 与 number|nume【转载请注明来源】【原创不易，请尊重版权】ric 的并集。

扩展语法著作权归作者所有，禁止商业用途转载。

__def__【关注微信公众号：wwwtangshuangnet】

用以解决无法用复合类型的情况下，提前定义著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。复合类型，例如枚举语法，无法枚举字典类型转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。，”{}|{}”【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。 大概意思是这样，比如，我有两种字典类型【转载请注明来源】【原创不易，请尊重版权】 Dog, Cat，现在我想要一个字典为转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net这两个中的一个，则无法使用上述语法实现。未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。此时用 __def__ 前置进行定义。

{
  "__def__": [
    {
      "name": "Dog", // 定义名字
      "def": { // 定义类型的内容，一般是复合类型才需要在 __def__ 中定义
        "name": "string",
        "type": "='dog'"
      }
    },
    {
      "name": "Cat",
      "def": {
        "name": "string",
        "color": "'white'|'grey'"
      }
    }
  ],
  "animal": "Dog|Cat" // 现在这里可以使用预先定义好的两个类型
}

__def__ 必须是数组，它里面的定义【原创不易，请尊重版权】【未经授权禁止转载】是有顺序的，后面的定义可以引用前面的定义【未经授权禁止转载】转载请注明出处：www.tangshuang.net。

__self__转载请注明出处：www.tangshuang.net

自引用类型，只能在 __def__ 中使【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。用。当我们需要在某些场景下，使用复合类型未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。本身时，需要用到它。

{
  "__def__": [
    {
      "name": "Person",
      "def": {
        "name": "string",
        "age": "number",
        "children": "?__self__[]" // 如果存在children这个字段时，它必须是Person列表
      }
    }
  ]
}

注：__self__ 是一个实现上的限制【版权所有，侵权必究】未经授权，禁止复制转载。，我们没有办法直接在 def 中使用 P【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。erson，只能使用 __self__ 转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】作为占位符。

注释著作权归作者所有，禁止商业用途转载。

在DSL文件（JSON）中对某个节点进行转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】注释，注释内容将在文档服务中显示出来。注【本文受版权保护】转载请注明出处：www.tangshuang.net释通过特殊的标记字段来完成，比如需要对 未经授权，禁止复制转载。【版权所有，侵权必究】name 字段进行注释，那么在 JSON转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net 中提供一个 #name 字段即可。

{
  "#name": "对name进行注释",
  "name": "string"
}

支持通过keyPath对嵌套节点进行注释【原创内容，转载请注明出处】【转载请注明来源】，例如：

  "#books[0]": "对书本的对象进行注释",
  "books": [
    {
      "title": "string"
    }
  ]
}

类型嵌套【本文受版权保护】

由于 TySheMo 仅支持非常简单的描【版权所有，侵权必究】【转载请注明来源】述语言，它不支持在描述文本中嵌套，因此，原创内容，盗版必究。原创内容，盗版必究。如果你需要有多层的嵌套规则，例如某个字段【版权所有，侵权必究】转载请注明出处：www.tangshuang.net是对象，然后你需要对对象内部进行约束，你【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。必须使用自定义规则，例如最前面代码里面的【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net books 那个属性一样。

自定义类型逻辑如下：转载请注明出处：www.tangshuang.net

TySheMo Parser 会首先去读本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】取 __def__ 中的内容，它必须是一本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】个数组，Parser 会去遍历这个数组，【版权所有，侵权必究】【原创内容，转载请注明出处】这个数组的元素结构如 { name, d【关注微信公众号：wwwtangshuangnet】【本文首发于唐霜的博客】ef }，每遍历一个元素，这个元素的解析【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。结果就会加入到 Parser 中，成为一【原创内容，转载请注明出处】【未经授权禁止转载】个定义，在后面的任何描述中，都可以使用这原创内容，盗版必究。【原创不易，请尊重版权】个元素。遍历完 __def__ 之后，再原创内容，盗版必究。【本文受版权保护】对整个 json 进行解析。

本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】

以前面的 books 为例。我们首先在 著作权归作者所有，禁止商业用途转载。【本文受版权保护】__def__ 中定义了一个 name 原创内容，盗版必究。【未经授权禁止转载】为 book 的类型，这个类型的具体描述本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】在 def 中，它实际上也是一个对象结构【原创内容，转载请注明出处】未经授权，禁止复制转载。。在 books 的描述中，我们使用了 【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net“book[]”未经授权，禁止复制转载。原创内容，盗版必究。，表示 books 是一个 book 的未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net数组。

自定义类型原创内容，盗版必究。

在一些场景下，你需要使用预设好的类型。你未经授权，禁止复制转载。未经授权，禁止复制转载。可以这样做：

// 预设类型
const types = {
  some: new Tuple([String, Number]),
}

// 将预设类型加入到该解析器，仅该解析器可以读懂预设类型
const parser = new Parser(types)

// 使用预设类型
parser.parse({
  list: "some", // some 为预设类型中对应的属性名
})

在 Parser 实例化的时候传入预设类【原创内容，转载请注明出处】【原创不易，请尊重版权】型，这些预设类型只会在该解析器解析的时候著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net生效，而不会影响其他解析器。

注释【转载请注明来源】

我们通过 json 来描述时，支持特殊的未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net方式表示注释。注释非常简单，就是在需要注【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。释的字段名字前加 #，这样就可以了。

{
  "#name": "对 name 进行注释",
  "name": "string"
}

注释支持对象嵌套，但不支持数组嵌套：【转载请注明来源】

{
  "body": {
    "#hand": "对象支持嵌套注释",
    "hand": "boolean",
    "foot": "boolean"
  },
  "#books[0].price": "数组不支持嵌套注释，只能在数组外部通过 keyPath 的方式进行注释",
  "books": [
    {
      "price": "number"
    }
  ],
  "#body.foot": "对象也支持 keyPath 的方式进行注释"
}

注意，__def__ 为关键字。在生成类【未经授权禁止转载】原创内容，盗版必究。型容器时，这些注释字段会按照规则，被添加【版权所有，侵权必究】【作者：唐霜】到 __comments__ 属性中，方未经授权，禁止复制转载。【转载请注明来源】便在 TyshemoService 中使【转载请注明来源】【版权所有】唐霜 www.tangshuang.net用。

但是在实际生产环境中需要注意，你需要在工【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.net具（例如 webpack）中将这些注释字著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】段从 json 中移除，以尽可能的减小代【关注微信公众号：wwwtangshuangnet】【原创内容，转载请注明出处】码体积。

接口【转载请注明来源】

parse(description)【原创不易，请尊重版权】

将描述文本 json 对象解析为 tys【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。hemo 的类型系统实例。

describe(type)转载请注明出处：www.tangshuang.net

将 tyshemo 的类型系统实例（Ty【作者：唐霜】转载请注明出处：www.tangshuang.netpe 实例）抽象为描述文本 json。

define(type, descrip【访问 www.tangshuang.net 获取更多精彩内容】【原创内容，转载请注明出处】tion)

定义一个解析对组。著作权归作者所有，禁止商业用途转载。

• type 目标类型（Type 实例或 p【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。rototype）
本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net
• description 文本著作权归作者所有，禁止商业用途转载。
【转载请注明来源】【本文首发于唐霜的博客】【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】

parser.define('some', SomeType)

经过 define 之后，你就可以在描述转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。文本中使用 some 代表 SomeTy【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.netpe 了。

技巧【转载请注明来源】

一般而言，只会在一些特殊场景下去使用解析【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net器。基于性能的考虑，不应该在前端大面积使【作者：唐霜】【原创内容，转载请注明出处】用这种方案，因为解析器本身在解析的时候，【原创内容，转载请注明出处】【版权所有，侵权必究】就会消耗一定的性能。

前后端通信时【访问 www.tangshuang.net 获取更多精彩内容】

由于前后端通信时，你无法直接传递运行时变【未经授权禁止转载】【转载请注明来源】量，不可能把 String, Numbe未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】r 这种传给前端，因此，只能选择 jso本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。n 字符串等通用描述方式。

前后端同构时原创内容，盗版必究。

使用同一套类型校验时，前后端使用相同的预【未经授权禁止转载】【原创不易，请尊重版权】设类型，可以减少传输成本。例如上面的一段本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】代码，其中的 some 类型，我们可以提著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net前预设好，这样，在发送的描述文件时，就不【访问 www.tangshuang.net 获取更多精彩内容】【转载请注明来源】需要再在描述文件中使用 __def__ 【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。去定义 some。

由于一些规则，特别是 determine转载请注明出处：www.tangshuang.net【未经授权禁止转载】 是无法直接获取计算后的类型的，因此，在本文作者：唐霜，转载请注明出处。【转载请注明来源】这种情况下，我们要使用自定义类型来实现这【本文首发于唐霜的博客】【本文受版权保护】些特殊规则的解析。

export const SomeRule = determine(data => data.type === 'die' ? DieType : LifeType)

事先定义 determine 规则的时候本文作者：唐霜，转载请注明出处。原创内容，盗版必究。，就是这样使用。让外部可以获取它。接着，【版权所有，侵权必究】【关注微信公众号：wwwtangshuangnet】使用独立作用域：

import { SomeRule } from './rules'

const parser = new Parser({
  tobeornottobe: SomeRule,
})

另外，还有一个技巧是，在解析器中，它会去著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。主动读取 Rule 实例的 patter【本文首发于唐霜的博客】【原创不易，请尊重版权】n 属性。因此，在解析代码中，我们可以自转载请注明出处：www.tangshuang.net【版权所有，侵权必究】己覆盖 pattern 属性，而非使用自【原创不易，请尊重版权】【未经授权禁止转载】定义类型。

import { SomeRule } from './rules'

SomeRule.pattern = [DieType, LifeType]

但是这样做明显是带有污染性质的，不建议这【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。么做，本文只是告诉开发者，在特殊情况下，【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。我们可以通过覆盖 pattern 来得到【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】想要的结果。

Mocker本文作者：唐霜，转载请注明出处。

上面，我们利用 Parser.descr著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。ibe 可以生成描述文件。差不多同样的道转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。理，我们可以生成 mock 数据。问题的【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】关键在于，我们如何生成每种原型对应的随机未经授权，禁止复制转载。原创内容，盗版必究。值。用法和 Parser 很像，但随机值【作者：唐霜】【原创内容，转载请注明出处】的产生不同。

const = loaders = [
  [String, function() {
    return 'a random string'
  }],
  [Number, function() {
    return Math.random() * 100
  }],
]
const mocker = new Mocker(loaders)

const dict = new Dict({
  name: String,
  age: Number,
})

const mock = mocker.mock(dict)

mock 方法可以提炼出一个 mock 【未经授权禁止转载】【转载请注明来源】数据，loaders 中的函数会返回一个本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】经过随机算法返回的字符串。最终，mock本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。 方法会返回一个符合 dict 的假数据【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】。Mocker 只有一个方法 mock，因此这里就不再深入赘述。本文作者：唐霜，转载请注明出处。

Service【版权所有】唐霜 www.tangshuang.net

基于 Parser 和 Mocker，我原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net开发了一个用于提供 nodejs 服务的【版权所有，侵权必究】转载请注明出处：www.tangshuang.net包: tyshemo-service【版权所有，侵权必究】，你可以【关注微信公众号：wwwtangshuangnet】阅读这篇文章转载请注明出处：www.tangshuang.net了解我的设计思路。这个包的主要目的是通过【本文首发于唐霜的博客】【本文受版权保护】项目中的 types 实例，自动生成文档本文作者：唐霜，转载请注明出处。【本文受版权保护】和 mock 数据接口。这样，我们就可以【作者：唐霜】【原创不易，请尊重版权】重复利用项目中已经写好的 types 文【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。件，很快输出开发阶段需要的东西。例如，我【未经授权禁止转载】本文作者：唐霜，转载请注明出处。们在我们的项目中写了一些 type 文件【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。：

// book.type.js
import { Dict } from 'tyshemo'

export const BookType = new Dict({
  name: String,
  price: Number
})

现在，我们有一个关于 book 的 re转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.netstful 接口，在前后端同学都是黑盒的本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。情况下，我们可以启动一个这样的服务：

// book.api.doc.js
const Service = require('tyshemo-service')

BookType.__comments__ = {
  'name': '书的名字',
  'price': '书的价格',
}

const server = new Service({
  getResponseType: (type) => {
    return {
      code: 0,
      data: type,
    }
  },
  getErrorType: (type) => {
    return {
      code: 10000,
      error: type,
    }
  },
  errorMapping: {
    10000: 'Database broken',
    10005: 'network error',
  },
  basePath: '/api/v2',
  data: [
    {
      name: 'Default Group',
      items: [
        {
          name: 'Book',
          description: '书本接口',
          method: 'get',
          path: '/book/:id',
          response: BookType,
        },
      ],
    },
  ], 
})

server.doc({ port: 4000 })

然后用 node 运行这个文件：【本文受版权保护】

node book.api.doc.js

这样就可以在本地启用一个服务，打开 lo【本文受版权保护】转载请注明出处：www.tangshuang.netcalhost:4000 就可以阅读文档未经授权，禁止复制转载。原创内容，盗版必究。。把这个文档另存为一个 html 发给后【原创不易，请尊重版权】原创内容，盗版必究。端同学，大家就可以对该接口进行约定了。这原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net样可以大大节约开发前期的沟通时间。同时，【转载请注明来源】【转载请注明来源】对于已经写好的 *.type.js 文件【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。，可以被重复用在运行时数据检查和做 ap【作者：唐霜】【原创不易，请尊重版权】i 测试中。api 测试，实际上就是在本【未经授权禁止转载】【原创不易，请尊重版权】地写 ajax 去不断请求和校验的过程。

初始配置本文版权归作者所有，未经授权不得转载。

在实例化Service的时候，需要传入一【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】个初始配置，这个配置是一个非常大的配置，转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。它包含了所有和接口、类型相关的配置。通过本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】这个配置，你可以描述所有的接口，以及输入【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。输出的一些规则。

{
  // 接口返回时，统一经过该方法进行处理。
  // 在大部分restful api接口中，都会在最外层包一层，但是我们没有必要把这些通用的东西写在response type里面，可以通过该方法来适配
  // 它接收下面接口配置的类型，返回一个新类型容器，也可以直接写成下面这种方式
  getResponseType(type) {
    return {
      code: 0,
      data: type,
    }
  },
  // 和 getResponsType一样的功效，只是在返回错误时进行包裹
  getErrorType(type) {
    return {
      code: Number,
      error: type,
    }
  },
  // 和getResponsType一样的功效，只是在请求数据外包裹
  getRequestType(type) {
    return type
  },
  // 规定全局的错误码对应文本，一般这个可以直接在项目的某个配置文件中引入
  errorMapping: {
    10000: 'Database broken',
    10005: 'network error',
  },
  // 接口访问时的基本路径，不包含域名部分
  basePath: '/api/v2',
  // 所有接口的配置信息
  data: [
    {
      // 先定义一个组
      id: 'default_group',
      name: 'Default Group',
      // 这个组里面包含了哪些接口，每个接口的具体配置下文详细解释
      items: [
        Person,
        Desk,
      ],
    },
  ],
}

其中最主要的部分就是 data 的配置。著作权归作者所有，禁止商业用途转载。转载请注明出处：www.tangshuang.net这个里面首先需要对接口进行分组，这是必须著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。的一个设计，因为一个接口的集合，不可能完【未经授权禁止转载】本文作者：唐霜，转载请注明出处。全不分组一次性给到开发者。每一个组的配置【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。包含三个字段，id, name, ite【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。ms，其中items就是将该组下的所有接【原创内容，转载请注明出处】原创内容，盗版必究。口按顺序排列，这个顺序会影响输出文档中的【版权所有，侵权必究】未经授权，禁止复制转载。顺序。

每一个item的配置如下：【作者：唐霜】

{
  id: 'person',
  name: 'Person',
  // 接口请求方式，必须是小写，因为express的路由中将会使用到这个值
  method: 'post',
  // 接口请求的路径，不包含basePath部分
  path: '/person/:id',
  // 请求发出的数据类型容器，method为get时表示queryString的参数
  request: RequestType,
  // 接口的响应数据类型容器
  response: ResponseType,
  // 用于单元测试的配置
  test: [
    {
      // 该单元测试多久执行一次，设置为0时取消自动循环功能
      frequency: 60000,
      name: '123',
      // 用于替换path中的占位符
      params: { id: 123 },
      // 用于覆盖单元测试随机值，保证某些字段是固定值
      request: { age: '10' },
    },
  ],
}

除了上述这些配置之外，还支持getRes未经授权，禁止复制转载。【本文首发于唐霜的博客】ponseType getErrorTy【本文首发于唐霜的博客】【本文首发于唐霜的博客】pe getRequestType ba本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】sePath 这几个配置，这几个配置如果【本文受版权保护】【本文首发于唐霜的博客】在 item 中配置了，那么这个接口不会本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。再使用全局配置中的这几个配置，而是使用自【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net己的配置，不配置的情况下，会直接使用全局【本文首发于唐霜的博客】未经授权，禁止复制转载。配置。errorMapping 会和全局本文版权归作者所有，未经授权不得转载。【转载请注明来源】配置中的 errorMapping 合并【转载请注明来源】著作权归作者所有，禁止商业用途转载。后作为当前接口的输出结果。

文档服务器【访问 www.tangshuang.net 获取更多精彩内容】

通过Service可以快速启用一个文档服【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net务器，让前后端的同学可以同时看着文档进行【未经授权禁止转载】【版权所有，侵权必究】开发，避免复杂的沟通交流。

当我们通过 new Service 得到【原创内容，转载请注明出处】未经授权，禁止复制转载。一个 server 之后，我们可以通过 【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。doc 方法快速启动一个服务器来展示文档【本文受版权保护】转载请注明出处：www.tangshuang.net。

server.doc(options)

使用 node 去运行这段脚本，就可以在未经授权，禁止复制转载。【未经授权禁止转载】浏览器中打开对应的端口访问默认提供的网页【转载请注明来源】【转载请注明来源】进行阅读。这里当 options 是对文原创内容，盗版必究。未经授权，禁止复制转载。档服务器启动时的配置。具体如下：

{
  // 服务器端口
  port: 9000,
  // 文档页面的title
  title: 'My App API DOC', // the doc page title
  // 文档页面一进入的欢迎语
  description: '', // the doc page description
  // 文档模版文件的路径，注意要使用绝对路径
  docTemplateFile: null,
}

怎么解决一些注释呢？我们怎么知道哪个字段【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】是什么意思呢？我们有一个 hook 用以【作者：唐霜】【转载请注明来源】解决注释问题。

RequestType.__comments__ = {
  // body.head 是对应的请求参数的键路径，而非单纯一个键
  'body.head': '这是 body.head 属性的注释',
}

通过 转载请注明出处：www.tangshuang.net__comments__ 属性来定义一些字段的备注。其中需要注意【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。的是，__comments__ 的键名是【转载请注明来源】【原创内容，转载请注明出处】基于 RequestType 的路径，这未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net些路径形式如 prop[i].prop.prop 是用来表示比较深层次的节点的。【访问 www.tangshuang.net 获取更多精彩内容】

Mock服务器【原创内容，转载请注明出处】

通过启用一个Mock服务器，前端同学不需转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。要后台同学完成开发，就可以在前端调通接口著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】，避免前端开发中，被后台接口开发卡住脖子本文版权归作者所有，未经授权不得转载。【未经授权禁止转载】的情况。

我们通过 server 的 mock 方【转载请注明来源】转载请注明出处：www.tangshuang.net法来开启Mock服务器。

server.mock(options)

目前，options 中只支持 port【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】 参数。

Mock 服务器启动之后，前端同学直接通【关注微信公众号：wwwtangshuangnet】【本文受版权保护】过代理等方式，将前端的请求转发到 Moc【本文受版权保护】本文版权归作者所有，未经授权不得转载。k 服务器，就可以在让 ajax 得到需【转载请注明来源】转载请注明出处：www.tangshuang.net要的数据，这些数据全部是根据数据类型描述【转载请注明来源】【原创内容，转载请注明出处】随机生成的。这样，就不用得到后台同学开发转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】完之后再进行接口联调了。

但是在一些情况下，你需要对某些节点的 m【作者：唐霜】【本文受版权保护】ock 数据做一个硬性的规定，你可以使用本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net __mocks__ 属性来进行处理。这个属性的用法和 __【版权所有，侵权必究】【转载请注明来源】comments__ 很像。它的值接收两【本文受版权保护】【作者：唐霜】种形式，一种是固定值，另一种是函数，如果【未经授权禁止转载】【版权所有，侵权必究】是一个函数，那么函数的运行结果就会作为该【本文受版权保护】【本文首发于唐霜的博客】节点的值。

ResponseType.__mocks__ = {
  'body.feet[0]': true,
}

但是有的情况下，对于一个 list，它的【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。值的类型是重复的，这个时候，你需要使用 [*] 来表示这种情况：【未经授权禁止转载】

ResponseType.__mocks__ = {
  'books[*].pages[*].num': function(data, indexes) {
    // data 是指整个 response 的 mock 数据（被 __mocks处理之前）
    // indexes 用于存储 * 所代表的索引值，之所以是一个数组，是表示 keyPath 中对应的 *
    // 例如这个例子里面，keyPath 中有两个 *，那么 indexes 中就会有两个值，第一个值代表 books[i]，第二个代表 pages[i]
    // 该函数每次执行的时候，indexes 里面的值都不一样，具体要看 mock 所产生的数据条数
    const [bookIndex, pageIndex] = indexes
    return 'page-' + (pageIndex + 1)
  },
}

自动测试服务器转载请注明出处：www.tangshuang.net

后端同学开发完接口之后，不知道自己开发好【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。的接口是否符合前端同学的需要，因此，需要【本文受版权保护】【本文首发于唐霜的博客】有一个测试工具，用来检查写好的接口是否是【转载请注明来源】【本文首发于唐霜的博客】 ok 的。tyshemo 提供一个自动【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。测试服务器，用来在这个阶段辅助完成接口测【作者：唐霜】【转载请注明来源】试（仅开发人员参与）。

server.test(options)

options 支持如下配置：【关注微信公众号：wwwtangshuangnet】

{
  port = 8087,
  // target 用于指向后端同学开发好后端代码后部署的服务器地址
  target = 'http://localhost:8089',
  title = 'TySheMo',
  description = 'This is an api doc generated by TySheMo.',
  // 自定义测试界面模板
  testTemplateFile = path.resolve(__dirname, 'test.html'),
}

用 node 去启动这个脚本之后，就可以【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】在浏览器中打开页面，去观看写好的测试用例【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net，并且运行测试用例来检查后台代码返回的结【访问 www.tangshuang.net 获取更多精彩内容】【关注微信公众号：wwwtangshuangnet】果是否符合前端同学的要求。

测试用例依赖于最前面 Service 配【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net置中的每个接口的 test 配置，通过这【版权所有，侵权必究】转载请注明出处：www.tangshuang.net些用例，可以很好的检查后台代码返回结果的本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。可用性。

统一服务器【转载请注明来源】

上述三个服务器在介绍中，都是独立启动的。【本文受版权保护】原创内容，盗版必究。你也可以一次性把三个服务器都起起来。

server.serve(options)

这里的 options 是上述三个服务器本文作者：唐霜，转载请注明出处。【本文受版权保护】的 options 的并集。当服务器起来【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。之后，在浏览器中打开对应的地址，根页面是【访问 www.tangshuang.net 获取更多精彩内容】【本文首发于唐霜的博客】文档页面，/_test 是测试页面。

Meta原创内容，盗版必究。

元（Meta）是有关一个字段的属性集合，转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】这个字段有哪些特征，有些什么逻辑，我们都著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net将这些描述放到 Meta 中进行描述。一著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。个 Meta 继承于 tyshemo 的未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】基类：

import { Meta } from 'tyshemo'

class Count extends Meta {
  static default = ''
  static type = Numeric
}

这些构成 Meta 的，被称之为“属性”【本文受版权保护】著作权归作者所有，禁止商业用途转载。（Attribute）。目前支持的属性包原创内容，盗版必究。本文作者：唐霜，转载请注明出处。含如下：

• default 默认值，必须【未经授权禁止转载】
原创内容，盗版必究。原创内容，盗版必究。【未经授权禁止转载】
• type 值类型，遵循 tyshemo 著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。类型系统的编程方式
  【访问 www.tangshuang.net 获取更多精彩内容】【本文首发于唐霜的博客】 这里需要注意，值在模型中的存在形式遵循原创内容，盗版必究。原创内容，盗版必究。该类型限制，而具体的业务场景下，值有多种未经授权，禁止复制转载。【原创不易，请尊重版权】形式，该类型限制仅针对模型内保存的值形式【原创不易，请尊重版权】【版权所有，侵权必究】。例如模型中保存 0 或 著作权归作者所有，禁止商业用途转载。1 那么它的类型是 未经授权，禁止复制转载。enumerate([0, 1])，但在实际展示时，我们可能把值转化为 【本文受版权保护】是 或 【关注微信公众号：wwwtangshuangnet】否 来展示，因此一定要注意一个值的形式。【原创内容，转载请注明出处】
著作权归作者所有，禁止商业用途转载。【转载请注明来源】【本文首发于唐霜的博客】
• validators 校验器列表，是一个原创内容，盗版必究。本文作者：唐霜，转载请注明出处。数组
  【未经授权禁止转载】【原创不易，请尊重版权】 校验器可以使用 tyshemo Val本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。idator 对象上的快捷校验器，例如 【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.netrequired, max, allOf转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】 等，具体可以参考项目代码中的代码。一个本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。校验器可以是一个纯对象，包含如下属性：
  【本文首发于唐霜的博客】【作者：唐霜】【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。
  • determine 是否要进行校验的判断本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。函数
  【作者：唐霜】【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。
  • validate 校验函数，返回 tru【本文受版权保护】未经授权，禁止复制转载。e 或 false 表示是否校验通过
  【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。本文作者：唐霜，转载请注明出处。【转载请注明来源】
  • message 校验未通过时，返回的提示未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。语
  【原创不易，请尊重版权】【本文受版权保护】【未经授权禁止转载】
  • break 该条校验未通过时，是否中断后【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】续校验，不传的情况下，列表中的所有校验器【版权所有】唐霜 www.tangshuang.net【转载请注明来源】会被全部依次执行
  原创内容，盗版必究。【原创内容，转载请注明出处】【原创内容，转载请注明出处】【本文首发于唐霜的博客】【访问 www.tangshuang.net 获取更多精彩内容】
原创内容，盗版必究。【本文受版权保护】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。
• readonly 是否只读？true 表本文作者：唐霜，转载请注明出处。原创内容，盗版必究。示值不能被修改，修改模型上的值时，值保持未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。原样，默认不报错
未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【原创不易，请尊重版权】
• disabled 是否禁用？true 表【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。示值不能被修改，不需要被校验（比 rea转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。donly 多的地方）
【关注微信公众号：wwwtangshuangnet】【作者：唐霜】未经授权，禁止复制转载。
• hidden 是否隐藏？在具体值上没有影【本文首发于唐霜的博客】【原创内容，转载请注明出处】响，但是在视图中会用到
【本文受版权保护】【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。
• required 是否必填？对具体值（包原创内容，盗版必究。【原创内容，转载请注明出处】括校验）没有影响，在视图中使用，可配合 【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。Validator.required 校转载请注明出处：www.tangshuang.net【未经授权禁止转载】验器进行校验
【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】
• drop 是否在调用 model.toD【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.netata 的时候丢掉当前这个字段？true【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。 时表示丢掉当前字段
本文作者：唐霜，转载请注明出处。【本文受版权保护】【作者：唐霜】
• map 在调用 model.toData【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net 时将当前字段的值进行转化
【原创内容，转载请注明出处】原创内容，盗版必究。未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】
• flat 在调用 model.toDat原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】a 时，将当前字段转化为其他字段（返回时【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】返回一个对象，这个对象被 patch 到原创内容，盗版必究。本文作者：唐霜，转载请注明出处。结果中）
  转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net 需要注意的是，flat 和 drop 【版权所有】唐霜 www.tangshuang.net【作者：唐霜】一般搭配使用，一般调用 flat 之后，未经授权，禁止复制转载。【转载请注明来源】当前这个字段可能不再需要，此时需要 dr【未经授权禁止转载】【版权所有，侵权必究】op 掉
本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。
• asset 耦合字段名。当我们需要调用 【版权所有】唐霜 www.tangshuang.net【本文受版权保护】model.fromJSON 欢迎模型字著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。段时，可通过该定义来规定使用传入 jso本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.netn 的哪个字段值作为当前这个字段要使用的本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】值，比如 attach: 'some' 那么 model.fromJSON 将【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】使用 json.some 作为当前这个字本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】段的值进行还原
本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】【版权所有，侵权必究】【本文受版权保护】
• create 还原转化函数。调用 mod【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】el.fromJSON 时，将接收到的字原创内容，盗版必究。【未经授权禁止转载】段值转化为什么结果之后再作为当前字段的值【原创不易，请尊重版权】【关注微信公众号：wwwtangshuangnet】，配合 attach 使用。它接收 (v【作者：唐霜】未经授权，禁止复制转载。alue, key, data)，当 a【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】ttach 无法满足要求时，可以直接通过著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。处理 data 上的值来构建字段值。
转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net
• save 导出转化器。调用 model.【关注微信公众号：wwwtangshuangnet】【未经授权禁止转载】toJSON 时，将该字段转化为什么结果本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net后保存。toJSON 和 fromJSO【转载请注明来源】【转载请注明来源】N 是逆操作，create 和 save【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。 的结果应该一一对应，否则无法正确使用。【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。它接收 (value, key, dat【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.neta)，当 attach 存在时，直接返回【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。值，当 attach 无法满足需求时，不要定义 attach【版权所有】唐霜 www.tangshuang.net，返回一个对象，对象将被 patch 到本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】结果上（类似 flat 的效果）。
【转载请注明来源】【本文受版权保护】【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net
• setter 赋值转化器。在修改字段值时【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net，将传入的值修改为新值后保存到 mode本文作者：唐霜，转载请注明出处。原创内容，盗版必究。l 上。
【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。原创内容，盗版必究。
• getter 取值转化器。在读取字段值时【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】，将保存的值经过转化后返回。
转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.net【作者：唐霜】
• formatter 文本格式化转化器。在【原创内容，转载请注明出处】【未经授权禁止转载】使用 view.text 读取当前字段的【本文首发于唐霜的博客】【作者：唐霜】文本时，通过该转化器进行格式化。
【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】【版权所有，侵权必究】
• state 函数，返回当前字段的衍生依赖原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。状态，高级用法，具体可以看项目中的代码
【转载请注明来源】本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】

setter 和 getter 是两个格未经授权，禁止复制转载。原创内容，盗版必究。式化函数，例如你要求当前属性必须是数字，【关注微信公众号：wwwtangshuangnet】【本文受版权保护】但是在表单中会使用字符串输入，因此，在 原创内容，盗版必究。未经授权，禁止复制转载。setter 中将字符串转化为数字，就可【转载请注明来源】【转载请注明来源】以解决问题。setter 具有比较高的优【未经授权禁止转载】【原创内容，转载请注明出处】先级，它会在 validate, ens未经授权，禁止复制转载。原创内容，盗版必究。ure 之前发挥作用，这样你就不用担心本未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】来想用 ’12’【未经授权禁止转载】转载请注明出处：www.tangshuang.net 得到 12 时由于类型校验不符合要求而未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。得到 default 了。

drop, map, flat 接收的参【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。数格式一致。它们都接收三个参数：

• value: 当前属性的值【本文首发于唐霜的博客】
【未经授权禁止转载】转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】【原创内容，转载请注明出处】
• key: 当前属性的 key【原创不易，请尊重版权】
未经授权，禁止复制转载。【版权所有，侵权必究】转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。
• data: 当前属性所在父节点的值（也就【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net是整个数据对象）
【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】本文版权归作者所有，未经授权不得转载。

以上就是一个属性描述的所有配置项。在接下【作者：唐霜】未经授权，禁止复制转载。来的接口详解时，可能会涉及到，你可以继续【原创内容，转载请注明出处】原创内容，盗版必究。往下读。

Schema【版权所有】唐霜 www.tangshuang.net

数据模式（Schema，本文简称“模式”【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】）是一种抽象结构。它的作用更多是描述，描【原创内容，转载请注明出处】【未经授权禁止转载】述一个结构应该是怎么构成的。Schema【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】 是 TySheMo 提供的一个类，它用【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。于生成一个模式描述。而这个描述有一些方法本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。，去保证你所提供的数据符合这个结构。

基于业务场景的思考，目前 Schema 本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】仅做了一层数据结构的描述。也就是说，Sc著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】hema 是不嵌套的。它只能描述当前这一转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net层的数据，深层结构数据是无法进行描述的（本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】虽然你可以用 object 来表示）。

import { Schema } from 'tyshemo'

const PersonSchema = new Schema({
  name: {
    type: String,
    default: 'unknown',
  },
  age: {
    type: Number,
    default: 0,
  },
})

这就是一个 schema，创建一个 sc本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。hema，你需要传入配置对象。对象的属性【本文受版权保护】【本文受版权保护】，就是所描述的数据的属性，属性值，则是该【版权所有】唐霜 www.tangshuang.net【原创不易，请尊重版权】属性的描述。

编程上，一个 Model 内保持着一个 【转载请注明来源】【原创内容，转载请注明出处】Schema 实例，这个实例一般是不对外【本文受版权保护】【原创不易，请尊重版权】暴露的。因此，它只是对 Model 起作【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。用，不提供接口。

Store著作权归作者所有，禁止商业用途转载。

TySheMo 提供了一个状态管理工具 未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。Store，它是一个状态管理器，一个 s本文版权归作者所有，未经授权不得转载。【转载请注明来源】tore 管理一个 state，它的特征【转载请注明来源】转载请注明出处：www.tangshuang.net是可被观察，让开发者可以通过 watch原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】 监听哪一个属性发生变化，并进行对应的下【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。一个操作。要使用 Store 也很方便。

import { Store } from 'tyshemo'

Store 是比 redux, mobx【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。 更便捷高效的状态管理器，它可以在 re【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。act, vue, angular 中被【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。无缝使用。而且，它的设计极其简单，没有任本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。何复杂概念，接口也很少，只能做这些操作。

初始化著作权归作者所有，禁止商业用途转载。

初始化动作超级简单。著作权归作者所有，禁止商业用途转载。

const store = new Store({
  name: 'tomy',
  age: 10,
})

没错，这样就创建了一个 store，st【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】ore 内保管着一份 state，初始化【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。之后，state 的值如上所示。

State【版权所有，侵权必究】

你可以读取 store.state 来进转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net行任意操作。利用 Proxy 技术，st本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】ate 比任何响应式库做的都要有意思。

const { state } = store

// 新增一个属性
state.sex = 'F'
// 修改原有属性
state.age ++
// 删除原有属性
delete state.name

state 的所有修改操作都是响应式的，著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】可以通过 watch 监听到这些修改。

计算属性转载请注明出处：www.tangshuang.net

Store 支持计算属性。在创建一个 s【本文首发于唐霜的博客】未经授权，禁止复制转载。tore 实例的时候，我们通过传入计算属本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】性来定义该属性。

const store = new Store({
  name: 'tomy',
  birth: 2009, 

  // age 是一个双向计算属性，可通过 get 实时动态计算值，可设置值时反写当前对象属性
  get age() {
    return new Date().getFullYear() - this.birth
  },
  set age(age) {
    this.birth = new Date().getFullYear() - age
  },

  // height 是一个单向计算属性，只能读取其计算结果值，不能向 height 设置值
  get height() {
    return this.age * 5
  },
  
  // fatherAge 是一个单向计算属性，任何情况下，读取结果都是 undefined，对它设置值时，只会对其他属性产生影响，而不会更新自己的值
  set fatherAge(fage) {
    this.age = fage - 28
  },
})

计算属性具有缓存，在第一次产生值之后，后未经授权，禁止复制转载。【未经授权禁止转载】续只有当该值，或它内部所依赖的值，发生变【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。化时，才会更新缓存。因此，上面使用了 n【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.netew Date().getFullYea【作者：唐霜】未经授权，禁止复制转载。r() 并不会每次都执行，倘若在年度之交转载请注明出处：www.tangshuang.net【未经授权禁止转载】使用上面代码，就会造成问题。因此，使用时【未经授权禁止转载】本文作者：唐霜，转载请注明出处。需要特别注意。

计算属性的计算器中的 this 指向 s原创内容，盗版必究。【原创不易，请尊重版权】tore.state，在其内部读取值时需【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】要注意，有的时候，被读取属性不存在时，会【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net报错，例如现在读取 this.body.【原创内容，转载请注明出处】【版权所有】唐霜 www.tangshuang.netfeet 就会报错，因为 this.bo【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。dy 并不存在。而且由于传入 Store【未经授权禁止转载】未经授权，禁止复制转载。 中的对象仅仅是一个初始值，在 stor著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。e 的运行过程中，是会改变的。那么，怎么【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net调整计算属性呢？

添加计算属性转载请注明出处：www.tangshuang.net

当初始值中不存在你需要的计算属性时，你可【本文受版权保护】转载请注明出处：www.tangshuang.net以通过 define 方法定义一个新的计【作者：唐霜】【原创不易，请尊重版权】算属性。

store.define('key', { get, set })

在第二个参数中传入 getter 和 s著作权归作者所有，禁止商业用途转载。【转载请注明来源】etter 函数。

修改计算属性【版权所有】唐霜 www.tangshuang.net

修改计算属性和添加计算属性的方法是一样的【转载请注明来源】未经授权，禁止复制转载。。

删除计算属性本文作者：唐霜，转载请注明出处。

使用 del 方法可以删除任意属性，计算【作者：唐霜】未经授权，禁止复制转载。属性也会被它所删除。

store.del('key')

实例方法本文作者：唐霜，转载请注明出处。

store 适应所有的框架，因为你可以选转载请注明出处：www.tangshuang.net【版权所有，侵权必究】择使用 state 来进行对象式操作，还本文版权归作者所有，未经授权不得转载。【作者：唐霜】是方法接口操作。

get(keyPath)原创内容，盗版必究。

通过 keyPath 获取属性值。key【作者：唐霜】【原创内容，转载请注明出处】Path 是用来描述一个深层次路径的表达【本文受版权保护】著作权归作者所有，禁止商业用途转载。式，可以是一个字符串，也可以是一个数组，本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net例如 [‘booksR【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。17;, 1] 表示 state.boo本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】ks[1]，也可以用字符串表示 R【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】16;books[1]’。

const name = store.get('name')

set(keyPath, value)转载请注明出处：www.tangshuang.net

通过 keyPath 设置某个属性的值为【原创不易，请尊重版权】【转载请注明来源】 value。

store.set('name', 'tomy')

del(keyPath)【作者：唐霜】

删除对应 keyPath 的属性。删除操【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net作虽然只是一个方法，但是实际上内部比较复【本文受版权保护】【本文受版权保护】杂，因为它要处理原有的依赖收集逻辑。

store.del('name')

update(data, async)本文作者：唐霜，转载请注明出处。

一次性更新多个属性值。本文版权归作者所有，未经授权不得转载。

store.update({
  name: 'tomy',
  age: 23,
})

它的第二个参数 async 表示是否异步【版权所有】唐霜 www.tangshuang.net【本文受版权保护】更新。异步更新的好处在于，我们建立一个很【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。小的事务，当同一个属性被多次更新的时候，【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net只有最后一次更新会被作为结果，这样可以提【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】升性能。

store.watch('age', () => console.log(111)) // 只会出现一次 console，因为两次 update 都是更新 age，而只有第二次更新被使用
store.update({ age: 24 }, true)
store.update({ age: 25 }, true)

它返回一个 Promise，你可以使用 【本文首发于唐霜的博客】【转载请注明来源】then/catch await 进行下【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.net一步操作。

需要注意，由于更新有先后顺序，使用 up【原创不易，请尊重版权】未经授权，禁止复制转载。date 更新数据时，尽量避免具有相互依转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。赖关系的数据同时更新。

define(key, options)

新增或修改计算属性。 当 options著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。 是一个函数时，直接被认为是 gette著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】r。

需要注意，define 只能定义顶层属性【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】，不能定义深层属性。

watch(keyPath, fn, d【版权所有，侵权必究】原创内容，盗版必究。eep)

监听某个 keyPath 的变动，当对应【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。 keyPath 值变化时，fn 这个回未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net调函数就会执行。deep 表示是否深层监【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。听，默认为 false，表示只有精确当 【本文受版权保护】本文版权归作者所有，未经授权不得转载。keyPath 变化时才会触发响应。而如【版权所有，侵权必究】【作者：唐霜】果 deep 为 true 时，表示如果本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net keyPath 对应的是一个对象，那么【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。该对象的子属性变化时，也会触发 fn。

当 keyPath 为 ‘*【版权所有，侵权必究】未经授权，禁止复制转载。’ 时，表示任意变动都能被监【本文首发于唐霜的博客】【转载请注明来源】听到。

unwatch(keyPath, fn)

解除 watch 绑定的监听函数。本文作者：唐霜，转载请注明出处。

bind(key)(store, key转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net)

将当前 store 的一个 key 和另原创内容，盗版必究。未经授权，禁止复制转载。外一个 store 的某个 key 进行原创内容，盗版必究。【原创内容，转载请注明出处】绑定，绑定之后，另外那个 store 的【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】那个 key 对应的值发生变化时，当前 【本文受版权保护】本文作者：唐霜，转载请注明出处。store 对应的 key 也会重新计算【本文受版权保护】【未经授权禁止转载】。这可以用在一些计算属性中使用了其他 s【原创不易，请尊重版权】【版权所有，侵权必究】tore 的情况。

Model本文版权归作者所有，未经授权不得转载。

终于进入到真正的数据建模讲解中。数据模型【访问 www.tangshuang.net 获取更多精彩内容】【原创内容，转载请注明出处】（Model，本文简称“模型”）是关于业【转载请注明来源】【版权所有】唐霜 www.tangshuang.net务的数据管理工具。把前端的数据想象成需要本文作者：唐霜，转载请注明出处。【作者：唐霜】一个数据库来进行管理。当你的数据需要自己【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】把控的时候，你需要怎么入手？你会涉及到哪未经授权，禁止复制转载。原创内容，盗版必究。些操作？在我看来，比较复杂的场景是：编辑本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】表单。你需要从 api 读取数据，并且恢【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。复到表单模型中，表单本身会需要自己的状态【作者：唐霜】【作者：唐霜】来维护，提交表单时需要校验数据，提交结果【本文受版权保护】【访问 www.tangshuang.net 获取更多精彩内容】需要进行规整化（根据后天 api 的接收本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】要求）。在这个过程中，对于本质其实只是一【本文受版权保护】【关注微信公众号：wwwtangshuangnet】份数据，却要考虑 3 种状态，这种时候，【原创内容，转载请注明出处】【转载请注明来源】通过 TySheMo 模型进行管理，会非【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】常方便。

TySheMo 的模型具备如下功能：转载请注明出处：www.tangshuang.net

• 字段类型校验原创内容，盗版必究。
著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】【本文受版权保护】
• 自定义校验器【原创内容，转载请注明出处】
【本文首发于唐霜的博客】原创内容，盗版必究。【原创不易，请尊重版权】【关注微信公众号：wwwtangshuangnet】
• 计算属性转载请注明出处：www.tangshuang.net
【本文受版权保护】著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。
• 从外来数据还原模型状态未经授权，禁止复制转载。
本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】
• 规整化表单数据著作权归作者所有，禁止商业用途转载。
【转载请注明来源】【未经授权禁止转载】【关注微信公众号：wwwtangshuangnet】
• 监听字段变化（响应式数据）著作权归作者所有，禁止商业用途转载。
本文作者：唐霜，转载请注明出处。【作者：唐霜】【关注微信公众号：wwwtangshuangnet】【本文受版权保护】【关注微信公众号：wwwtangshuangnet】

Model 中保持着一份 Store 和【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net Schema。Store 用于数据的响【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net应式管理，Schema 用于字段规则的管【未经授权禁止转载】本文作者：唐霜，转载请注明出处。理。Model 基于 Store，因此，未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。Model 上的数据具有可被观察性，你可【本文受版权保护】本文作者：唐霜，转载请注明出处。以通过 watch 来观察 Model 【转载请注明来源】著作权归作者所有，禁止商业用途转载。上的数据变化，从而触发界面更新。Mode著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】l 基于 Schema 来做数据的模式，【关注微信公众号：wwwtangshuangnet】【本文受版权保护】也就是说 Model 内管理的数据遵循 【版权所有，侵权必究】原创内容，盗版必究。Schema 的描述。

创建模型【关注微信公众号：wwwtangshuangnet】

一个模型是对数据的定义，但 Model 转载请注明出处：www.tangshuang.net【本文受版权保护】类不是数据本身，而是数据的规定。一个模型【本文首发于唐霜的博客】【本文首发于唐霜的博客】是一个数据的抽象，通过定义模型，就定义了【本文受版权保护】转载请注明出处：www.tangshuang.net这一个数据的字段规则以及变化逻辑。

Schema 声明【原创内容，转载请注明出处】

创建模型类具有非常强的场景意识，开发者应转载请注明出处：www.tangshuang.net原创内容，盗版必究。该非常清楚自己的模型将会需要哪些字段。前【转载请注明来源】【原创不易，请尊重版权】面我们提到模型是基于 Schema 的，【本文受版权保护】【未经授权禁止转载】那么我们怎么去确定一个模型的 Schem【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。a 呢？我们需要这样规定一个模型：

import { Model } from 'tyshemo'

export class SomeModel extends Model {
  static field = {
    type: String,
    default: '',
  }
}

创建一个继承自 Model 的类，这个类【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。，就是模型本身，将这个模型需要的字段以静著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。态属性的方式进行写作。每个字段所需包含的本文作者：唐霜，转载请注明出处。【本文受版权保护】配置信息，就是 Schema 属性的配置【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】信息。

有了一个模型之后，我们就可以实例化得到一著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。个模型的实例，这个实例则是数据的容器。

const model = new SomeModel()

实例化的时候，你可以传入一个初始数据，如【转载请注明来源】本文作者：唐霜，转载请注明出处。果不传，则会使用 schema 中的 d【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】efault 打造一个初始数据。也就是说本文版权归作者所有，未经授权不得转载。【本文受版权保护】，模型实例化之后，立即拥有了一个符合 s转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。chema 规定的数据。我们可以直接通过【本文受版权保护】本文版权归作者所有，未经授权不得转载。 model 读取模型实例的数据。

const field = model.field

而此时，因为 schema 中规定了 f【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。ield 的 default 为 【本文受版权保护】【未经授权禁止转载】221;，所以我们读取到的 field 【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。也是 ”.

将 Schema 引入到 Model 中转载请注明出处：www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】是 TySheMo 最重要的一个点。因为本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。有了 Schema，Model 中的数据转载请注明出处：www.tangshuang.net【转载请注明来源】不再是不可预测的。

本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】

创建一个 Model 原来如此简单。【本文受版权保护】

钩子函数转载请注明出处：www.tangshuang.net

在创建模型时，你可以通过覆盖钩子函数，来未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。实现模型上特定时期的动作。其中最重要的是【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。 onInit 和 onError。

class SomeModel extends Model {
  // 实例化完成时被调用
  onInit() {
    this.watch('*', () => this.doSomeThing())
  }
  // 当数据变换过程中，发生错误时，被调用
  onError(error) {
    console.log(error.message)
  }
}

自定义方法原创内容，盗版必究。

像普通的 js 类一样，你可以在模型中自【访问 www.tangshuang.net 获取更多精彩内容】【转载请注明来源】定义一些方法，将一些特殊的逻辑集合通过方本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。法的形式对外暴露，从而可以集中管理某些特转载请注明出处：www.tangshuang.net【作者：唐霜】定业务逻辑。

class SomeModel extends Model {
  doSomeThing() {
    this.name = ''
    this.age = 0
  }
}

const some = model.get('some')

const some = model.get('body.some')

class SomeModel extends Model {
  static some = {
    type: String,
    default: 'a',
  }
}

const model = new SomeModel()
console.log(model.some) // 'a'

const { $views } = model
const { some } = $views // 获取字段视图
const { 
  value, // 该字段当前的值
  required, // 该字段当前是否必填
  readonly, // 该字段当前是否只读
  disabled, // 该字段当前是否禁用
  errors, // 该字段当前是否校验不通过，如果不通过，会返回失败的 error 列表，否则返回空数组
  ...extra, // 你可以在定义 schema 时，定一个 extra 对象，该对象的值会被解构到 view 中，方便使用
} = some

some.value = 'b'

<input v-model="model.view.some.value" />
<span v-for="error in model.view.some.errors">{{ error.message }}</span>

model.set('name', 'lily')

model.$views.some.value = 'new value'

class SomeModel extends Model {
  static some = {
    type: String,
    default: 'a',
  }
}

const model = new SomeModel()
console.log(model.some) // 'a'

model.some = 'b'
console.log(model.some) // 'b'

model.update({
  name: 'lily',
  age: 12,
})

model.update({
  name: 'lily',
  age: 12,
}, true)

watch未经授权，禁止复制转载。

使用 watch 监听某个属性的变化，并【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】且在监听函数中，可以更新另外一个属性。但未经授权，禁止复制转载。【版权所有，侵权必究】和 angular 不同的是，watch【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.net 默认支持深检查。在监听函数中，可使用 【本文受版权保护】【转载请注明来源】this 指向当前 model。

model.watch('name', ({ key next, prev }) => {
  // key: 当前被修改的属性的 keyPath，数组，注意，key 不一定是这里的 name，而有可能是 name.length 等子属性
  // next: 被修改为什么值
  // prev: 被修改前的值
})

unwatch【本文受版权保护】

取消 watch 绑定的回调函数。【版权所有】唐霜 www.tangshuang.net

监听任何变动未经授权，禁止复制转载。

使用 * 可以监听 model 数据的所【版权所有】唐霜 www.tangshuang.net【原创不易，请尊重版权】有变动，只要数据变动，回调函数都会被执行【原创不易，请尊重版权】【原创不易，请尊重版权】。

model.watch('*', () => {})

数据校验【转载请注明来源】

在 TySheMo 模型中，进行模型的数【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】据校验非常方便。因为我们在 schema【转载请注明来源】原创内容，盗版必究。 中已经定义好了所有的校验规则，所以实际【访问 www.tangshuang.net 获取更多精彩内容】【作者：唐霜】上，你只需要对上文中关于 Schema 本文版权归作者所有，未经授权不得转载。【转载请注明来源】的 validate 的部分进行了解，就【版权所有】唐霜 www.tangshuang.net【作者：唐霜】可以知道 Model 的校验逻辑是怎样的本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】。

validate未经授权，禁止复制转载。

直接调用 Model 的 validat【本文受版权保护】著作权归作者所有，禁止商业用途转载。e 方法进行数据校验。

const errors = model.validate()

它不接收任何参数，直接对 model 的【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。数据进行全量校验。返回一个数组，该数组包著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】含了所有校验错误。当全部校验都通过的情况著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net下，返回一个空数组。

需要注意，这里的校验会使用 type, 原创内容，盗版必究。【作者：唐霜】required, validators【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。 进行校验。它的结果和 $views.$本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。errors 不同，多出了 type, 【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。required 的校验结果。

你也可以针对单个 字段进行校验。【访问 www.tangshuang.net 获取更多精彩内容】

const errors = model.validate('key')

甚至，你还可以用一个值去看看，这个值是否著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。符合该字段的规则。例如，我现在有一个值 【本文受版权保护】本文版权归作者所有，未经授权不得转载。some，我并不知道它是否符合 name【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。 字段的规则，在我打算使用它之前，我先通未经授权，禁止复制转载。【原创不易，请尊重版权】过下面的方法进行检验。

const errors = model.validator('name', some)

如果 errors 是空的，则说明 so【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】me 符合 name 的所有校验逻辑，可【原创不易，请尊重版权】【作者：唐霜】以放心使用。当然，一般情况下，不会这样去未经授权，禁止复制转载。【转载请注明来源】操作。

数据重置原创内容，盗版必究。

前文提到，围绕 Model 实际上有三种【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。状态的数据。我们现在要对第一种数据进行处未经授权，禁止复制转载。【作者：唐霜】理，然后让数据变为第二种状态的数据。即我【版权所有，侵权必究】【访问 www.tangshuang.net 获取更多精彩内容】们像 model 中注入新数据，使 mo【本文受版权保护】未经授权，禁止复制转载。del 重新拥有一个全新的状态数据。

fromJSON未经授权，禁止复制转载。

恢复数据调用 fromJSON 方法即可本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net。这个方法接收新的数据。

model.fromJSON(data)

它实际上用到了 schema 上的多个方未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net法（最主要是 create 规则），保证【版权所有，侵权必究】【版权所有，侵权必究】了恢复的数据的完整性和可靠性。

onParse本文作者：唐霜，转载请注明出处。

在后台 api 返回的数据和 model未经授权，禁止复制转载。【原创内容，转载请注明出处】 进行数据恢复之间，有一个 hook 方【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。法会被调用，即 onParse 方法。你转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。可以在创建模型时重写该方法，在 rest原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】ore 一开始时，该方法会被调用。

class SomeModel extends Model {
  static some = { ... }
  onParse(data) {
    return {
      ...data,
      user: localStoreage.getItem('USER'),
    }
  }
}

onParse 方法只能在创建模型时进行原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。规定。在 restore 执行之前，on【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。Parse 会被调用，得到一个新的数据之【本文受版权保护】本文作者：唐霜，转载请注明出处。后在 restore。因此，你可以在 o原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。nParse 里面做任何事情，特别是你知【本文受版权保护】转载请注明出处：www.tangshuang.net道你的 api 接口返回的数据需要进行结原创内容，盗版必究。本文作者：唐霜，转载请注明出处。构或字段名调整的时候。

toJSON【作者：唐霜】

toJSON 方法将 Model 导出为一个纯 ob本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.netject 保存，依赖于 save 属性的导出结果。save 属性和 as【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。set 属性影响了 toJSON 的字段转载请注明出处：www.tangshuang.net【未经授权禁止转载】导出值。

class Time extends Meta {
  static create(value) {
    return new Date(value)
  }
  static save(date, key) {
    const value = formatDate(date, 'YYYY-MM-DD')
    return { [key]: value } // 注意此处
  }
}

上面 save 属性返回了一个对象，并不转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。是说当前这个字段的值将以这个对象进行保存原创内容，盗版必究。【本文受版权保护】，而是将这个对象合并到导出的整体对象上去【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。，这样，save 属性可以返回一个特定 转载请注明出处：www.tangshuang.net原创内容，盗版必究。key 的对象，甚至多个 key 的对象【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】，产生保存需要的数据。

class Time extends Meta {
  static asset = 'time_at'
  static create(value) {
    return new Date(value)
  }
  static save(date, key) {
    const value = formatDate(date, 'YYYY-MM-DD')
    return value // 注意此处
  }
}

当存在 asset 属性时，行为逻辑就不原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net同了，asset 属性表示当字段一定是从【未经授权禁止转载】转载请注明出处：www.tangshuang.net json 对象的该字段获取，save 【关注微信公众号：wwwtangshuangnet】【原创内容，转载请注明出处】的结果也一定放在该字段上。

数据提取【转载请注明来源】

将数据输出为另外一个个数，用于表单提交之【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】类的。这是我在工作中积累出来的经验。在提本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。交表单之前，你所需要的数据格式跟你实际在【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。模型中管理的状态格式大部分情况下不同，前未经授权，禁止复制转载。【原创内容，转载请注明出处】端和后段对数据格式的要求非常不一致，这很原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】常见。通过 schema 中的配置选项，【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net你都不需要动脑筋就可以得到一个规整后的数【转载请注明来源】【原创内容，转载请注明出处】据。

toData转载请注明出处：www.tangshuang.net

通过 toJson 方法，你可以得到一个本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net基于规整规则后输出的 js 对象。

const json = model.toJson()

toParams【作者：唐霜】

通过 toParams 方法，你可以得到【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net一个 urlencoded 的数据。

const params = model.toParams()

它的结果如下：【版权所有，侵权必究】

{
  'books[1].name': 'A',
  'books[1].price': 12.5
}

它的属性层级被打平为一个字符串。转载请注明出处：www.tangshuang.net

toFormData【作者：唐霜】

通过 toFormData 方法，得到一未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net个 FormData 的实例。在一些要上未经授权，禁止复制转载。【未经授权禁止转载】传文件的情况下会用到。

const formdata = model.toFormData()

class SomeModel extends Model {
  onExport(data) { // 这里的 data 是 toJson 之后得到的对象
    return {
      ...data,
      user: localStoreage.getItem('USER'),
    }
  }
}

嵌套模型原创内容，盗版必究。

在某些场景下，我们会创建多个模型，并且在【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】模型中嵌套模型。这种情况其实比较常见，因著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。此，tyshemo 内部做了处理，你可以【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。这样使用：

import { Model } from 'tyshemo'

class PersonModel extends Model {
  static name = {
    type: String,
    default: '',
  }
  static age = {
    type: Number,
    default: 0,
  }
}

class InvestorModel extends Model {
  // 复用其他模型的单个属性
  static name = PersonModel.name
  static age = PersonModel.age

  static money = {
    type: Number,
    default: 0,
    setter: v => +v,
    getter: v => v + '',
  }
}

class ProjectModel extends Model {
  // 直接使用其他模型，表示 investor 这个属性的值是 InvestorModel 的一个实例
  // 它将直接继承整个 InvestorModel 的校验、规整化等等规则
  static investor = InvestorModel

  // 数组表示这是一个子模型列表
  static investors = [InvestorModel]

  static name = {
    type: String,
    default: '',
    required: true,
  }
}

const project = new ProjectModel()
console.log(project.investor.money)

同时，它也支持传入一个数组，表示这是一个转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。元素全部是该模型的列表。但是，此时需要注【原创内容，转载请注明出处】【本文受版权保护】意，它是不支持多元素的模型的。

Validator【作者：唐霜】

Tyshemo内置了一些校验器，而在Me【原创不易，请尊重版权】【转载请注明来源】ta中，使用Validator来实例化一【访问 www.tangshuang.net 获取更多精彩内容】【关注微信公众号：wwwtangshuangnet】个校验器。我们可以这样获取Validat【未经授权禁止转载】【未经授权禁止转载】or：

import { Validator } from 'tyshemo'

它是一个类，你可以通过实例化该类来获得一【转载请注明来源】【未经授权禁止转载】个校验器。

该类上有一些静态方法，这些静态方法可以生【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】成特定的校验器，你可以这样获取它们：

const {
  required,
  integer,
  decimal,
  max,
  min,
  email,
  url,
  date,
  match,
  maxLen,
  minLen,
  merge,
  enume,
} = Validator

required(message, em著作权归作者所有，禁止商业用途转载。【本文受版权保护】ptyFn)

这个校验器生成器比较特殊，它会根据Met【版权所有，侵权必究】【原创内容，转载请注明出处】a上的required属性来决定是否要执【本文首发于唐霜的博客】【原创不易，请尊重版权】行必填校验。如果Meta上的requir【原创内容，转载请注明出处】未经授权，禁止复制转载。ed为true，那么就会执行必填校验，如【转载请注明来源】转载请注明出处：www.tangshuang.net果校验没有通过，就会在tyshemo的校【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net验结果中增加一条以message作为信息【作者：唐霜】【原创内容，转载请注明出处】的错误。emptyFn可以让你自己定义怎【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。么样算是not required的逻辑。

integer(len, message【作者：唐霜】【本文受版权保护】)

用于校验一个数整数部分，len表示该数整【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net数部分支持多少位，比如 100 表示 3【本文受版权保护】转载请注明出处：www.tangshuang.net 位。integer(3, '整数部分不能超过3位') 这个校验器会在遇到 1000 的时候报【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。错。

decimal(len, message【原创内容，转载请注明出处】【原创不易，请尊重版权】)

校验逻辑和integer一致，只是作用于【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。小数部分。

max(num, message)【作者：唐霜】

用于校验一个数是否大于临界值，比如 【关注微信公众号：wwwtangshuangnet】max(100, '不能超过100') 在遇到101时，就会报错。【版权所有，侵权必究】

mix(num, message)【原创内容，转载请注明出处】

和max一致，只是用于校验最小值。【本文受版权保护】

email(message)未经授权，禁止复制转载。

用于校验字符串是否是一个邮箱格式。著作权归作者所有，禁止商业用途转载。

url(message)【原创内容，转载请注明出处】

用于校验字符串是否是一个url格式。本文作者：唐霜，转载请注明出处。

date(message)【作者：唐霜】

用于校验字符串是否是一个日期格式。【访问 www.tangshuang.net 获取更多精彩内容】

maxLen(len, message)

用于校验一个字符串的最大长度是否超过le未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.netn。

minLen(len, message)

用于校验一个字符串长度是否少于len个字【本文受版权保护】【原创内容，转载请注明出处】。

match(validator:Func本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.nettion, message)

用于创建一个根据validator函数返著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。回结果的校验器。validator返回t著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.netrue表示通过了校验。

另外，为了方便使用validator还可原创内容，盗版必究。未经授权，禁止复制转载。以是其他任何Type，比如：

[
  match(/[0-9]+/, 'Some should must be a number'),
  match(v => v > 10, 'Some should be greater than 10'),
  match(String, 'Some should be a string'),
  match(NaN, 'Some should not be a number'),
  match(Promise, 'Some should be a promise'),
  match('aaa', 'Some should equal `aaa`'),
]

allOf(validators:Fun【原创内容，转载请注明出处】原创内容，盗版必究。ction[], message)

用于创建一个根据全部validators未经授权，禁止复制转载。【本文首发于唐霜的博客】返回结果的校验器。和match不同的是，【版权所有，侵权必究】【作者：唐霜】validators是一个函数数组，必须【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。全部函数都返回true，才算通过校验。

anyOf(validators:Fun【未经授权禁止转载】未经授权，禁止复制转载。ction[], message)

和allOf不同，只要validator【原创内容，转载请注明出处】未经授权，禁止复制转载。s中任何一个validator函数返回t原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】rue，就算通过校验。

AsyncGetter【作者：唐霜】

AsyncGetter是一个tyshem【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。o中特殊的方法，它用于处理某些特殊场景，【原创不易，请尊重版权】【本文受版权保护】即当你的前端应用需要从接口拉取某些数据作【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。为应用的特定数据时，可以使用这个方法。

import { AsyncGetter } from 'tyshemo'

AsyncGetter(defaultValue:Any, AsyncGetter:Function)

比如，用于选取地址的省市县数据，我们不可原创内容，盗版必究。原创内容，盗版必究。能打包到js里面，都是通过接口返回的，这未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。个时候，我们就可能需要用到AsyncGe转载请注明出处：www.tangshuang.net【转载请注明来源】tter：

class Address extends Meta {
  static default = []
  static options = AsyncGetter([], () => fetch('http://...').then(res => res.json()).then(data => data.locations))
}

这样，当Address对应字段生成时，它原创内容，盗版必究。【原创不易，请尊重版权】会先以[]作为options属性的默认值著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。，随后发送一个ajax请求，并将执行的结本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。果作为新的值作为options的值。此时【作者：唐霜】【版权所有】唐霜 www.tangshuang.net，还会触发Model上的!事件，你可以通原创内容，盗版必究。未经授权，禁止复制转载。过watch来监听：

model.watch('!', fn)

AsyncGetter除了作为Meta属【作者：唐霜】原创内容，盗版必究。性的值之外，也支持作为state的值。例【未经授权禁止转载】转载请注明出处：www.tangshuang.net如

import { Model, AsyncGetter } from 'tyshemo'

class SomeModel extends Model {
  state() {
    return {
      some: AsyncGetter('', () => fetch('...').then(res => res.text())),
    }
  }
}

但是这种情况下，它不会触发!，而是直接触【作者：唐霜】原创内容，盗版必究。发some这个模型属性的change事件

model.watch('some', ...)

Loader著作权归作者所有，禁止商业用途转载。

Loader是tyshemo中更高集成的转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】工具，它用于解析JSON，基于JSON来【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net创建模型。

import { Loader } from 'tyshemo'

class SomeLoader extends Loader {
  fetchJSON(url) {
    return axios.get(url).(res => res.data)
  }
}

new SomeLoader().load(url).then((SomeModel) => {
  const model = new SomeModel()
  ...
})

JSON协议著作权归作者所有，禁止商业用途转载。

{
  "schema": {
    "name": {
      "default": "tomy",
      "type": "string",
      "required()": "age > 10" // use () after a key to mean a function attribute
    },
    "age": {
      "default": 10,
      "type": "number"
    }
  },
  "state": {
    "is_adult": false
  },
  "attrs": {
    "is_empty": "false"
  },

  // methods for Model
  "methods": {
    "getWeight()": "age * 5"
  }
}

它将被解析为【未经授权禁止转载】

class SomeModel extends Model {
  schema() {
    return {
      "name": {
        "default": "tomy",
        "type": "string",
        required() {
          return this.age > 10
        },
      },
      "age": {
        "default": 10,
        "type": "number"
      }
    }
  }
  state() {
    return {
      "is_adult": false
    }
  }
  attrs() {
    return {
      "is_empty": "false"
    }
  }

  getWeight() {
    return this.age * 5
  }
}

如果JSON中的key形式为 【版权所有】唐霜 www.tangshuang.net<...> ，会认为这是一个子模型。例如：【访问 www.tangshuang.net 获取更多精彩内容】

{
  "schema": {
    "<submodel>": {
      // the structure of a json schema for submodel
      "schema": { }
    },
    "<submodels>": [ // be an array
      {
        "schema": { }
      }
    ]
  }
}

特殊语法转载请注明出处：www.tangshuang.net

await fetch【原创内容，转载请注明出处】

该语法会调用Loader实例的fetch【作者：唐霜】著作权归作者所有，禁止商业用途转载。方法，进行异步请求。例如：

{
  "methods": {
    "fetchBookPrice(id)": "await fetch('...' + id).price"
  }
}

它有两个注意点：1.只能在methods【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。中使用；2.它直接返回loader.fe本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】tch的结果，你直接通过.price的方【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。式得到对应属性值，而不需要用then之类【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】的语法。

:fetch著作权归作者所有，禁止商业用途转载。

它是AsyncGetter的语法糖，例如【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。：

{
  "schema": {
    "book": {
      "default": null,
      "priceRange": "[0,100]:fetch('....').range"
    },
  },
  "state": {
    "someGlobalOptions": "[]:fetch('....')"
  }
}

上面的 未经授权，禁止复制转载。[]:fetch(...) 就算 未经授权，禁止复制转载。AsyncGetter([], ...) 的语法糖。【原创不易，请尊重版权】

结语著作权归作者所有，禁止商业用途转载。

TySheMo 是一款全新的思考前端数据原创内容，盗版必究。未经授权，禁止复制转载。管理的类库。它主要解决的是在前端不同的使【本文首发于唐霜的博客】【原创内容，转载请注明出处】用场景下，如何抽象数据类型和规则逻辑，特【未经授权禁止转载】本文作者：唐霜，转载请注明出处。别是在一些前后端数据耦合比较严重的系统中未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net。使用 TySheMo 不仅可以解决数据转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。校验问题，还可以解决数据的输入输出结构调未经授权，禁止复制转载。【本文受版权保护】整问题。当然，它还会有一些不足，如果你觉未经授权，禁止复制转载。【原创内容，转载请注明出处】得这样的想法对你有一些借鉴意义，或者任何本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。想法，欢迎在下方留言和我讨论。

如果你觉得本书对你有帮助，通过下方的二维码向我打赏吧，帮助我写出更多有用的内容。

2019-06-04