Awesome 社區模塊

A simple and composable way


Superstruct makes it easy to define interfaces and then validate JavaScript data against them. Its type annotation API was inspired by

But Superstruct is designed for validating data at runtime, so it throws (or returns) detailed runtime errors for you or your end users. This is especially useful in situations like accepting arbitrary input in a REST or GraphQL API. But it can even be used to validate internal data structures at runtime when needed.


Superstruct exports astruct

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
import { struct } from 'superstruct' const Article = struct({ id: 'number', title: 'string', is_published: 'boolean?', tags: ['string'], author: { id: 'number', }, }) const data = { id: 34, title: 'Hello World', tags: ['news', 'features'], author: { id: 1, }, } const article = Article(data) // This will throw when the data is invalid, and return the data otherwise. // If you'd rather not throw, use `Struct.validate()` or `Struct.test()`.

It recognizes all the native JavaScript types out of the box. But you can also define your own custom data types—specific to your application's requirements—by using thesuperstruct

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
import { superstruct } from 'superstruct' import isUuid from 'is-uuid' import isEmail from 'is-email' const struct = superstruct({ types: { uuid: value => isUuid.v4(value), email: value => isEmail(value) && value.length < 256, }, }) const User = struct({ id: 'uuid', email: 'email', is_admin: 'boolean?', }) const data = { id: 'c8d63140-a1f7-45e0-bfc6-df72973fea86', email: '', } const user = User(data)

Superstruct supports more complex use cases too like defining list or scalar structs, applying default values, composing structs inside each other, returning errors instead of throwing them, etc. For more information read the full


There are lots of existing validation libraries—joiexpress-validatorvalidator.jsyupajvis-my-json-valid

  • They don't expose detailed errors.

  • They make custom types hard.

  • They don't encourage single sources of truth.

  • They don't throw errors.throw

  • They don't pre-compile schemas.

  • They're tightly coupled to other concerns.

  • They use JSON Schema.

Of course, not every validation library suffers from all of these issues, but most of them exhibit at least one. If you've run into this problem before, you might like Superstruct.

Which brings me to how Superstruct solves these issues...


  1. Customizable types.

  2. Unopinionated defaults.

  3. Composable interfaces.

  4. Terse schemas.

  5. Compiled validators.

  6. Useful errors.

  7. Familiar API.


Try out the

Demo screenshot.


Superstruct's API is very flexible, allowing it to be used for a variety of use cases on your servers and in the browser. Here are a few examples of common patterns...


Read the getting started guide to familiarize yourself with how Superstruct works. After that, check out the full API reference for more detailed information about structs, types and errors...


This package is MIT-licensed.