Javascript运行时类型检查引擎

Question

I've been using the Closure Compiler for some time and i've been wondering if there's some engine to make runtime validations of data types .

The fact is types allow people to make less mistakes . For example, in Haskell , lets say Int , any datatype must have a value, you just can't specify null or undefined to a value if it doesn't allow it. Anyways you can specify a wrapper like Maybe Int to make it nullable . Which means that the value is null or not, and if it's not null, you can extract the value . But you have first to check if it's null, there's no way to access the value first.

Closure Compiler does a pretty good job validating data types statically. Some things are missing, like stronger null/undefined validations. Other things which escape from Closure Compiler are type checks with data downloaded from server. Even if you trust your server, specifications change and your code does also. Tests can validate this kind of mismatches, but it would be better if those validations could occur directly in code. They could even log errors found trying to match a type.

The following code is a minimalist example of a server response:

/**
 * Server result data types
 * @param {T} t [description]
 * @template T
 */
ServerResult = {
  /**
   * Result code from server
   * @type {Number}
   */
  code: 0,

  /**
   * Result data from server
   * @type {T}
   */
   data: null,

  /**
   * Message of the server in case something didn't go as expected
   * @type {String}
   */
  message: ''
};

Result.data could even be another datatype (a record, for example). Right now what i'm doing is to recursively check the type contained in the default instance and compare it to the downloaded version .

1. Is there a better way to do this?
2. Is there a library I could be using instead of rewritting the wheel?
3. Is this a nonsense?

Answer 1

There are quite a few libraries out there to help validate data types in JavaScript, but I believe the most comprehensive and popular one is tcomb (and its related library tcomb-validation ).

There's also joi from the folks who created hapi for Node.js. However, I've found that trying to run joi in the browser can be a hassle. Also, I've found it more difficult to capture complex data types using joi compared to tcomb, but this will depend on your use case.

Answer 2

You can also try Runtyper - a Babel plugin that performs types validation in runtime. Comparing to tcomb it does not force you to write type annotations. Instead it guess variable type from operation itself.

For your example, if server result contains incorrect code value:

var ServerResult = {
  code: 'unknown',
  ...
}

and later you compare code to number :

if (ServerResult.code === 0) { ... }

Runtyper will show warning in console:

Strict compare of different types: "unknown" (string) === 0 (number)