HelloType使用手册
返回： 唐霜 ｜ 书

HelloType使用手册

完全符合ES语法的前端js运行时数据类型检查工具，从此对api返回的数据格式心中有数

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

【作者：唐霜】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。

本项目不再维护，基于项目理念，我开发的 【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。tyshemo 更合理。请使用 tyshemo【本文首发于唐霜的博客】。【版权所有，侵权必究】

未经授权，禁止复制转载。【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。
【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。

HelloType是一款我想强推的前端数【原创不易，请尊重版权】本文版权归作者所有，未经授权不得转载。据类型检查工具，因为越来越多的数据类型问著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】题引起了前端的bug。即使已经有Type原创内容，盗版必究。本文作者：唐霜，转载请注明出处。Script、Flow等工具，但是还是无原创内容，盗版必究。【版权所有，侵权必究】法解决运行时的数据类型检查，它们都是在编原创内容，盗版必究。原创内容，盗版必究。译时进行数据类型检查的工具。特别是在前端【转载请注明来源】原创内容，盗版必究。请求后端API，用返回的数据进行下一步操本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。作时，经常遇到由于前端默认认为后端返回的转载请注明出处：www.tangshuang.net原创内容，盗版必究。数据格式是正确的，就直接进行一些数据遍历【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。之类的操作，于是bug就出现了。

【本文首发于唐霜的博客】【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】

传统解决这类问题的办法是，在用到后端AP【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】I返回的数据之前，对要用到的地方进行数据【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】类型判断，在业务代码里面反复的去写，去判【作者：唐霜】【转载请注明来源】断数据类型是否符合我的需要，只有在数据类未经授权，禁止复制转载。未经授权，禁止复制转载。型满足操作之后，才进行下一步操作。但是，本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net这样反复的在业务代码中写逻辑判断，会让大本文版权归作者所有，未经授权不得转载。【本文受版权保护】部分时间都浪费掉，而且最要命的是，你无法【版权所有，侵权必究】【关注微信公众号：wwwtangshuangnet】完全做到不遗漏的判断，总有时候会疏忽某个原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】检查而导致bug。

著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。【本文受版权保护】【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】

我实在不能忍受这种情况的继续发生，所以，转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】我写了HelloType，一方面是解决这本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】一现实问题，另一方面也算是自己在js弱数原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】据类型下的探索。因此，我希望写一个手册，原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。不仅把怎么使用HelloType说清楚，本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】也希望能把自己在这个过程中的一些思想讲清著作权归作者所有，禁止商业用途转载。【转载请注明来源】楚，这也可以为其他开发者提供一些思维上的未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net借鉴。

著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。

基础概念本文作者：唐霜，转载请注明出处。

原创内容，盗版必究。原创内容，盗版必究。【未经授权禁止转载】【版权所有，侵权必究】

HelloType中的“类型”和编程语言【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】里面的“类型”是有区别的，在HelloT未经授权，禁止复制转载。【版权所有，侵权必究】ype里面的“类型”更多的是指一个容器，著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】本质也就是一个js对象实例，这个实例拥有【作者：唐霜】【本文受版权保护】一些方法，利用这些方法，就可以判断一个变【版权所有，侵权必究】转载请注明出处：www.tangshuang.net量所存储的数据是不是符合这个类型的要求。

【版权所有，侵权必究】未经授权，禁止复制转载。【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。【转载请注明来源】

在js语言中，基本数据类型只有numbe著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】r, boolean, string, 本文版权归作者所有，未经授权不得转载。【转载请注明来源】null, undefined, sym【作者：唐霜】【版权所有】唐霜 www.tangshuang.netbol这几种，其他所有复杂的数据类型，都【未经授权禁止转载】本文作者：唐霜，转载请注明出处。是由object这种类型扩展出来的，因此著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。，js里面只有7种数据类型。但是，js里【版权所有】唐霜 www.tangshuang.net【转载请注明来源】面却没有一种方法可以区分出这7种类型，使【原创内容，转载请注明出处】【版权所有】唐霜 www.tangshuang.net用最多的typeof除了这几种类型外，还【访问 www.tangshuang.net 获取更多精彩内容】【本文受版权保护】会给出function，而null无法得【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。到。还有坑是，NaN的数据类型是numb【版权所有】唐霜 www.tangshuang.net【转载请注明来源】er。也就是说，在js里面没有绝对的办法转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】确定某个变量的值一定是某个类型。为了解决【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】这个问题，在HelloType中我重新对【版权所有】唐霜 www.tangshuang.net【转载请注明来源】js的数据类型进行规整。

本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。

原型 prototype【作者：唐霜】

【未经授权禁止转载】本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net

和prototype概念一样，所谓原型，本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】就是一个数据的本质。但是正如前面所说，j【未经授权禁止转载】原创内容，盗版必究。s只有7种，因此我们进行扩展：

【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net

上面红色标记的是我扩展出的原型，需要通过import { Null, Undefined, Any } from 'hello-type'引入。除了上面列出来的一些原生的数据原型【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】，js中其他没有列出来的原型也可以在这个未经授权，禁止复制转载。原创内容，盗版必究。列表中，只不过我这里列出了最常见的，其他本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。任何原型都是可以用的，甚至包括Error【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net，Promise等等。另外，我们还可以自【转载请注明来源】未经授权，禁止复制转载。己创建原型，就跟js里面创建一个带pro著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。totype的function，或者直接【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】用class声明一个类一样，自己写一个类原创内容，盗版必究。【本文受版权保护】，然后以这个类为原型，那么基于这个原型的【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。容器，在断言类的实例的时候，是可以通过的【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。。

【转载请注明来源】【转载请注明来源】未经授权，禁止复制转载。【作者：唐霜】本文版权归作者所有，未经授权不得转载。

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

【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。

我们有了原型，并不能直接使用原型和具体的【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。某个值进行对比，然后就得出这个值是不是符【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。合这个原型对应的数据类型。我们需要借助一【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。个数据类型容器。所谓数据类型容器，其实是著作权归作者所有，禁止商业用途转载。转载请注明出处：www.tangshuang.net说将原型本身包裹起来，这样，利用容器的统【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。一方法，就可以进行类型判别（断言）。He【本文首发于唐霜的博客】【作者：唐霜】lloType是怎么做的呢？就是提供了一原创内容，盗版必究。本文作者：唐霜，转载请注明出处。个Type构造器，构造一个容器，例如：

【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net 
const NumberType = new Type(Number)

这样，就用原型Number构造了一个容器【原创内容，转载请注明出处】原创内容，盗版必究。NumberType，接下来就可以用这个【本文首发于唐霜的博客】【作者：唐霜】容器对某个具体的值进行断言：

本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。【作者：唐霜】 
NumberType.assert(1) // 不会抛出错误
NumberType.assert('1') // 会抛出错误

我这里用了“断言”作为类型校验的动词，主【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】要是因为我认为数据类型校验其实是一个非必本文作者：唐霜，转载请注明出处。原创内容，盗版必究。须的动作，它不是业务逻辑的必须部分，而是【作者：唐霜】【未经授权禁止转载】我们附加的逻辑，但是在写代码时又不得不加未经授权，禁止复制转载。【本文受版权保护】入而已。数据类型校验先于所有业务逻辑，期著作权归作者所有，禁止商业用途转载。【作者：唐霜】望被校验的数据符合数据类型，当校验不通过【未经授权禁止转载】【作者：唐霜】时，容器可以发出阻断指令，因此，用“断言原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。”也比较形象。

原创内容，盗版必究。本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net

当然，容器还有其他方法，用以满足不同的数【原创不易，请尊重版权】未经授权，禁止复制转载。据类型检查需要。下文我会详细介绍容器的各本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】个方法，这里就暂时做概念的介绍。

转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。

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

【版权所有】唐霜 www.tangshuang.net【转载请注明来源】【转载请注明来源】

如果仅仅有原型和容器，还不足以满足我们对未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。数据类型的检查。因为我们在实际开发中会出【本文受版权保护】【本文受版权保护】现多种嵌套的数据形式，因此我们要有一种方原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】式可以满足这种需要。

转载请注明出处：www.tangshuang.net【转载请注明来源】【作者：唐霜】 
const SomeType = new Type({
  name: String,
  books: [Object],
})

上面红色部分不是原型，但为什么可以传给T【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。ype构造器呢？因为它被我称为型式（pa【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。ttern），它是形式化的数据结构，这个未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net结构将对数据进行约束。也就是说，如果你用【本文首发于唐霜的博客】【本文受版权保护】SomeType去校验一个对象，那么对象【本文受版权保护】未经授权，禁止复制转载。必须有name、books两个属性，而且【关注微信公众号：wwwtangshuangnet】【本文受版权保护】books属性值必须是数组。实际上，任何【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。被传入Type构造器的都是一个型式，包括著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】前面直接传Number，“Number”转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。本身也被认为是一个型式。

本文版权归作者所有，未经授权不得转载。【转载请注明来源】转载请注明出处：www.tangshuang.net

规则 Rule【原创内容，转载请注明出处】

【未经授权禁止转载】【作者：唐霜】未经授权，禁止复制转载。【原创内容，转载请注明出处】

所谓规则，就是指一个值是否是我们需要的数未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。据类型的确定方式。它跟在某个具体的属性名【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】后面，作为该属性值的校验方式，当然，它也【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。可以作为型式传入new Type：

【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】【作者：唐霜】 
const SomeType = new Type({
  name: String,
  age: IfExists(Number),
})
// String和IfExists(Number)就是name和age的规则

HelloType支持如下规则：【原创不易，请尊重版权】

【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】

HelloType内置了几种基于Rule【转载请注明来源】【访问 www.tangshuang.net 获取更多精彩内容】的规则：

【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】

比如，我们可以这样使用某个内置规则：【原创内容，转载请注明出处】

原创内容，盗版必究。【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。 
const SomeType = new Type({
 name: String,
 age: IfExists(Number), // 当obj.age存在时，它的值必须是一个数字，如果obj.age不存在，则忽略这个检查
})

我们可以利用HelloType提供的构造【原创不易，请尊重版权】【作者：唐霜】器创建自己的规则：

【本文受版权保护】本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。 
import { Rule } from 'hello-type'

const SomeRule = new Rule(function(value) {
  if (typeof value !== 'object') {
    return new Error('your passed value is not an object')
  }
})

这样你就可以像Number，String【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。这样使用SomeRule了，Null，U本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】ndefined，Any这三个扩展原型都本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】是这样出来的。

本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。【本文受版权保护】

小结【本文受版权保护】

【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】

在实际开发中，你根本不需要去思考这些概念【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。，所有使用都凭着感觉走，只要记住几个禁忌【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。即可，例如记住Lambda仅能用于对象的【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。属性值，IfExists只能用于对象属性著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】值、数组元素、Tuple的末尾参数。这些【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。禁忌如果可能的话，我会在最后列出来。

本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】【未经授权禁止转载】

快速入门【作者：唐霜】

著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。【原创内容，转载请注明出处】

这一章基于对一个api返回数据的类型检查【作者：唐霜】【版权所有，侵权必究】的场景，教你快速上手HelloType。

转载请注明出处：www.tangshuang.net【作者：唐霜】【本文受版权保护】

包的安装和使用著作权归作者所有，禁止商业用途转载。

本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】

HelloType是一个npm包，你需要【转载请注明来源】著作权归作者所有，禁止商业用途转载。通过npm进行安装：

【原创不易，请尊重版权】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。 
npm install --save hello-type

接下来在你的项目中使用这个包，它支持ES【原创不易，请尊重版权】【原创不易，请尊重版权】6、AMD的模块引入，也支持直接联入到H本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。TML文档中使用。

原创内容，盗版必究。原创内容，盗版必究。【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net 
// ES6
import { Type } from 'hello-type'
// CommonJS
const { Type } = require('hello-type')
// AMD or CMD
define(['hello-type'], function(hello_type) {
  const { Type } = hello_type
})

在HTML中直接使用时，你需要把hell【作者：唐霜】【版权所有，侵权必究】o-type/dist目录下的hello【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。-type.js文件拷贝到你的本地目录：

【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。 
<script src="hello-type/dist/hello-type.js"></script>
<script>
const { Type } = window['hello-type'] // 注意这里的使用方法
</script>

创建类型检查容器【作者：唐霜】

【原创不易，请尊重版权】【本文受版权保护】本文作者：唐霜，转载请注明出处。【本文受版权保护】

在使用HelloType进行数据校验之前【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net，你需要先进行数据类型的规定，通过创建一【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。个容器，把规定固定下来。

【本文首发于唐霜的博客】【版权所有，侵权必究】转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】 
const BookType = new Type({
  name: String,
  price: Number,
})

一般而言，一个项目里面会有很多这样的初始著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】化工作，所以，为了方便项目管理，最好把所【作者：唐霜】本文作者：唐霜，转载请注明出处。有这种形式的代码集中起来。目录结构如下：

著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。 
|-types
|  |-person
|  |-book
|  |  |-book.type.js
|  |-benifit
|-controllers
|  |-shop.controller.js

如上，创建了一个types目录，用来保管【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】所有的type相关文件，甚至为了区分，文著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】件命名时使用了.type.js后缀。

转载请注明出处：www.tangshuang.net原创内容，盗版必究。转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。 
// book.type.js
import { Type } from 'hello-type'

export const BookType = new Type({
  name: String,
  author: String,
})
// shop.controller.js
import HelloType from 'hello-type'
import { BookType } from '../types/book/book.type.js

export default class ShopController {
  sell(book) {
    // 在所有业务代码运行之前，用HelloType对方法函数的参数类型进行检查
    // 如果别的地方调用sell方法时，传入的book不符合BookType的规定，那么这里会直接抛出错误，方法无法继续执行
    HelloType.expect(book).to.match(BookType)

    // 具体的业务逻辑代码
  }
}

对API数据进行检查【未经授权禁止转载】

本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。

当我们通过ajax到服务器api接口拿到【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】数据之后，并不能确保数据接口返回的结果一【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net定是符合预期的，我们得在使用接口数据之前【作者：唐霜】【版权所有】唐霜 www.tangshuang.net进行类型和结构断言：

未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】 
import { Dict, List, IfExists, Type, HelloType } from 'hello-type'

export const NumberType = new Type(Number)
export const BooksType = List([
  IfExists({
    name: String,
    age: Number,
  })
])
export const BooksResType = Dict({
  code: Number,
  data: BooksType,
})
async function getBookDetail(id) {
  HelloType.expect(id).to.match(NumberType) // 对函数的输入进行类型断言
  
  let res = await fetch(apiUrlBase + '/books/' + id)
  let data = await res.json()
  HelloType.expect(data).to.match(BooksResType)
  
  // 由于对api接口返回的数据进行了断言，如果程序能够执行到这里，那么说明api返回的数据符合要求，下面的操作不必有任何担心

  let books = data.data
  books.forEach((book) => {
    // ...
  })

  HelloType.expect(books).to.match(BooksType) // 对函数的返回值进行类型断言
  return books
}

这样就完成了对API返回数据的类型断言，【作者：唐霜】【版权所有】唐霜 www.tangshuang.net由于这是一个async函数，因此，当断言【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。中报错时，会阻止程序继续往下执行，并抛出著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】错误，在使用函数时，可以通过catch获【本文受版权保护】著作权归作者所有，禁止商业用途转载。取到抛出的错误内容，并对错误内容进行解读【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。（例如上传到监控系统）。

本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】【转载请注明来源】

看上去是不是很简单？看不懂？没关系，关于【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】Dict、List，以及Type里面套用【版权所有，侵权必究】原创内容，盗版必究。等，会在后文一一详解，只要继续阅读就能理原创内容，盗版必究。本文作者：唐霜，转载请注明出处。解了。

转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net

Type【本文受版权保护】

【未经授权禁止转载】未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】

利用Type可以创建一个容器，它是一个构【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。造器，也是一个ES6的class，因此在【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net使用时要用new去实例化。它没有任何配置未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net项，每一个传入的值，都是一个型式，型式可【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。以是任意内容，它会按照一定的规则进行型式原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】的格式化，形成规则体现。

【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。

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

著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。

要使用Type，只能通过new关键字去实【版权所有，侵权必究】【原创不易，请尊重版权】例化一个实例出来，得到的就是一个类型容器【作者：唐霜】【版权所有】唐霜 www.tangshuang.net。

原创内容，盗版必究。【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。【作者：唐霜】【本文首发于唐霜的博客】 
const NumberType = new Type(Number)

上面这段代码就创建了一个基于Number本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。的类型容器，它用来检查一个值是不是一个数【转载请注明来源】转载请注明出处：www.tangshuang.net字。由于js的一些坑，例如NaN的typ【本文首发于唐霜的博客】原创内容，盗版必究。eof也是number，所以我对这些情况转载请注明出处：www.tangshuang.net【本文受版权保护】都进行统一：

【原创不易，请尊重版权】【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.net

上面这四种类型都做了强制规定，因此，你在原创内容，盗版必究。【版权所有，侵权必究】用它们的时候，真的就跟它们的字面意思一样【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。，不会产生副作用。在HelloType的本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】体系里，所有的原型在上一章已经说过了，这【访问 www.tangshuang.net 获取更多精彩内容】【原创内容，转载请注明出处】里就不再赘述。

【版权所有，侵权必究】【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】

HelloType希望用js里面最简单直【转载请注明来源】本文作者：唐霜，转载请注明出处。接的思维解决数据类型问题，对一个数据进行【版权所有，侵权必究】转载请注明出处：www.tangshuang.net类型断言时，我没有发明一种新形式来表示类本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。型，因为类型是枚举不完的，我看到有一个和【原创内容，转载请注明出处】【作者：唐霜】hello-type目的相同的库，它通过【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。字符串来表达类型，然而，在它的issue【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net列表里，很多都是对这种字符串来表示类型的本文版权归作者所有，未经授权不得转载。【作者：唐霜】一些疑问或希望修改类型名等。而Hello【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。Type用原生的类型原型作为类型的基础，原创内容，盗版必究。【原创内容，转载请注明出处】几乎不需要做任何扩展，就可以把js里面所【原创不易，请尊重版权】【未经授权禁止转载】有类型囊括进来，这就是所谓以不变应万变吧转载请注明出处：www.tangshuang.net【未经授权禁止转载】。

【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net
【原创不易，请尊重版权】【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】

new Type支持同时传入一组型式，这【原创不易，请尊重版权】【本文首发于唐霜的博客】样可以一次性对多个数据进行校验。这对于有本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】多个参数的函数的参数校验非常有用：

【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】 
const ParamsType = new Type(String, Number, Boolean)
ParamsType.assert('tomy', 10, true)

这种一次打包一组数据，但又不是数组的数据本文版权归作者所有，未经授权不得转载。【本文受版权保护】形式，我把它扩展为了Tuple（元组），著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。下文会详细介绍。

本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】

传入new Type的型式是你最直观的一【原创内容，转载请注明出处】【版权所有，侵权必究】种书写方式，比如一个对象结构，或者一个数【本文首发于唐霜的博客】【本文受版权保护】组结构：

【访问 www.tangshuang.net 获取更多精彩内容】【作者：唐霜】未经授权，禁止复制转载。原创内容，盗版必究。 
const SomeType = new Type({
  name: String,
  detail: {
    title: String,
    content: String,
  },
})

虽然内部而言，它其实是一个Dict嵌套的【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】结构，但是实际上，在外表上看，它就像一个【未经授权禁止转载】本文作者：唐霜，转载请注明出处。普通的对象一样。Dict是字典结构，下文本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】会详细解释。在构建容器的时候，容器本身，原创内容，盗版必究。【未经授权禁止转载】只能对object的第一层数据进行校验，【本文受版权保护】原创内容，盗版必究。当有嵌套数据的时候怎么办呢？把被嵌套的型【作者：唐霜】【本文首发于唐霜的博客】式转化为一个Dict容器，这样，虽然容器【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net本身只校验第一层，但是当校验到规则为一个转载请注明出处：www.tangshuang.net【转载请注明来源】容器的时候，它会利用容器，对该属性的值再【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。次进行校验，而这个时候，这个二级容器，又本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。可以去校验下一级的对象。正是因为实现了这转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。个机制，所以HelloType几乎可以实著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。现无限层的校验，虽然这是不允许的。虽然我【未经授权禁止转载】【关注微信公众号：wwwtangshuangnet】这里不能把原理讲明白，但是你只要按照你以本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net为的方式去用就好了，并不会有问题。

未经授权，禁止复制转载。【作者：唐霜】【版权所有】唐霜 www.tangshuang.net

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

【本文首发于唐霜的博客】【本文首发于唐霜的博客】原创内容，盗版必究。【本文首发于唐霜的博客】未经授权，禁止复制转载。

assert方法是Type容器的最重要方【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net法，也是所有HelloType方法的基础著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】。当你完成Type实例化，创建了一个容器【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。之后，这个容器实例就自动拥有了一些方法，【作者：唐霜】【转载请注明来源】assert方法就是需要介绍的第一个方法转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】。

【转载请注明来源】未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net【本文受版权保护】【作者：唐霜】

assert方法用来断言接收到的变量数据转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net是否符合当前容器所对应的数据类型和数据格本文作者：唐霜，转载请注明出处。【本文受版权保护】式：

【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【本文受版权保护】 
const person = {
  name: 'tomy',
  age: 10,
}

PersonType.assert(person) // 断言person符合PersonType的定义

如果person不符合PersonTyp本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。e的定义，assert会throw Ty【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。peError，而在js里面，被抛出的错【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。误，可以被window.onerror监【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。听到，这非常有用，对于前端异常的监控，或【本文受版权保护】【版权所有】唐霜 www.tangshuang.net者一些特别的逻辑非常有帮助，因此，我才选【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。择throw error的形式抛出错误。本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】Error还能记录代码的stack信息，【未经授权禁止转载】【本文首发于唐霜的博客】可以帮助我们快速定位错误位置。

【原创内容，转载请注明出处】【版权所有，侵权必究】【未经授权禁止转载】

assert接收的参数个数，和new T【转载请注明来源】转载请注明出处：www.tangshuang.netype时接收的参数个数必须相同，如果不同本文版权归作者所有，未经授权不得转载。【本文受版权保护】，也会抛出错误。因此，对参数个数具有严格原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。的要求，你不能用assert一次性校验多【未经授权禁止转载】【转载请注明来源】个数据，只能反复调用assert来校验。

本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net

另外有一点需要注意，【版权所有，侵权必究】HelloType只会在遇到第一个断言失【本文受版权保护】【版权所有，侵权必究】败时跳出断言，而不会遍历所有断言。这也就是说，当你assert抛出错误时未经授权，禁止复制转载。【原创不易，请尊重版权】，并不代表该数据只有一个地方不符合类型，本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】在你修复了bug之后，需要继续关注，在后【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net面的断言里，还可能出现不符合类型。例如：

【原创不易，请尊重版权】【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】 
const SomeType = new Type({
  name: String,
  age: Number,
})
const some = {}
SomeType.assert(some) // 在对name属性值进行断言的时候抛出错误，并终止断言。但是你会发现，其实age属性也不符合要求。

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

【未经授权禁止转载】【本文首发于唐霜的博客】【作者：唐霜】

assert方法会通过throw Typ【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】eError抛出错误，这可能不是你想要的【转载请注明来源】原创内容，盗版必究。，你可能只想看看这个数据是否符合规定，如【版权所有，侵权必究】【原创内容，转载请注明出处】果符合返回一个true，不符合返回一个f转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。alse。test方法就是做这件事的。

未经授权，禁止复制转载。原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net【版权所有，侵权必究】 
let bool = PersonType.test(person) // true
if (!bool) {
  alert('person does not match PersonType')
}

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

【版权所有，侵权必究】【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】

test方法虽然可以让你判断，但是你希望【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。还能获取到具体的错误信息，catch方法【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】就可以帮助你捕获错误而不抛出任何错误。

未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。【版权所有，侵权必究】原创内容，盗版必究。 
let error = PersonType.catch(person)
if (error) {
  console.log(error.stack)
}

catch方法会把捕获到的错误返回，如果【作者：唐霜】转载请注明出处：www.tangshuang.net没有错误发生，就返回null。

【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net【本文受版权保护】【本文受版权保护】【关注微信公众号：wwwtangshuangnet】

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

原创内容，盗版必究。未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。

不过有的时候，你并不希望HelloTyp【访问 www.tangshuang.net 获取更多精彩内容】【关注微信公众号：wwwtangshuangnet】e终止你的程序，但你又不想用catch，转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net多加一层判断，这个时候，你可以使用tra【原创不易，请尊重版权】转载请注明出处：www.tangshuang.netck.with，异步处理错误。

【作者：唐霜】【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。 
PersonType.track(person).with((error) => {
  // ...
})

使用这个语句，本身不会让程序终止，它在断原创内容，盗版必究。【原创内容，转载请注明出处】言之后，如果发现不符合类型，就会执行fn原创内容，盗版必究。转载请注明出处：www.tangshuang.net，并把error传给fn。不过，如果在f未经授权，禁止复制转载。【本文首发于唐霜的博客】n中抛出错误就看你自己了。利用track【作者：唐霜】【关注微信公众号：wwwtangshuangnet】.with，你就可以在不影响函数的正常执【转载请注明来源】【版权所有】唐霜 www.tangshuang.net行的情况下，还可以抓取到数据类型错误信息本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net。

原创内容，盗版必究。【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net

trace.with【未经授权禁止转载】

本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。

track和trace的区别，在英文里面本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】是这样的，track追踪的是从起点到当前【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】点的线索，而trace是从当前点开始往后【原创内容，转载请注明出处】【未经授权禁止转载】跟踪。假如你是一个侦探，正在怀疑一个人是【访问 www.tangshuang.net 获取更多精彩内容】【关注微信公众号：wwwtangshuangnet】凶手，你在不停的找他的犯罪证据或者线索就【版权所有，侵权必究】【访问 www.tangshuang.net 获取更多精彩内容】是track，而你在他身上偷偷安装跟踪器【未经授权禁止转载】本文作者：唐霜，转载请注明出处。进行跟踪就是trace。在HelloTy著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】pe体系里，trace.with和tra【转载请注明来源】【本文受版权保护】ck.with的用法是一模一样的，只不过【版权所有】唐霜 www.tangshuang.net【本文受版权保护】执行的进程不同。track的前半部分是同原创内容，盗版必究。未经授权，禁止复制转载。步的，会阻塞进程。而trace会完全异步【本文首发于唐霜的博客】【原创不易，请尊重版权】执行的，也就是说它会在异步执行时才会去检【作者：唐霜】【关注微信公众号：wwwtangshuangnet】查数据的类型错误。这也就是说，如果你在函【原创不易，请尊重版权】【未经授权禁止转载】数的执行过程中如果改动了数据，trace转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。是先不管的，只有当函数中的同步进程执行完本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】了，trace才会对数据进行检查，而这个原创内容，盗版必究。本文作者：唐霜，转载请注明出处。时候，trace检查的是修改过的数据，因转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net此，在使用trace.with的时候一定本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】要注意这点。

【原创内容，转载请注明出处】【转载请注明来源】【原创不易，请尊重版权】【作者：唐霜】

之所以提供trace和track，主要是【本文受版权保护】原创内容，盗版必究。从性能上考虑，track是同步执行的，对【转载请注明来源】本文版权归作者所有，未经授权不得转载。性能有所影响，而trace是完全异步执行【作者：唐霜】【作者：唐霜】的，因此不仅不会由于抛出错误而终止进程，【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net而且还把对数据对判断放到末尾去做，因此对未经授权，禁止复制转载。【原创内容，转载请注明出处】界面的渲染一点影响都没有。不过最惨的地方【本文受版权保护】【本文受版权保护】在于，如果你在代码中修改了数据，那tra【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】ce得到的结果可能就跟你预期的不同了。因【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.net此使用的时候一定要注意。

【本文首发于唐霜的博客】【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】

严格模式本文版权归作者所有，未经授权不得转载。

原创内容，盗版必究。本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net

在进行断言的时候，默认情况下，Hello原创内容，盗版必究。【未经授权禁止转载】Type会使用兼容模式。当断言一个对象的【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。时候，当一个对象里面有一个属性是type【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net规定的对象里没有规定的时候，不会产生任何本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。问题，（type里有的一定会校验，）也就【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。是忽略不校验。而如果是严格模式，则要求对【本文受版权保护】本文版权归作者所有，未经授权不得转载。象的属性和type规定的一模一样，如果被【本文首发于唐霜的博客】原创内容，盗版必究。检查的对象多了一些属性是type里面没有【本文首发于唐霜的博客】原创内容，盗版必究。规定的，那么也会报错。

未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。原创内容，盗版必究。

之所以提供严格模式，也是想要提供一种选项【原创内容，转载请注明出处】原创内容，盗版必究。，帮助数据类型检查。

【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】【转载请注明来源】

那么怎么开启严格模式呢？有两种方式：【版权所有】唐霜 www.tangshuang.net

【未经授权禁止转载】【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】 
PersonType.toBeStrict()

将PersonType切换为严格模式。【本文首发于唐霜的博客】

【未经授权禁止转载】【作者：唐霜】著作权归作者所有，禁止商业用途转载。【转载请注明来源】【版权所有，侵权必究】 
let StrictPersonType = PersonType.Strict

返回一个拷贝，而这个拷贝是严格模式的。s未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。trct和Strict是一模一样的，你也【未经授权禁止转载】【未经授权禁止转载】可以用someType.strict，只【原创不易，请尊重版权】【本文首发于唐霜的博客】是为了让使用的时候，根据不同开发者的习惯【本文受版权保护】【版权所有，侵权必究】，提供大小写区别的方式。

转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。【转载请注明来源】转载请注明出处：www.tangshuang.net

为什么要提供两种方式呢？因为切换模式是直本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net接让当前容器进行改变，也就是说，如果你在【转载请注明来源】著作权归作者所有，禁止商业用途转载。其他地方也使用到了该容器，那就会有影响，【版权所有】唐霜 www.tangshuang.net【作者：唐霜】而strict则不会改变当前容器，而是返【作者：唐霜】著作权归作者所有，禁止商业用途转载。回一个新容器，只不过这个容器是严格模式的原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net。大部分情况下，推荐使用strict来获未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。取一个新容器，防止对其他实例造成影响。

【作者：唐霜】原创内容，盗版必究。【未经授权禁止转载】【转载请注明来源】

严格模式会自动继承给被嵌套的容器，例如：

【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。【本文受版权保护】【转载请注明来源】未经授权，禁止复制转载。 
const SubType = new Type({
  name: String,
})
const ParentType = new Type({
  name: String,
  child: SubType,
})

ParentType.toBeStrict()
PerentType.assert({
  name: 'jhon',
  child: {
    name: 'tomy',
    age: 10,
  },
})

上面的校验会抛出错误，因为child.a本文版权归作者所有，未经授权不得转载。【本文受版权保护】ge设置了值，而严格模式下，被嵌套的容器【未经授权禁止转载】未经授权，禁止复制转载。也会转化为严格模式后再使用，因此，你不用转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。自己手动嵌套一个严格模式的容器。而且，这未经授权，禁止复制转载。原创内容，盗版必究。种情况，SubType自身不会被切换为严转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】格模式，内部使用的是SubType.St【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。rict，因此你可以放心使用。

未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】【原创不易，请尊重版权】

扩展数据类型【本文受版权保护】

本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。未经授权，禁止复制转载。原创内容，盗版必究。

js的基础数据类型显然不够用，所有的复杂本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net数据都基于object进行扩展，所以到最未经授权，禁止复制转载。【本文受版权保护】后instanceof Object都是【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】true。我希望通过HelloType，著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】对js的数据类型扩展，在进行数据类型检查著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】的时候，让数据类型有所归属。基于这种想法【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。，我扩展出了5种，但实际上，基于已有的原未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。材料，你可以扩展出自己的数据类型（容器）【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。。

【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】【转载请注明来源】

下面这些扩展类型的本质还是“规则”，它们原创内容，盗版必究。未经授权，禁止复制转载。本身不是对数据类型的扩展，不是新的数据结未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】构，而是创建一个对特定值进行类型约束的容著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net器。因此，它们全部是函数，而非类。

本文版权归作者所有，未经授权不得转载。【本文受版权保护】著作权归作者所有，禁止商业用途转载。转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。

Dict 字典未经授权，禁止复制转载。

【本文受版权保护】【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】原创内容，盗版必究。

实际上，我在HelloType里面对一个转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】对象进行检查时，只会对真正的对象进行检查【作者：唐霜】【关注微信公众号：wwwtangshuangnet】，也就是说，一个function、一个类【原创不易，请尊重版权】本文版权归作者所有，未经授权不得转载。的实例，虽然它们在js里面都是对象，但是本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】实际上，在HelloType里面它们会被著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。认为是自己真实的本质，而不是一个对象。而【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。Dict就代表对象本身。

原创内容，盗版必究。未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net【本文受版权保护】

在Type的基础上，所有扩展类型都做了强转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】规定，这样保证这些类型的特殊性。

本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】【原创内容，转载请注明出处】 
const DictType = Dict({
  nage: String,
  age: Number,
  children: [IfExists(Object)], // IfExists是一个内置规则，下文会更详细的讲
})

这样就得到一个Dict的容器。它和一个n【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.netew Type的普通容器是一样的，只是在原创内容，盗版必究。【未经授权禁止转载】它的基础上加了一些强制而已，其他没有区别【版权所有，侵权必究】【访问 www.tangshuang.net 获取更多精彩内容】。

著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。【转载请注明来源】【转载请注明来源】【本文受版权保护】

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

【本文受版权保护】【未经授权禁止转载】【未经授权禁止转载】本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】

Dict除了通用的判断方法外，还另外有两【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。个特别的方法。extends方法用于对原【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net有的规则结构进行扩展，例如，你定义了一个【本文受版权保护】【版权所有】唐霜 www.tangshuang.netPersonType，但是你现在需要一个转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】BoyType，而BoyType实际上拥【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net有了PersonType的全部属性，你可【转载请注明来源】【版权所有】唐霜 www.tangshuang.net以这样做：

本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。【未经授权禁止转载】转载请注明出处：www.tangshuang.net 
const BoyType = PersonType.extends({
  sex: Enum('F', 'M'),
  age: ShouldMatch(Number, Validate(value => value <= 14, `Boy's age should not bigger than 14.`)),
})

extends的参数是新增的属性及其规则本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。。也可以通过extends对原有的规则进【版权所有】唐霜 www.tangshuang.net【原创不易，请尊重版权】行覆盖，当原有类型中存在某个属性时，新给【原创内容，转载请注明出处】原创内容，盗版必究。定当属性规则会覆盖原有的规则。它返回一个【未经授权禁止转载】【转载请注明来源】新的Dict。

转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net

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

【本文受版权保护】本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。【版权所有，侵权必究】

和extends相反，extract则是本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。从原有的某些属性中抽取部分作为新的规则集著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。合。它的使用方法如下：

【本文首发于唐霜的博客】未经授权，禁止复制转载。未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】【关注微信公众号：wwwtangshuangnet】 
const ChildType = ParentType.extract({
  name: true,
  age: true,
  height: false,
  weight: false,
})

其中，值为true表示在新的ChildT【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。ype中，这个属性的规则将会被使用，为f【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】alse将会被舍弃。但是，你可能会问，假转载请注明出处：www.tangshuang.net原创内容，盗版必究。如在ParentType中的属性，在使用【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。extract的时候没有传入怎么办？这种【本文首发于唐霜的博客】【原创内容，转载请注明出处】情况会有一个规则去自适配：

【本文首发于唐霜的博客】【本文受版权保护】【关注微信公众号：wwwtangshuangnet】

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

转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】

List对应数组，它规定一个数组的每个位转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。置上元素的类型。

【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.net 
const ListType = List([String, Number])

List的校验规则如下：本文版权归作者所有，未经授权不得转载。

转载请注明出处：www.tangshuang.net【转载请注明来源】【未经授权禁止转载】

上述最后一点，当超出长度时，比如用上面的【版权所有，侵权必究】未经授权，禁止复制转载。ListType去校验[‘t【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。omy’, 10, true【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。]就会不通过，第二个元素后面的元素必须是【转载请注明来源】转载请注明出处：www.tangshuang.netString或Number。

【作者：唐霜】【本文受版权保护】转载请注明出处：www.tangshuang.net原创内容，盗版必究。转载请注明出处：www.tangshuang.net

Enum 枚举【未经授权禁止转载】

本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。【转载请注明来源】

枚举在js里面本身是没有的，我扩展出来，著作权归作者所有，禁止商业用途转载。【作者：唐霜】在HelloType体系里非常有用。它很【作者：唐霜】未经授权，禁止复制转载。简单，要求要校验的值，会用规定的几个规则著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】中的一个去校验：

【原创不易，请尊重版权】【未经授权禁止转载】【转载请注明来源】 
const EnumType = Enum(String, Number, Boolean)

那么在校验的时候，被校验值必须是这三种类未经授权，禁止复制转载。【本文首发于唐霜的博客】型之一。

【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】【作者：唐霜】

不过一般而言，很少会这样用，因为我们并不【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。希望一个值是多类型的，我们更多的用法是：

转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。 
const ColorType = Enum('blue', 'red', 'yellow')

前面讲过，具体的某个值也是一种规则，要求【本文受版权保护】【未经授权禁止转载】被校验值必须与该值相等。在Enum中就非未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。常明显，ColorType去校验的时候，【作者：唐霜】【转载请注明来源】值必须是这三个值中的一个，否则就会不通过本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。。

【作者：唐霜】原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】

枚举是一个超级好用的类型，它可以帮助你实【未经授权禁止转载】【本文受版权保护】现各种花式操作，例如：

【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。 
function link(a, b) {
  return a + b
}

这个函数，乍一看是个加法运算，但是在js原创内容，盗版必究。未经授权，禁止复制转载。里面，字符串连接也是这样，所以，这就比较未经授权，禁止复制转载。【关注微信公众号：wwwtangshuangnet】麻烦了，两种数据类型都是允许的，但是假如【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】，你只想它是其中的一种，你可以这样：

【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。 
const ParamsType = Enum(Tuple(Number, Number), Tuple(String, String))

这样可以防止用户在用的时候，传入一个字符【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。串和一个数字。

【作者：唐霜】【本文首发于唐霜的博客】【原创内容，转载请注明出处】【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。

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

未经授权，禁止复制转载。未经授权，禁止复制转载。【原创内容，转载请注明出处】

元组是指一组散列的数据，按照一定的顺序组【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】成一组。它非常适合用来校验函数的参数。

转载请注明出处：www.tangshuang.net【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net 
const TupleType = Tuple(String, Number)

它非常使用函数参数校验，因为有的时候，你转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】并不知道函数参数会传多少个，你会这样做：

【本文受版权保护】【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】【转载请注明来源】 
function fun(...args) {
  TupleType.assert(...args)
}

因为Tuple可以校验一组值，而非一个值本文作者：唐霜，转载请注明出处。【版权所有，侵权必究】，所以它很适合这种校验。它的校验规则如下【原创内容，转载请注明出处】未经授权，禁止复制转载。：

【原创内容，转载请注明出处】【未经授权禁止转载】【本文受版权保护】著作权归作者所有，禁止商业用途转载。

如果Tuple只接收一个参数的话，和ne本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】w Type看上去没两样，但是，在兼容模【本文受版权保护】【本文受版权保护】式下，Tuple支持IfExists，而【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。new Type不支持。这时，如果Tup【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.netle末尾的IfExists会被兼容，也就【原创内容，转载请注明出处】【未经授权禁止转载】是说在参数个数校验时，会特殊处理，而ne【本文受版权保护】【本文首发于唐霜的博客】w Type必须是强对应。下文会更详细介未经授权，禁止复制转载。原创内容，盗版必究。绍IfExists。

【本文受版权保护】【本文受版权保护】【关注微信公众号：wwwtangshuangnet】【原创内容，转载请注明出处】 
const SomeType = Tuple(String, Number, IfExists(Boolean))

注意，如果不是尾部的IfExists，它本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】会被强制校验。

原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】【转载请注明来源】

Range 域值原创内容，盗版必究。

【本文受版权保护】未经授权，禁止复制转载。【版权所有，侵权必究】【作者：唐霜】

Range代表一个数字区间，要校验的值首原创内容，盗版必究。【未经授权禁止转载】先得是数字，其次得是出于这个区间的值，区本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。间包含传入的起始点和结束点。

【本文首发于唐霜的博客】【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。转载请注明出处：www.tangshuang.net 
const RangeType = Range(0, 100)

上面的RangeType要求被校验的是数原创内容，盗版必究。转载请注明出处：www.tangshuang.net字，且必须处于[0, 100]之间（包含本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net0和100）。

【本文受版权保护】【本文受版权保护】未经授权，禁止复制转载。【原创内容，转载请注明出处】【本文首发于唐霜的博客】

自定义类型未经授权，禁止复制转载。

著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。【作者：唐霜】本文作者：唐霜，转载请注明出处。

你也可以写出自己的自定义类型，其实构建一【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。个自定义类型非常简单，你可以查看Dict【作者：唐霜】【本文受版权保护】的源码，它干了两件事，一是规定了函数传入【转载请注明来源】未经授权，禁止复制转载。参数的限制，另一件事是创建一个容器，这个【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。容器具有特殊的校验规则，并给它赋一个na【本文首发于唐霜的博客】【作者：唐霜】me。例如，我现在要扩展出一个只允许包含【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net两个元素，且都是数字的数组的类型：

原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】 
function Position() {
  let type = List([Number, Number]).toBeStrict()
  type.name = 'Position'
}
const PositionType = Postion()

PositionType.assert([10, 100]) // ok
PositionType.assert([1, 1, 1]) // throw TypeError
PositionType.assert(['tomy', 10]) // throw TypeError

利用已有的各种素材，可以创建任何类型。本文版权归作者所有，未经授权不得转载。

著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】

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

转载请注明出处：www.tangshuang.net【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。

规则是HelloType里面对一个值进行【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】校验时，真正用来作为对比基础的东西。也正【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】因为这样，规则是最千变万化的，前文已经说【未经授权禁止转载】本文作者：唐霜，转载请注明出处。了哪些东西可以作为规则。不过显然，有穷的【访问 www.tangshuang.net 获取更多精彩内容】【转载请注明来源】列举还是无法满足所有需求，有的时候你需要【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。自定义规则，这个时候你就需要用到Rule转载请注明出处：www.tangshuang.net【本文受版权保护】。

原创内容，盗版必究。【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net

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

【关注微信公众号：wwwtangshuangnet】【本文首发于唐霜的博客】【本文首发于唐霜的博客】【未经授权禁止转载】【原创内容，转载请注明出处】

Rule是一个构造器，使用时你需要先引入【本文受版权保护】本文作者：唐霜，转载请注明出处。：

【未经授权禁止转载】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。 
import { Rule } from 'hello-type'

它接收一个参数，这个参数是一个函数，函数著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。可以包含一个参数，这个参数就是要校验的值本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。。这个函数可以返回任意内容，但是，当你校【原创内容，转载请注明出处】【未经授权禁止转载】验失败时，必须返回一个Error/Typ【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。eError实例，当HelloType发本文作者：唐霜，转载请注明出处。原创内容，盗版必究。现你返回的是Error的实例的时候，就认著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。为校验失败，并抛出错误：

【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【本文受版权保护】著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。 
const MyRule = new Rule(function(value) {
  if (typeof value !== 'object') {
    return new TypeError('%arg is not an object')
  }
})

非常简单。不过它也可以接收两个参数，第一转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net个参数可以是一个字符串，用来给这个Rul【原创内容，转载请注明出处】【本文首发于唐霜的博客】e命名：

【访问 www.tangshuang.net 获取更多精彩内容】【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。 
const MyRule = new Rule('ObjectRule', function(value) {
  if (typeof value !== 'object') {
    return new TypeError('%arg is not an object')
  }
})
MyRule.name // ObjectRule

=== 注意：以下内容有点危险 ===【未经授权禁止转载】

原创内容，盗版必究。原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。

Rule构造器还可以接收第三个参数，但是原创内容，盗版必究。本文作者：唐霜，转载请注明出处。这个参数有点危险，请谨慎使用。第三个参数转载请注明出处：www.tangshuang.net【本文受版权保护】用来覆盖当前属性的值。它仅对对象属性、数【转载请注明来源】【版权所有】唐霜 www.tangshuang.net组元素生效。

原创内容，盗版必究。原创内容，盗版必究。【转载请注明来源】【版权所有，侵权必究】 
const MyRule = new Rule('ObjectRule', function(value) {
  if (typeof value !== 'object') {
    return new TypeError('%arg is not an object')
  }
}, function(error, prop, target) {
  if (error) {
    target[prop] = {}
  }
})

上面这段代码创建了一个rule，它会检查【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。一个值是否typeof为object，如著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】果不是就抛出错误，但是如果当前检查的值是【原创不易，请尊重版权】【关注微信公众号：wwwtangshuangnet】一个对象的属性，或者一个数组的元素，它还转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】会继执行第三个参数的函数，而不会立即终止【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。进程，执行完第三个参数的函数之后，再回到【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】第二个函数参数重新进行校验，如果校验通过未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net了，则不会报任何错。

【本文受版权保护】【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】未经授权，禁止复制转载。

第三个函数有三个参数【本文首发于唐霜的博客】

著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。

但是你应该注意到，在第三个函数中，我使用【作者：唐霜】本文版权归作者所有，未经授权不得转载。了target[prop] = {}，直【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。接修改了原始数据中的内容，这一点你要千万原创内容，盗版必究。【作者：唐霜】小心，这个操作修改了原始值，因此你一定要【原创不易，请尊重版权】【作者：唐霜】在知道发生了什么的情况下使用。

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

Null、Undefined、Any【原创内容，转载请注明出处】

未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。

在最前面的章节里我已经介绍到了这Null本文版权归作者所有，未经授权不得转载。【转载请注明来源】、Undefined、Any这三个被扩展【作者：唐霜】本文作者：唐霜，转载请注明出处。出来的原型。

原创内容，盗版必究。【未经授权禁止转载】未经授权，禁止复制转载。【本文首发于唐霜的博客】

Null【转载请注明来源】

转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。

要校验的值必须是null。【本文受版权保护】

【版权所有，侵权必究】原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。【未经授权禁止转载】

Undefined【本文受版权保护】

【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】

要校验的值必须是undefined。本文作者：唐霜，转载请注明出处。

【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】【原创内容，转载请注明出处】

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

本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】

要校验的值可以是任何类型。本文作者：唐霜，转载请注明出处。

本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。

Numeric【作者：唐霜】

【作者：唐霜】原创内容，盗版必究。【原创不易，请尊重版权】【作者：唐霜】【版权所有】唐霜 www.tangshuang.net

Numeric是我内置的一种类型，Num转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】eric类型允许值为真正的数字，或者形式【作者：唐霜】原创内容，盗版必究。与数字一模一样的字符串。例如：̵【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。7;12.34’。

【未经授权禁止转载】原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】

基于Rule可以制作出任意的扩展类型。在本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。这个思路下，你可以在自己的项目中去创建自【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】己的很多原型，例如创建某个时间格式的原型【版权所有】唐霜 www.tangshuang.net【本文受版权保护】等。

原创内容，盗版必究。【本文受版权保护】【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。

内置规则【作者：唐霜】

【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。未经授权，禁止复制转载。

我在HelloType中内置了几种规则，【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】把常见的一些情况考虑进去，当然，考虑的不本文作者：唐霜，转载请注明出处。【本文受版权保护】够全面，如果你有认为需要改进的地方，可以【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。给我提出需求，我可以根据情况，把你提出的【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。规则内置进去。

本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。

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

【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】转载请注明出处：www.tangshuang.net

这一些情况下，你希望有些值是可选的，比如著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。一个对象的某个属性，你希望如果这个属性存【本文受版权保护】【转载请注明来源】在，就校验它，如果不存在，就直接略过。数未经授权，禁止复制转载。未经授权，禁止复制转载。组也是一样，你希望一个数组如果是空数组，【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。就直接略过，如果这个数组有元素，那么要求【未经授权禁止转载】【未经授权禁止转载】它每个元素都是一个字符串。这样的需求比较著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。常见。

【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】

那么怎么做到呢？就要借助IfExists未经授权，禁止复制转载。【本文受版权保护】。

【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。 
const SomeType = Dict({
  name: String,
  age: IfExists(Number)
})

严格模式下的时候，要特别注意，IfExi原创内容，盗版必究。【本文受版权保护】sts会失效，因此，如果你用SomeTy原创内容，盗版必究。【转载请注明来源】pe的严格模式，age必须是一个数字。

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

在Tuple, List中使用IfExi本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。sts有特殊性，Tuple只会让末尾的I【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。fExists生效：

【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。 
const SomeType = Tuple(String, IfExists(String), Number, IfExists(Boolean), IfExists(Boolean))

上面有三个IfExists，但只有末尾两【原创不易，请尊重版权】【原创不易，请尊重版权】个会生效，第一个IfExists会被严格【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。校验。

转载请注明出处：www.tangshuang.net【版权所有，侵权必究】【作者：唐霜】

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

【作者：唐霜】【作者：唐霜】转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】

这个规则用于校验被校验值是否是传入值的一未经授权，禁止复制转载。原创内容，盗版必究。个实例。

著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】

在HelloType中String，Nu本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】mber，Boolean，Object都原创内容，盗版必究。【转载请注明来源】做了强制，因此，当你想要判断一个值是否是本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。new String出来的怎么办呢？这个本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】时候就得借助InstanceOf：

【作者：唐霜】著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】【版权所有，侵权必究】 
const StringType = new Type(InstanceOf(String))
StringType.assert('xxx') // throw TypeError
StringType.assert(new String('xxx')) // ok

由于HelloType内部本身就会去校验【未经授权禁止转载】【转载请注明来源】一个对象是否是给出的规则类的一个实例，所【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net以，在校验是否是实例的时候其实不需要专门转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。使用InstanceOf:

【版权所有，侵权必究】【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。 
const ins = new MyClass()

const MyClassType = new Type(MyClass)

MyClassType.assert(ins) // ok

之所以提供InstanceOf规则，是用【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。来校验直接属于某个类的实例的情况。例如F【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。ile的实例，同时也是Blob的实例，但本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net是，在使用InstanceOf规则时，只【本文首发于唐霜的博客】【未经授权禁止转载】会通过File，而不通过Blob。另外，【本文首发于唐霜的博客】【访问 www.tangshuang.net 获取更多精彩内容】InstanceOf的最合理使用场景是，【本文受版权保护】【本文首发于唐霜的博客】避免直接校验js内置的构造器，例如Num本文版权归作者所有，未经授权不得转载。【转载请注明来源】ber，new Type(Number)只会校验真实的数字，而无法校验num =【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。 new Number(10)，这个时候转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。就必须new Type(InstanceOf(Number))。著作权归作者所有，禁止商业用途转载。

【未经授权禁止转载】原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】

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

转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【转载请注明来源】【未经授权禁止转载】【作者：唐霜】

在HelloType的校验中，虽然会先校【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】验一个值是否与规定的值相等，然后再考虑其未经授权，禁止复制转载。【转载请注明来源】他校验规则。而String，Number转载请注明出处：www.tangshuang.net【转载请注明来源】，Boolean，Object都被做了强原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net制，因此，如果你这样做：

【本文受版权保护】【版权所有，侵权必究】【访问 www.tangshuang.net 获取更多精彩内容】 
const SomeType = new Type(String)
SomeType.assert(String) // throw TypeError

只会得到一个错误，所以，在这种情况下，默【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。认的相等规则失效了，这个时候就需要借助E【关注微信公众号：wwwtangshuangnet】【转载请注明来源】qual：

著作权归作者所有，禁止商业用途转载。【未经授权禁止转载】本文作者：唐霜，转载请注明出处。【转载请注明来源】【关注微信公众号：wwwtangshuangnet】 
const SomeType = new Type(Equal(String))
SomeType.assert(String) // ok

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

本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net

当一个值不符合你的预期的时候，你想给它一本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net个默认值怎么办呢？例如，你希望api返回【未经授权禁止转载】【转载请注明来源】的children是一个数组，但是api未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net返回给你null，你想把它调整为一个空数【原创不易，请尊重版权】【原创内容，转载请注明出处】组，怎么办呢？用IfNotMatch可以【本文受版权保护】【关注微信公众号：wwwtangshuangnet】办到。

【本文受版权保护】本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】【未经授权禁止转载】 
const SomeType = Dict({
  code: Number,
  data: {
    name: String,
    children: IfNotMatch(List([Object]), [])
  },
})

虽然上面的这句话很像IfExists，但本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】是并不是，IfExists是允许chil原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。dren不存在，而IfNotMatch要【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。求children必须存在，如果不存在，转载请注明出处：www.tangshuang.net【未经授权禁止转载】或者说它不满足List([Object]本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。)，就会用一个空数组去代替。

【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。转载请注明出处：www.tangshuang.net

第三个参数是一个函数，用来动态计算值并返【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。回一个值作为新值赋值给原始数据。

【未经授权禁止转载】【原创内容，转载请注明出处】原创内容，盗版必究。【版权所有】唐霜 www.tangshuang.net【转载请注明来源】 
const SomeType = Dict({
  code: Number,
  data: {
    name: String,
    children: IfNotMatch(List([Object]), (value) => {
      if (!Array.isArray(value)) {
        return []
      }
      else {
        return value.map(item => item && typeof item === 'object' ? item : {})
      }
    })
  },
})

前面说过Rule的第三个参数，IfNot本文版权归作者所有，未经授权不得转载。【转载请注明来源】Match就用了这第三个危险的参数，它会【作者：唐霜】【未经授权禁止转载】修改你的原始值，因此在使用的时候要特别小本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】心。举个例子，你不能在使用trace的场【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】景下使用IfNotMatch，因为tra【本文受版权保护】【本文首发于唐霜的博客】ce会异步执行代码，如果你这个时候使用I【本文受版权保护】著作权归作者所有，禁止商业用途转载。fNotMatch的第二个参数defau【原创不易，请尊重版权】【作者：唐霜】ltValue去覆盖，你会发现，覆盖动作【本文受版权保护】【版权所有】唐霜 www.tangshuang.net位于你整个程序时序的最后，这个时候，bu【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。g可能已经产生了。最大的建议，就是尽可能不要用IfNotM未经授权，禁止复制转载。【原创内容，转载请注明出处】atch。【本文首发于唐霜的博客】

【转载请注明来源】【作者：唐霜】本文作者：唐霜，转载请注明出处。

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

【本文受版权保护】【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。【未经授权禁止转载】

相当于IfExists和IfNotMat著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】ch的组合。当一个属性不存在时，直接忽视【版权所有，侵权必究】【作者：唐霜】这条规则，不进行校验。而如果存在的情况下转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】，就要进行校验，同时，如果校验失败，用新【本文首发于唐霜的博客】【未经授权禁止转载】值去替代原始值。

【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。【原创不易，请尊重版权】【未经授权禁止转载】 
const SomeType = Dict({
  code: Number,
  data: {
    name: String,
    children: IfExistsNotMatch(List([Object]), [])
  },
})

当【本文首发于唐霜的博客】children不存在时，就不进行校验，如果存在时，进行【原创不易，请尊重版权】【访问 www.tangshuang.net 获取更多精彩内容】校验，如果校验结果为失败，那么用一个空数【关注微信公众号：wwwtangshuangnet】【未经授权禁止转载】组作为值赋给children。这对某些api返回的数据有帮助，比如某著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。些api，根据你传入的某个scope参数【本文受版权保护】【关注微信公众号：wwwtangshuangnet】，返回对应的字段给你，不在你传的scop【未经授权禁止转载】【原创不易，请尊重版权】e中的字段不会返回，因此，使用IfExi【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。sts校验比较合理。

【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net【转载请注明来源】

同样的道理，IfExistsNotMat【原创不易，请尊重版权】【本文首发于唐霜的博客】ch会修改你的原始值，尽可能不要用，用的转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。时候也要非常小心。

转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】【本文受版权保护】【版权所有，侵权必究】

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

【原创不易，请尊重版权】【本文首发于唐霜的博客】【转载请注明来源】【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。

这个规则非常微妙，虽然我不推荐你使用它，【转载请注明来源】著作权归作者所有，禁止商业用途转载。但是我希望你知道它的思想，这样你可以更好【本文受版权保护】【版权所有，侵权必究】的使用HelloType。Lambda会转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】检查当前值是否是一个函数，如果是函数的话本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】，会重写这个函数，并且用输入和输出规则进【作者：唐霜】本文作者：唐霜，转载请注明出处。行校验。

【关注微信公众号：wwwtangshuangnet】【本文受版权保护】著作权归作者所有，禁止商业用途转载。 
const SomeType = Dict({
  fn: Lambda(Tuple(String, Number), Object),
})

这个不能多讲，毕竟它是一个比较危险容易出【未经授权禁止转载】转载请注明出处：www.tangshuang.netbug的规则，你应该学习它的思想，去gi转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】thub上读它的源码。

【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】【作者：唐霜】

Validate：自定义消息转载请注明出处：www.tangshuang.net

原创内容，盗版必究。【版权所有，侵权必究】【原创不易，请尊重版权】

这个规则更适合用来做自定义消息，它非常有【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】利于降级HelloType的概念，让基础【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net开发者不必深入了解HelloType的理【版权所有，侵权必究】【本文受版权保护】念，从业务中逐渐过度HelloType的未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】使用方法，我们来看一个例子：

【原创内容，转载请注明出处】【访问 www.tangshuang.net 获取更多精彩内容】本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】 
let SomeType = Dict({
  name: Validate(String, '名字必须为字符串'),
  child: Validate(Any, 'child字段必须填写'),
  age: Validate(value => typeof value === 'number' && value > 10, '年龄必须大于10'),
})

上面规定了一个对象的三个字段的类型，在具【作者：唐霜】【转载请注明来源】体业务中，这个对象可能是表单要提交的对象原创内容，盗版必究。【原创内容，转载请注明出处】，利用这种方式，可以很好的做表单检查：

未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。 
function onSubmit() {
  let data = this.formdata
  let error = SomeType.catch(data)
  if (error) {
    this.toast.error(error.message)
  }
  // ...
}

上面这段绿色的代码进行了数据检查，当用户【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】点击提交按钮的时候，SomeType检查本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。数据，并返回错误提示（只能提示到出错的第本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net一条数据，当用户修改之后，再点提交，如果原创内容，盗版必究。未经授权，禁止复制转载。还有错误，又会提示）。

【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。【原创不易，请尊重版权】

Validate函数的参数如下：【本文首发于唐霜的博客】

【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。原创内容，盗版必究。未经授权，禁止复制转载。

Determine：条件选择未经授权，禁止复制转载。

【访问 www.tangshuang.net 获取更多精彩内容】【转载请注明来源】【作者：唐霜】

这个规则主要用来根据当前属性所在的对象进【未经授权禁止转载】【转载请注明来源】行条件选择，根据对象上其他属性的判断来确【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net定当前这个属性应该是什么类型。比如，当前转载请注明出处：www.tangshuang.net原创内容，盗版必究。这个对象是一个person，而它有一个属【作者：唐霜】转载请注明出处：www.tangshuang.net性叫mustache（胡子），显然，女人著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】是不可能有胡子的，因此，要决定musta【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。che的值的类型，需要依赖于对性别的检查【版权所有，侵权必究】【访问 www.tangshuang.net 获取更多精彩内容】。那么这种情况下，就可以使用Determ原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】ine来做：

本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】【版权所有，侵权必究】【转载请注明来源】 
const PersonType = Dict({
  name: String,
  isMale: Boolean,
  // data type check based on person.isMale
  mustache: Determine(function(person) {
    if (person.isMale) {
      return Number
    }
    else {
      return Null
    }
  }),
})

上面这段代码，当这个人是一个男人的时候，【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】要求mustache属性必须是一个数字，本文版权归作者所有，未经授权不得转载。未经授权，禁止复制转载。否则必须为Null。

【作者：唐霜】【转载请注明来源】【作者：唐霜】

Determine函数的具体参数如下：【本文受版权保护】

未经授权，禁止复制转载。原创内容，盗版必究。本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。

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

【转载请注明来源】转载请注明出处：www.tangshuang.net原创内容，盗版必究。

Async规则也是一个函数，它生成一个特著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】殊的规则，这个规则在默认情况下永远返回t本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.netrue，即不会造成任何校验错误。但是你需【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】要向它传一个函数，这个函数里面进行异步操著作权归作者所有，禁止商业用途转载。【作者：唐霜】作，通过返回Promise来返回一个规则本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。，当Promise resolved之后【原创不易，请尊重版权】【版权所有，侵权必究】，这个返回的规则会替代原有规则，成为新规原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】则。

未经授权，禁止复制转载。【未经授权禁止转载】未经授权，禁止复制转载。未经授权，禁止复制转载。【转载请注明来源】

这个规则适合用在一些需要等待加载的情景：

本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】【原创内容，转载请注明出处】【转载请注明来源】 
const SomeType = new Type({
  test: Async(function() {
    return new Promise((resolve) => {
      setTimeout(() => resolve(Number), 200)
    })
  }),
})

SomeType.assert({ text: '10' }) // 不会报错，因为SomeType的真正规则还没有加载出来
setTimeout(() => {
  SomeType.assert({ test: '10' }) // 会报错，因为SomeType的test的规则已经被设置为Number
}, 300)

上面这段代码，很好演示了在异步校验场景的【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。应用。

【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net

ShouldMatch：同时满足多个著作权归作者所有，禁止商业用途转载。

未经授权，禁止复制转载。【转载请注明来源】【版权所有，侵权必究】【本文首发于唐霜的博客】

在一些特定环境下，你需要一个规则，让当前【本文受版权保护】【作者：唐霜】值同时满足多个检查规则才算通过校验。感觉【本文首发于唐霜的博客】【原创不易，请尊重版权】上，它和Enum是相对的一个规则，Enu【版权所有】唐霜 www.tangshuang.net【转载请注明来源】m要求只需要满足其中之一，而Should著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。Match要求必须全部满足。

转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】【原创不易，请尊重版权】

ShouldMatch函数的具体参数：本文作者：唐霜，转载请注明出处。

原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】 
const SomeType = Dict({
  value: ShouldMatch(
    Validate(Number, 'it should be a number'),
    Validate(value => value === parseInt(value, 10), 'it should be a int number')
   )
})

上面这个例子非常好的解释了它的使用场景。【未经授权禁止转载】【转载请注明来源】Validate规则只能规定一个mess未经授权，禁止复制转载。【原创内容，转载请注明出处】age，但是，有的时候，你需要针对不同的未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。检查结果给出不同的message，这个时本文作者：唐霜，转载请注明出处。【本文受版权保护】候，可以将Validate拆分，并配合S【本文受版权保护】【本文首发于唐霜的博客】houldMatch来用，就可以非常方便【未经授权禁止转载】【本文首发于唐霜的博客】的实现这个目的。

【本文首发于唐霜的博客】【本文受版权保护】【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net

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

著作权归作者所有，禁止商业用途转载。【作者：唐霜】本文版权归作者所有，未经授权不得转载。著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。

这个规则生成器的厉害之处在于，可以通过一【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net个条件去决定该属性是否可以不存在。听上去【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。，逻辑是反的，但是事实时，在某些情况下，【转载请注明来源】未经授权，禁止复制转载。你希望通过一个条件判断来决定这个属性是不【关注微信公众号：wwwtangshuangnet】【本文受版权保护】是存在，如果存在的情况下会使用某个规则。【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net它的用法如下：

【本文受版权保护】本文版权归作者所有，未经授权不得转载。【关注微信公众号：wwwtangshuangnet】 
const SomeType = Dict({
  name: String,
  age: Number,
  knowledge: DetermineExists(data => data.age > 10, KnowledgeType), // 当data.age <= 10时，knowledge属性可以不存在
})

它的使用方法和IfExists极其相似，【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】都是只有在该属性存在的情况下才会运用对应【作者：唐霜】本文版权归作者所有，未经授权不得转载。的type去做数据检查。但是，Deter【原创不易，请尊重版权】【版权所有】唐霜 www.tangshuang.netmineExists会在决定这个属性是否著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】可以不存在时，多加来一层。

【版权所有，侵权必究】【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net

这个方法在一些特别的情况下具有非常重要的转载请注明出处：www.tangshuang.net【原创不易，请尊重版权】作用，例如，有些接口的某些字段，在接口返本文版权归作者所有，未经授权不得转载。【作者：唐霜】回的对象为某种类型时，有些字段不存在，而【本文首发于唐霜的博客】【本文首发于唐霜的博客】另外一些字段只有在该对象为特定类型是才会【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。存在，这是就可以用Determine来规【版权所有，侵权必究】转载请注明出处：www.tangshuang.net定它的规则。

未经授权，禁止复制转载。【转载请注明来源】【原创内容，转载请注明出处】【作者：唐霜】

规则嵌套【原创内容，转载请注明出处】

【未经授权禁止转载】【本文受版权保护】【版权所有】唐霜 www.tangshuang.net

规则可以相互嵌套，但也不尽然。有的时候逻本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】辑很重要，特别是IfExists一般都会【访问 www.tangshuang.net 获取更多精彩内容】【本文首发于唐霜的博客】嵌套规则，举个例子：

【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。【未经授权禁止转载】转载请注明出处：www.tangshuang.net 
const SomeType = new Type({
  color: IfExists(Enum('blue', 'red', 'yellow')),
})

如果color存在的话，就必须为红蓝黄中【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。的一个，否则验证不通过。再比如：

【版权所有，侵权必究】【本文受版权保护】【作者：唐霜】原创内容，盗版必究。 
const SomeType = new Type({
  color: IfExists(Validate(String, '必须是字符串')),
})

这样也是一种形式。【原创内容，转载请注明出处】

转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】未经授权，禁止复制转载。【未经授权禁止转载】

但是未经授权，禁止复制转载。，IfNotMatch和IfExists本文作者：唐霜，转载请注明出处。原创内容，盗版必究。NotMatch不能被嵌套使用，一定、必本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net须、立刻记住这点，因为嵌套不会得到你想要本文版权归作者所有，未经授权不得转载。【作者：唐霜】的结果。当然，IfExistsNotMa【本文受版权保护】【版权所有】唐霜 www.tangshuang.nettch本身就是为了解这个问题出现的，总之【转载请注明来源】著作权归作者所有，禁止商业用途转载。，你不能在其他规则中嵌套这两个规则，否则未经授权，禁止复制转载。未经授权，禁止复制转载。bug出现的时候你可能都找不到原因。

【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net 
// 错误的代码示例
const SomeType = new Type({
  color: IfExists(IfNotMatch(String, '#ffffff')),
})

这种情况，应该使用IfExistsNot【原创内容，转载请注明出处】未经授权，禁止复制转载。Match替代。而类似Validate(IfNotMatch(String, '#ffffff'), '必须是色值')这样的校验规则没有任何意义，而且，也得不未经授权，禁止复制转载。【原创内容，转载请注明出处】到预期的结果。

原创内容，盗版必究。【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】未经授权，禁止复制转载。【版权所有，侵权必究】

HelloType辅助器转载请注明出处：www.tangshuang.net

【原创内容，转载请注明出处】原创内容，盗版必究。【转载请注明来源】

前面的内容基本上已经囊括了HelloTy【版权所有】唐霜 www.tangshuang.net【本文受版权保护】pe类型检查的所有内容，你可以利用上面的【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。内容编程了。但是有一个问题，上面的使用方本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。法太过分散，如果你要进行代码升级的话，非【转载请注明来源】未经授权，禁止复制转载。常麻烦。因此，我提供了一堆辅助器方便统一【转载请注明来源】著作权归作者所有，禁止商业用途转载。代码风格，这样，在用编辑器进行全局搜索时【未经授权禁止转载】【未经授权禁止转载】，就很有用，可以快速定位到代码位置。

未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。【本文受版权保护】著作权归作者所有，禁止商业用途转载。

所有辅助器都以HelloType打头，例【未经授权禁止转载】原创内容，盗版必究。如：

原创内容，盗版必究。【作者：唐霜】【未经授权禁止转载】【版权所有】唐霜 www.tangshuang.net 
HelloType.expect(obj).to.match(SomeType)

这样，你搜索HelloType.expe著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。ct，就可以找到所有断言代码了。

【原创内容，转载请注明出处】【访问 www.tangshuang.net 获取更多精彩内容】【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。

同时，为了方便使用你在使用HelloTy【转载请注明来源】【版权所有，侵权必究】pe辅助器时，不需要非得实例化一个typ本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】e出来，而是可以直接传入rule：

原创内容，盗版必究。【本文受版权保护】未经授权，禁止复制转载。 
HelloType.expect(10).to.match(Number)
let bool = HelloType.is(10).of(Number)

这样，就让使用更简单，不过，这样的话，内【访问 www.tangshuang.net 获取更多精彩内容】【本文受版权保护】部直接使用Type，而不会使用List,【版权所有，侵权必究】【版权所有，侵权必究】 Dict等扩展类型，必要的时候，你最好【本文受版权保护】原创内容，盗版必究。还是先用扩展类型创建type先。

本文作者：唐霜，转载请注明出处。【作者：唐霜】【版权所有】唐霜 www.tangshuang.net

expect.to.match【关注微信公众号：wwwtangshuangnet】

未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。【未经授权禁止转载】

它提供对某个目标值进行校验的方法。Hel【访问 www.tangshuang.net 获取更多精彩内容】【版权所有】唐霜 www.tangshuang.netloType.expect.to.mat本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】ch是assert方法的别称，例如：

【原创内容，转载请注明出处】【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】未经授权，禁止复制转载。 
HelloType.expect(obj).to.match(SomeType)
// 等同于：
SomeType.assert(obj)

这两者是一样的。虽然前面一句的句子长很多著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】，但是这主要是为了代码管理的方便。而且还未经授权，禁止复制转载。【本文首发于唐霜的博客】有好处，先卖关子，后面会讲到。

本文版权归作者所有，未经授权不得转载。【作者：唐霜】未经授权，禁止复制转载。【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。

catch.by未经授权，禁止复制转载。

【未经授权禁止转载】【原创内容，转载请注明出处】【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】原创内容，盗版必究。

HelloType.catch.by是c著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。atch方法的别称：

本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】【转载请注明来源】【版权所有】唐霜 www.tangshuang.net 
var error = HelloType.catch(obj).by(SomeType)
// 等同于：
var error = SomeType.catch(obj)

track.by.with【转载请注明来源】

【版权所有】唐霜 www.tangshuang.net【本文受版权保护】【未经授权禁止转载】

HelloType.track.by.w【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】ith是track.with的别称：

著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】 
var error = await HelloType.track(obj).by(SomeType).with(fn)
// 等同于：
var error = await SomeType.track(obj).with(fn)

trace.by.with原创内容，盗版必究。

【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】

HelloType.trace.by.w【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。ith是trace.with的别称：

【未经授权禁止转载】【转载请注明来源】【原创内容，转载请注明出处】 
var error = await HelloType.trace(obj).by(SomeType).with(fn)
// 等同于：
var error = await SomeType.trace(obj).with(fn)

is.typeof【作者：唐霜】

【转载请注明来源】【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】

HelloType.is.typeof是【原创内容，转载请注明出处】未经授权，禁止复制转载。test的别称：

著作权归作者所有，禁止商业用途转载。【本文受版权保护】本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】 
var bool = HelloType.is(SomeType).typeof(obj)
// 等同于：
var bool = SomeType.test(obj)

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

【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】未经授权，禁止复制转载。【转载请注明来源】原创内容，盗版必究。

与is.typeof形成反转，即参数是颠【原创不易，请尊重版权】【作者：唐霜】倒的。

本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.net 
let bool = HelloType.is(10).of(Number)

of后面跟规则。转载请注明出处：www.tangshuang.net

【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。【转载请注明来源】

decorate原创内容，盗版必究。

【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】本文作者：唐霜，转载请注明出处。

ES7提供了装饰器的能力，用以对一个类及本文作者：唐霜，转载请注明出处。【本文受版权保护】其成员进行装饰。这部分内容，对于比较熟悉【转载请注明来源】【原创内容，转载请注明出处】的开发者应该不陌生，如果你不熟悉，不使用著作权归作者所有，禁止商业用途转载。【作者：唐霜】也是没关系的。

【原创内容，转载请注明出处】【作者：唐霜】【本文受版权保护】

with【作者：唐霜】

【访问 www.tangshuang.net 获取更多精彩内容】【版权所有，侵权必究】【未经授权禁止转载】

HelloType.decorate.w本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。ith可以直接装饰类，也可以装饰属性成员本文版权归作者所有，未经授权不得转载。【作者：唐霜】：

【版权所有，侵权必究】【作者：唐霜】本文作者：唐霜，转载请注明出处。 
@HelloType.decorate.with(ParamsType)
class A {
  @HelloType.decorate.with(ObjectType)
  obj = {}
}

上面这段代码，会在new A的时候，对c【原创内容，转载请注明出处】【作者：唐霜】onstructor的参数进行校验。

【版权所有】唐霜 www.tangshuang.net【本文受版权保护】【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】

input.with【关注微信公众号：wwwtangshuangnet】

原创内容，盗版必究。【转载请注明来源】【本文首发于唐霜的博客】【版权所有，侵权必究】

HelloType.decorate.i【作者：唐霜】【关注微信公众号：wwwtangshuangnet】nput.with可以装饰方法成员，校验【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。它的输入值：

【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【作者：唐霜】 
class A {
  @HelloType.decorate.with(FunctionType)
  @HelloType.decorate.input.with(ParamsType)
  say(msg) {}
}

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

【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】未经授权，禁止复制转载。【版权所有，侵权必究】

HelloType.decorate.o【作者：唐霜】著作权归作者所有，禁止商业用途转载。utput.with可以装饰方法成员，校【关注微信公众号：wwwtangshuangnet】【访问 www.tangshuang.net 获取更多精彩内容】验它的返回值：

著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。【作者：唐霜】【关注微信公众号：wwwtangshuangnet】 
class A {
  @HelloType.decorate.with(FunctionType)
  @HelloType.decorate.input.with(ParamsType)
  @HelloType.decorate.output.with(ReturnType)
  say(msg) {}
}

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

【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】【未经授权禁止转载】【作者：唐霜】

with后面除了可以直接传Type实例之转载请注明出处：www.tangshuang.net【作者：唐霜】外，还可以传一个函数，因为有的时候你不想本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net直接用容器去校验，而是有一定逻辑的去校验【原创不易，请尊重版权】【原创不易，请尊重版权】。函数怎么用呢？

【未经授权禁止转载】本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net 
@HelloType.decorate.input.with((...args) => {
  ParamsType.assert(...args)
})

总之，在你知道装饰器的情况下使用Hell【本文受版权保护】著作权归作者所有，禁止商业用途转载。oType.decorate，会让你的代【版权所有】唐霜 www.tangshuang.net未经授权，禁止复制转载。码减少侵入性。

【原创内容，转载请注明出处】【本文受版权保护】【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net

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

【版权所有，侵权必究】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。

HelloType.define的功能是本文版权归作者所有，未经授权不得转载。【作者：唐霜】，将一个对象转化为规定的类型对应的对象，转载请注明出处：www.tangshuang.net原创内容，盗版必究。在修改对象值的时候，会进行值的类型检查。【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】例如：

【本文首发于唐霜的博客】【转载请注明来源】本文版权归作者所有，未经授权不得转载。 
const ObjType = Dict({
  name: String,
  age: Number,
  sub: {
    key: Object,
  },
})
let obj = HelloType.define({}).by(ObjType)

这需要注意，define不会修改原始值，【本文受版权保护】【关注微信公众号：wwwtangshuangnet】而是先克隆一个备份之后再赋值给obj。d本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.netefine的结果会自带规定的那些属性，例【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net如obj.sub.key已经有了，虽然是【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。undefined，但是不会报错。

【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】

经过define之后，如果你进行赋值ob【原创内容，转载请注明出处】原创内容，盗版必究。j.sub.key = 10就会报错，因【本文受版权保护】原创内容，盗版必究。为obj.sub.key必须是一个obj未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。ect。这个时候，你可能还会用上Lamb转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】da，可以往上翻看它的具体方法。

转载请注明出处：www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。

其他方法著作权归作者所有，禁止商业用途转载。

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

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

未经授权，禁止复制转载。【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。

安静模式，仅对HelloType.exp转载请注明出处：www.tangshuang.net【原创内容，转载请注明出处】ect.to.match有效，直接使用容本文版权归作者所有，未经授权不得转载。【本文受版权保护】器不会生效。所谓安静模式，意思是不通过t转载请注明出处：www.tangshuang.net【转载请注明来源】hrow TypeError终止进程，但【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。是抛出错误。

【作者：唐霜】原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】

开启安静模式下，你还可以通过bind绑定【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net一个函数，用以收集错误。先看下开启安静模【作者：唐霜】【关注微信公众号：wwwtangshuangnet】式：

【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】【原创不易，请尊重版权】未经授权，禁止复制转载。未经授权，禁止复制转载。 
HelloType.silent = true
HelloType.expect(obj).to.match(SomeType) // 如果不匹配，不会报错中断进程，而是console.error打印错误，且不会阻断程序

从这点上讲，只有expect.to.ma转载请注明出处：www.tangshuang.net【未经授权禁止转载】tch、define里面的不通过情况下可本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】以使用silent模式。因此，你在想使用【原创内容，转载请注明出处】【原创内容，转载请注明出处】安静模式的时候，要选对方法。当安静模式开【访问 www.tangshuang.net 获取更多精彩内容】【本文受版权保护】启时，expect.to.match不会【本文首发于唐霜的博客】【未经授权禁止转载】阻断进程，因此，你也可以利用这点做些动作【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net。

【作者：唐霜】【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】

Silent和silent是一模一样的，转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。只是为了编程习惯，提供大小写区分而已。

【作者：唐霜】【转载请注明来源】本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】

注意：安静模式是全局的，一旦你设置了He【版权所有，侵权必究】【版权所有，侵权必究】lloType.silent为true，【本文受版权保护】著作权归作者所有，禁止商业用途转载。其他任何你使用HelloType.exp转载请注明出处：www.tangshuang.net【关注微信公众号：wwwtangshuangnet】ect.to.match的地方都会被改变著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】为安静模式，因此，你必须确定是不是要全局【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】开启安静模式。如果不是，建议你从正确的H【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。elloType方法中挑选使用。

转载请注明出处：www.tangshuang.net【作者：唐霜】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。

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

【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。

当你使用辅助器的时候，有的时候，你想传入本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】一个函数，用来捕获任何可能出现的报错。这原创内容，盗版必究。未经授权，禁止复制转载。个时候，你可以使用bind来绑定一个函数【本文受版权保护】本文作者：唐霜，转载请注明出处。：

【版权所有】唐霜 www.tangshuang.net【本文受版权保护】【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net 
const fn = (error) => {
  saveToCacheStore(error)
}
HelloType.bind(fn)

当你在使用expect.to.match本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】或者使用define的时候，运行过程中由【版权所有】唐霜 www.tangshuang.net【转载请注明来源】于数据和类型不匹配抛出错误时，但fn会运未经授权，禁止复制转载。【未经授权禁止转载】行。这样，无论你是否在安静模式下，都可以本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。获得错误信息，并把它记录在本地，以备之后【关注微信公众号：wwwtangshuangnet】【本文首发于唐霜的博客】做分析。

本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net

另外，trace和track辅助器原本是本文作者：唐霜，转载请注明出处。【作者：唐霜】要传入一个fn到with中，用来抓取错误【本文受版权保护】未经授权，禁止复制转载。，而如果你使用bind绑定了函数，就可以著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】不用传with也可以收集到错误信息。

【原创内容，转载请注明出处】【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。

unbind原创内容，盗版必究。

原创内容，盗版必究。【原创内容，转载请注明出处】【原创不易，请尊重版权】

unbind是bind的反函数，用以直接【原创不易，请尊重版权】原创内容，盗版必究。解除fn的绑定。解绑之后，抛出错误时，这本文作者：唐霜，转载请注明出处。【版权所有，侵权必究】个函数就不会执行了。

转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。【本文受版权保护】转载请注明出处：www.tangshuang.net

Error原创内容，盗版必究。

本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net【本文受版权保护】

这是整个HelloType里面最隐性的一【原创内容，转载请注明出处】【原创不易，请尊重版权】个部分，开发者在默认情况下不会用到Hel【版权所有】唐霜 www.tangshuang.net【未经授权禁止转载】loType.Error，但是实际上，每【本文首发于唐霜的博客】【本文受版权保护】次接收到HelloType默认抛出的错误未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。时，错误的类型都是它。HelloType本文作者：唐霜，转载请注明出处。【版权所有】唐霜 www.tangshuang.net.Error是基于TypeError的错【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】误对象扩展，它具备非常高级的功能，因此，【本文受版权保护】原创内容，盗版必究。在自定义一个Rule的时候，建议返回He【版权所有，侵权必究】【作者：唐霜】lloType.Error的实例，这样才【原创不易，请尊重版权】【本文首发于唐霜的博客】能发挥HelloType的最大功能。

【原创内容，转载请注明出处】【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】

引入和使用【版权所有，侵权必究】

【版权所有】唐霜 www.tangshuang.net【转载请注明来源】本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。

想要使用HelloTypeError很简【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net单，通过包引入即可：

【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】 
import HelloType from 'hello-type'

这样之后，你就可以像使用js原生的Err【版权所有，侵权必究】【访问 www.tangshuang.net 获取更多精彩内容】or一样使用HelloType.Erro本文作者：唐霜，转载请注明出处。本文作者：唐霜，转载请注明出处。r。

著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。著作权归作者所有，禁止商业用途转载。【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。 
let err = new HelloType.Error(message)

秘密【转载请注明来源】

本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】【原创不易，请尊重版权】

HelloType.Error比任何Er本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。ror类型都更加强化，它拥有更为复杂的结【访问 www.tangshuang.net 获取更多精彩内容】【转载请注明来源】构，但仍然保持Error的基本结构。那么转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。接下来，让我们来看看它都拥有哪些神秘的东本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net东。

【转载请注明来源】【转载请注明来源】著作权归作者所有，禁止商业用途转载。

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

【转载请注明来源】【关注微信公众号：wwwtangshuangnet】【版权所有】唐霜 www.tangshuang.net

和普通Error不同，HelloType【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net.Error是为HelloType服务的【本文受版权保护】【本文受版权保护】，在HelloType中，必须追踪到错误【作者：唐霜】【版权所有】唐霜 www.tangshuang.net发生的具体路径，因此，当一个错误产生时，【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。追踪信息就至关重要。而这些追踪信息，不仅转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。能得到错误发生时的基本信息，而且具体是什【版权所有，侵权必究】【版权所有，侵权必究】么值发生了错误，都可以通过检查error【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。.traces得到。有兴趣的你，可以打印本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net出来看看。

著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】【关注微信公众号：wwwtangshuangnet】转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net 
let error = HelloType.catch(some).by(SomeType)
if (error) {
  console.log(error.traces)
}

addtrace(traceinfo)原创内容，盗版必究。

【本文首发于唐霜的博客】转载请注明出处：www.tangshuang.net原创内容，盗版必究。原创内容，盗版必究。

但是，如果一个普通用户，想要独立使用He本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】lloType.Error时，就可以使用【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】error.addtrace来在trac未经授权，禁止复制转载。【关注微信公众号：wwwtangshuangnet】es链中添加一个追踪记录，添加使用的是u转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。nshift，因此新增的记录被加在整个链【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。条的最前面。这是由于我们在使用trace本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】s的时候，其实它是一个自下而上冒泡的过程著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】。总之，最后，traces这个数组记录了著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net从错误发生的位置，到最外层的追踪，以此可【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】以知道到底是型式的哪个位置发生了问题。

【原创内容，转载请注明出处】【原创不易，请尊重版权】原创内容，盗版必究。

addtrace的参数是任意的对象，它只未经授权，禁止复制转载。转载请注明出处：www.tangshuang.net是用来作为记录的，如果是脱离HelloT【转载请注明来源】【本文首发于唐霜的博客】ype独立使用，开发者可以自己规定一种对本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net象模式。

原创内容，盗版必究。【作者：唐霜】【版权所有】唐霜 www.tangshuang.net【转载请注明来源】 
error.addtrace({
  key: 'name',
  value: 'tomy',
})

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

【本文受版权保护】原创内容，盗版必究。【本文首发于唐霜的博客】

而message和普通的Error不同，未经授权，禁止复制转载。【未经授权禁止转载】普通的Error传入的message就是本文作者：唐霜，转载请注明出处。【作者：唐霜】最后Error抛出的错误信息。但是Hel【本文首发于唐霜的博客】原创内容，盗版必究。loType.Error的message本文作者：唐霜，转载请注明出处。原创内容，盗版必究。高级很多，它支持{插值}。

未经授权，禁止复制转载。未经授权，禁止复制转载。【转载请注明来源】【本文受版权保护】【原创不易，请尊重版权】 
let error = new HelloType.Error('{name} is wrong.', {
  name: 'tomy',
})

而最终message内容展示出什么内容，原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。summary才是message的值的来原创内容，盗版必究。【原创内容，转载请注明出处】源。这就非常好玩了，有了这样的功能，那么本文版权归作者所有，未经授权不得转载。原创内容，盗版必究。message的内容就可以根据trace原创内容，盗版必究。未经授权，禁止复制转载。信息发生变化。因此，在创建一个error【版权所有，侵权必究】【关注微信公众号：wwwtangshuangnet】的时候，最好是可以提前通过插值来安排你的【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。消息。

【本文受版权保护】【作者：唐霜】【转载请注明来源】【本文受版权保护】转载请注明出处：www.tangshuang.net 
let error = new HelloType.Error('{stack} at {line}:{column}')

error.addtrace({
  stack: 'type error',
  line: 10,
  column: 20,
})

console.log(error.message)

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

转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】原创内容，盗版必究。

而将所有的traces整理之后，就是su未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。mmary。你可以通过直接读取error未经授权，禁止复制转载。原创内容，盗版必究。.summary来得到摘要信息，这些信息未经授权，禁止复制转载。原创内容，盗版必究。将被用作构建message的材料，你可以【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】直接在message中使用它们。它有几个【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】非常有用的属性：keyPath、shou【原创内容，转载请注明出处】【作者：唐霜】ld、receive。

【本文首发于唐霜的博客】【版权所有，侵权必究】【未经授权禁止转载】【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.net 
console.log(error.summary.stack)

因为对于输出的message而言，由于考【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net虑到输出结果的长度和一些敏感性问题，sh【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】ould和receive输出的都是摘要信本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net息，它会对原始信息进行简单处理，例如截取【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。字符串、省略object的属性值、只显示未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。数组的长度等。

著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】【本文首发于唐霜的博客】【作者：唐霜】【访问 www.tangshuang.net 获取更多精彩内容】

translate(message, r【版权所有，侵权必究】转载请注明出处：www.tangshuang.neteplace)

本文作者：唐霜，转载请注明出处。【访问 www.tangshuang.net 获取更多精彩内容】【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。

不过，一般情况下，HelloType抛出【访问 www.tangshuang.net 获取更多精彩内容】【原创内容，转载请注明出处】的错误，都是提前预设好了message的本文作者：唐霜，转载请注明出处。本文版权归作者所有，未经授权不得转载。。下文会讲怎么修改默认的message，【转载请注明来源】本文作者：唐霜，转载请注明出处。但是，如果你在得到一个error的时候，【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。又不想用它默认的message，想在特殊转载请注明出处：www.tangshuang.net本文作者：唐霜，转载请注明出处。情况下，提供特殊的message信息。这本文作者：唐霜，转载请注明出处。【版权所有，侵权必究】个时候，可以使用error的transl【关注微信公众号：wwwtangshuangnet】【作者：唐霜】ate方法：

本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net著作权归作者所有，禁止商业用途转载。 
let msg = error.translate('{keyPath}不在{receive}中。')
console.log(msg)

这样，你就可以利用error的summa【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】ry来得到一个新的message信息，在原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。特殊情况下，返回特殊文本体现。具体的案例本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net，你可以看下我github上exampl未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。es目录下的例子。

【本文受版权保护】【作者：唐霜】【原创内容，转载请注明出处】【关注微信公众号：wwwtangshuangnet】本文作者：唐霜，转载请注明出处。

它的第二个参数是一个Boolean变量，【转载请注明来源】【未经授权禁止转载】当设置为true时，表示经过transl著作权归作者所有，禁止商业用途转载。【关注微信公众号：wwwtangshuangnet】ate之后，替换掉原始的error.me未经授权，禁止复制转载。本文作者：唐霜，转载请注明出处。ssage，下一次你再读取error.m【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】essage将会是经过translate【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。之后的内容。

未经授权，禁止复制转载。原创内容，盗版必究。未经授权，禁止复制转载。【版权所有】唐霜 www.tangshuang.net 
error.translate('{keyPath}不在{receive}中。', true)
console.log(error.message)

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

本文作者：唐霜，转载请注明出处。【原创不易，请尊重版权】【本文受版权保护】转载请注明出处：www.tangshuang.net

修改HelloType内置的错误提示语。未经授权，禁止复制转载。转载请注明出处：www.tangshuang.netHelloType的所有错误提示语位于e【本文首发于唐霜的博客】【未经授权禁止转载】rror.js里面，你可以阅读源码，查阅【原创内容，转载请注明出处】【本文受版权保护】所有可以修改的提示语信息。通过messa【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。ges方法，传入一个对象，用来覆盖默认提【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。示语。提示语里面支持{插值}，但是每个提【本文首发于唐霜的博客】【转载请注明来源】示语的插值是固定的，请查看源码了解。例如【关注微信公众号：wwwtangshuangnet】【版权所有，侵权必究】你可以这样：

【作者：唐霜】【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】【转载请注明来源】 
HelloType.Error.messages.refuse = '{keyPath}不符合类型{should}，接收到的是{receive}。'

你也可以打印出HelloType.Err【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。or.messages来看看messag【未经授权禁止转载】著作权归作者所有，禁止商业用途转载。es里面到底都有些什么，以此决定都要修改【访问 www.tangshuang.net 获取更多精彩内容】【作者：唐霜】什么。

【原创不易，请尊重版权】【作者：唐霜】转载请注明出处：www.tangshuang.net【本文首发于唐霜的博客】

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

【本文首发于唐霜的博客】【本文受版权保护】【原创内容，转载请注明出处】

以上就是有关HelloType的所有使用【本文受版权保护】【本文受版权保护】方法，当然，有一些隐性的东西我不会透露出本文作者：唐霜，转载请注明出处。转载请注明出处：www.tangshuang.net来，因为有些方法并不常用，或者不应该用，本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】有兴趣的读者可以自己去阅读源码是怎么实现【转载请注明来源】本文版权归作者所有，未经授权不得转载。的。

【版权所有】唐霜 www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【访问 www.tangshuang.net 获取更多精彩内容】

HelloType是我花了一个周末时间写未经授权，禁止复制转载。【本文受版权保护】完的，但后面陆续又花了几周把最终的形态确【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。定下来，可以说是这段时间在api数据检查著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】过程中拼命挣扎的结果。

转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。

我在自己的博客中提到过，开源的真正意义，【转载请注明来源】未经授权，禁止复制转载。不是在于提供一款免费的产品，而是在于提供【本文受版权保护】【版权所有】唐霜 www.tangshuang.net一种问题的解决思路，给其他人去参考。都说本文版权归作者所有，未经授权不得转载。【原创内容，转载请注明出处】开发中不要重复造轮子，但是由于开源协议，【转载请注明来源】【本文受版权保护】或者具体某个需求的不确定性，改造轮子是很【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。正常的事，我觉得“不要重复造轮子”是说，【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.net不应该为了解决前人已经解决过的问题，从零【原创内容，转载请注明出处】【转载请注明来源】开始思考，构建一套自己的实现，而应该站在【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net巨人肩膀上，直接把前人解决问题的思维方式本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】甚至思路借鉴过来，在此基础上，再去实现具【原创不易，请尊重版权】【关注微信公众号：wwwtangshuangnet】体需求。一味的拒绝使用别人的代码（思路）【原创不易，请尊重版权】本文作者：唐霜，转载请注明出处。或一味的否定拒绝使用别人的代码我认为都是转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。不合理的。最近红芯浏览器内核的事闹的沸沸【作者：唐霜】【作者：唐霜】扬扬，我觉得可能是整个业界的一种自卑心态【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。。实际上，任何一项技术，都是站在前人的肩【版权所有，侵权必究】【原创不易，请尊重版权】膀上获得成功，chrome内核也用了很多【关注微信公众号：wwwtangshuangnet】【未经授权禁止转载】别人的东西，做一款基于Chrome内核的著作权归作者所有，禁止商业用途转载。【作者：唐霜】浏览器是没有什么错的，只不过在推广的时候【未经授权禁止转载】【转载请注明来源】，打上一些“首款自主研发”这样的词汇，不【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。免让人觉得是在骗国家的钱。好了，这种吐槽【转载请注明来源】【版权所有】唐霜 www.tangshuang.net也没有太大意义，只希望读者能够从Hell原创内容，盗版必究。著作权归作者所有，禁止商业用途转载。oType项目中得到一点启发，根据自己的【原创内容，转载请注明出处】【访问 www.tangshuang.net 获取更多精彩内容】需要获取需要的部分。

【未经授权禁止转载】【转载请注明来源】【本文首发于唐霜的博客】【作者：唐霜】【原创不易，请尊重版权】
【版权所有，侵权必究】本文版权归作者所有，未经授权不得转载。【本文受版权保护】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。本文作者：唐霜，转载请注明出处。未经授权，禁止复制转载。【本文首发于唐霜的博客】本文作者：唐霜，转载请注明出处。【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】【本文受版权保护】【转载请注明来源】【版权所有，侵权必究】【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】著作权归作者所有，禁止商业用途转载。【版权所有】唐霜 www.tangshuang.net【作者：唐霜】【未经授权禁止转载】【版权所有，侵权必究】【原创不易，请尊重版权】著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】【转载请注明来源】【版权所有，侵权必究】著作权归作者所有，禁止商业用途转载。未经授权，禁止复制转载。未经授权，禁止复制转载。【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。【关注微信公众号：wwwtangshuangnet】原创内容，盗版必究。【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。【原创内容，转载请注明出处】【未经授权禁止转载】【本文受版权保护】【本文首发于唐霜的博客】未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。【访问 www.tangshuang.net 获取更多精彩内容】【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】本文版权归作者所有，未经授权不得转载。本文版权归作者所有，未经授权不得转载。【版权所有，侵权必究】未经授权，禁止复制转载。【版权所有，侵权必究】【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net【本文首发于唐霜的博客】【版权所有】唐霜 www.tangshuang.net

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

2018-08-26 | , ,

已有20条评论
  1. sunflower 2019-03-08 20:37

    目前有个问题就是，后端正常返回对象，降级返回[]，就会有问题

    回复
  2. sunflower 2019-03-08 20:26

    如果是多种类型校验，既可以是对象，也可以是数组

    回复
    • 否子戈 2019-03-08 22:50

      灵活运用各个方法，才能得到你想要到结果，例如使用Enum，IfNotMatch等，总之，HelloType是一个非常灵活的系统，你需要在实际使用的时候根据自己的情况选择不同的方式来创建规则。

      回复
      • sunflower 2019-03-10 14:47

        const DistType = Dict({
            name: String,
            age: Number
          })
          const SomeType = {
            ret: Number,
            data: IfNotMatch(DistType, [])
          }
          const some = {
            ret: 1,
            data: []
          }

          HelloType.expect(some).to.match(SomeType)
        Enum不太适合，IfNotMatch没有实现，如果传入空数组，不报错，感觉实现不了我的需求

        回复
        • 否子戈 2019-03-10 22:01

          你具体要实现什么目的？

          回复
          • sunflower 2019-03-11 10:08

            可以是两种数据结构，对象 或者 数组 ，DIct || LIst ，能实现吗

          • 否子戈 2019-03-11 10:11

            Enum(Dict, List)

  3. qte 2019-01-04 17:01

    用了一下今天，我发现必须显式声明HelloType.Slient = true;
    不然我的chrome console里没有任何内容（另外slient拼错了）。
    另外使用上，把trace放在快速入门demo更明显的位置会比较好吧，match的返回值也应该强调下（个人建议）。

    回复
    • 否子戈 2019-01-04 22:19

      感谢指出单词拼写错误！！！
      不过你指出的无法打印错误的情况我没遇到，可否将你的用法贴出来看下

      回复
  4. sunflower 2019-01-01 16:29

    打印错误的时候能打印后端传递的整个对象吗

    回复
    • 否子戈 2019-01-01 16:36

      为了避免敏感数据问题，输出的错误提示中去掉了一些东西，不过你可以在检验的时候自己获取error，然后读取error.summary来得到更丰富的信息。
      另外，你的具体使用场景是怎样？可以把代码贴出来，我看看有没有什么更好的办法。

      回复
      • sunflower 2019-01-02 10:26

        helloType.expect(resData).to.match(shopqueryType) 能error能打印整个后端对象resData详情信息吗？目前好像只能自己记录了，是吗

        回复
        • 否子戈 2019-01-02 10:29

          所有的error都有一个summary属性，可以打出来看，注意看文档

          回复
        • 否子戈 2019-01-02 10:31

          另外，你后端都整个response是你都入参啊，不需要再到HelloType里面去打印，直接打印出来就可以了

          回复
          • sunflower 2019-01-02 10:34

            我现在就是要在错误的时候记录，后端返回的整个对象，方便记录，error. summary好像并不能满足

          • 否子戈 2019-01-02 11:15

            HelloType.track(resData).by(shopqueryType).with(error => {
              console.error(error.translate(‘后台返回数据 {keyPath} 应该是 {should} ，后台返回数据为：’), resData)
            })

            方法有很多，看你怎么去用error的用法参考 https://www.tangshuang.net/5625.html#title-9-2

  5. 玲玲 2018-12-27 18:09

    如果发现类型不对，能实现自动转化吗

    回复
    • 否子戈 2018-12-27 18:11

      可以用IfNotMatch试试

      回复
      • 玲玲 2018-12-27 20:25

        IfNotMatch(String) 第二个参数是默认值转了

        回复
        • 否子戈 2018-12-27 23:29

          没明白你意思

          回复