yup
v1 Because I finally got around to it
Yup 是一个用于运行时值解析和验证的模式构建器。定义架构、转换值以匹配、断言现有值的形状，或两者兼而有之。是的，模式非常具有表现力，并且允许对复杂的、相互依赖的验证或值转换进行建模。
您正在查看 v1.0.0 的文档，是的，v1 之前的文档可用：此处
杀手级特点：
模式由解析操作（转换）以及关于输入值的断言（测试）组成。验证输入值以对其进行解析并运行配置的断言集。将方法链接在一起以构建模式。
import { object , string , number , date , InferType } from 'yup' ;
let userSchema = object ( {
name : string ( ) . required ( ) ,
age : number ( ) . required ( ) . positive ( ) . integer ( ) ,
email : string ( ) . email ( ) ,
website : string ( ) . url ( ) . nullable ( ) ,
createdOn : date ( ) . default ( ( ) => new Date ( ) ) ,
} ) ;
// parse and assert validity
let user = await userSchema . validate ( await fetchUser ( ) ) ;
type User = InferType < typeof userSchema > ;
/* {
name: string;
age: number;
email?: string | undefined
website?: string | null | undefined
createdOn: Date
}*/使用模式将输入值强制或“转换”为正确的类型，并可选择将该值转换为更具体和特定的值，而无需进行进一步的断言。
// Attempts to coerce values to the correct type
let parsedUser = userSchema . cast ( {
name : 'jimmy' ,
age : '24' ,
createdOn : '2014-09-23T19:25:25Z' ,
} ) ;
// ✅ { name: 'jimmy', age: 24, createdOn: Date }知道您的输入值已经被解析了吗？您可以“严格”验证输入，并避免运行解析逻辑的开销。
// ValidationError "age is not a number"
let parsedUser = await userSchema . validate (
{
name : 'jimmy' ,
age : '24' ,
} ,
{ strict : true } ,
) ; yupreach(schema: Schema, path: string, value?: object, context?: object): SchemaaddMethod(schemaType: Schema, name: string, method: ()=> Schema): voidref(path: string, options: { contextPrefix: string }): Reflazy((value: any) => Schema): LazyValidationError(errors: string | Array<string>, value: any, path: string)SchemaSchema.clone(): SchemaSchema.label(label: string): SchemaSchema.meta(metadata: SchemaMetadata): SchemaSchema.describe(options?: ResolveOptions): SchemaDescriptionSchema.concat(schema: Schema): SchemaSchema.validate(value: any, options?: object): Promise<InferType<Schema>, ValidationError>Schema.validateSync(value: any, options?: object): InferType<Schema>Schema.validateAt(path: string, value: any, options?: object): Promise<InferType<Schema>, ValidationError>Schema.validateSyncAt(path: string, value: any, options?: object): InferType<Schema>Schema.isValid(value: any, options?: object): Promise<boolean>Schema.isValidSync(value: any, options?: object): booleanSchema.cast(value: any, options = {}): InferType<Schema>Schema.isType(value: any): value is InferType<Schema>Schema.strict(enabled: boolean = false): SchemaSchema.strip(enabled: boolean = true): SchemaSchema.withMutation(builder: (current: Schema) => void): voidSchema.default(value: any): SchemaSchema.getDefault(options?: object): AnySchema.nullable(message?: string | function): SchemaSchema.nonNullable(message?: string | function): SchemaSchema.defined(): SchemaSchema.optional(): SchemaSchema.required(message?: string | function): SchemaSchema.notRequired(): SchemaSchema.typeError(message: string): SchemaSchema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema别名： equalsSchema.notOneOf(arrayOfValues: Array<any>, message?: string | function)Schema.when(keys: string | string[], builder: object | (values: any[], schema) => Schema): SchemaSchema.test(name: string, message: string | function | any, test: function): SchemaSchema.test(options: object): SchemaSchema.transform((currentValue: any, originalValue: any) => any): Schemastring.required(message?: string | function): Schemastring.length(limit: number | Ref, message?: string | function): Schemastring.min(limit: number | Ref, message?: string | function): Schemastring.max(limit: number | Ref, message?: string | function): Schemastring.matches(regex: Regex, message?: string | function): Schemastring.matches(regex: Regex, options: { message: string, excludeEmptyString: bool }): Schemastring.email(message?: string | function): Schemastring.url(message?: string | function): Schemastring.uuid(message?: string | function): Schemastring.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number})string.datetime(message?: string | function)string.ensure(): Schemastring.trim(message?: string | function): Schemastring.lowercase(message?: string | function): Schemastring.uppercase(message?: string | function): Schemanumber.min(limit: number | Ref, message?: string | function): Schemanumber.max(limit: number | Ref, message?: string | function): Schemanumber.lessThan(max: number | Ref, message?: string | function): Schemanumber.moreThan(min: number | Ref, message?: string | function): Schemanumber.positive(message?: string | function): Schemanumber.negative(message?: string | function): Schemanumber.integer(message?: string | function): Schemanumber.truncate(): Schemanumber.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schemadate.min(limit: Date | string | Ref, message?: string | function): Schemadate.max(limit: Date | string | Ref, message?: string | function): Schemaarray.of(type: Schema): thisarray.json(): thisarray.length(length: number | Ref, message?: string | function): thisarray.min(limit: number | Ref, message?: string | function): thisarray.max(limit: number | Ref, message?: string | function): thisarray.ensure(): thisarray.compact(rejector: (value) => boolean): Schemaobject.shape(fields: object, noSortEdges?: Array<[string, string]>): Schemaobject.json(): thisobject.concat(schemaB: ObjectSchema): ObjectSchemaobject.pick(keys: string[]): Schemaobject.omit(keys: string[]): Schemaobject.from(fromKey: string, toKey: string, alias: boolean = false): thisobject.noUnknown(onlyKnownKeys: boolean = true, message?: string | function): Schemaobject.camelCase(): Schemaobject.constantCase(): Schema模式定义由解析“转换”组成，“转换”将输入操纵为所需的形状和类型，“测试”对解析的数据进行断言。模式还存储一堆“元数据”，即有关模式本身的详细信息，可用于改进错误消息、构建动态使用模式的工具或将模式序列化为另一种格式。
为了最大程度地灵活，yup 允许单独运行解析和断言以满足特定需求
每个内置类型都实现了基本类型解析，这在解析序列化数据（例如 JSON）时派上用场。此外，类型还实现了可以启用的特定于类型的转换。
let num = number ( ) . cast ( '1' ) ; // 1
let obj = object ( {
firstName : string ( ) . lowercase ( ) . trim ( ) ,
} )
. json ( )
. camelCase ( )
. cast ( '{"first_name": "jAnE "}' ) ; // { firstName: 'jane' }可以添加自定义转换
let reversedString = string ( )
. transform ( ( currentValue ) => currentValue . split ( '' ) . reverse ( ) . join ( '' ) )
. cast ( 'dlrow olleh' ) ; // "hello world"转换形成一个“管道”，其中前一个转换的值通过管道传输到下一个转换。当输入值undefined时，yup 将应用模式默认值（如果已配置）。
当心！不保证值是转换函数中的有效类型。之前的转换可能失败。例如，数字变换可以接收输入值、
NaN或数字。
是的，模式对输入值运行“测试”。测试断言输入符合某些标准。测试与转换不同，因为它们不会更改或更改输入（或其类型），并且通常保留用于难以（如果不是不可能）以静态类型表示的检查。
string ( )
. min ( 3 , 'must be at least 3 characters long' )
. email ( 'must be a valid email' )
. validate ( 'no' ) ; // ValidationError与转换一样，测试可以即时定制
let jamesSchema = string ( ) . test (
'is-james' ,
( d ) => ` ${ d . path } is not James` ,
( value ) => value == null || value === 'James' ,
) ;
jamesSchema . validateSync ( 'James' ) ; // "James"
jamesSchema . validateSync ( 'Jane' ) ; // ValidationError "this is not James"注意：与转换不同，自定义测试中的
value保证是正确的类型（在本例中是可选字符串）。在这些情况下，它仍然可能是undefined或为null具体取决于您的架构，您可能希望对缺失值返回true除非您的转换做出与存在相关的断言。如果设置了测试选项skipAbsent它将为您执行此操作。
在最简单的情况下，测试函数根据检查是否通过返回true或false 。如果测试失败，yup 将抛出ValidationError以及该测试的（或默认）消息。 ValidationErrors 还包含有关测试的一堆其他元数据，包括它的名称、调用它的参数（如果有）以及嵌套验证情况下失败字段的路径。
还可以即时构建错误消息以自定义模式失败的方式。
let order = object ( {
no : number ( ) . required ( ) ,
sku : string ( ) . test ( {
name : 'is-sku' ,
skipAbsent : true ,
test ( value , ctx ) {
if ( ! value . startsWith ( 's-' ) ) {
return ctx . createError ( { message : 'SKU missing correct prefix' } )
}
if ( ! value . endsWith ( '-42a' ) ) {
return ctx . createError ( { message : 'SKU missing correct suffix' } )
}
if ( value . length < 10 ) {
return ctx . createError ( { message : 'SKU is not the right length' } )
}
return true
}
} )
} )
order . validate ( { no : 1234 , sku : 's-1a45-14a' } )模式是不可变的，每个方法调用都会返回一个新的模式对象。重用并传递它们，而不用担心会改变另一个实例。
let optionalString = string ( ) . optional ( ) ;
let definedString = optionalString . defined ( ) ;
let value = undefined ;
optionalString . isValid ( value ) ; // true
definedString . isValid ( value ) ; // false 是的，模式生成静态 TypeScript 接口。使用InferType提取该接口：
import * as yup from 'yup' ;
let personSchema = yup . object ( {
firstName : yup . string ( ) . defined ( ) ,
nickName : yup . string ( ) . default ( '' ) . nullable ( ) ,
sex : yup
. mixed ( )
. oneOf ( [ 'male' , 'female' , 'other' ] as const )
. defined ( ) ,
email : yup . string ( ) . nullable ( ) . email ( ) ,
birthDate : yup . date ( ) . nullable ( ) . min ( new Date ( 1900 , 0 , 1 ) ) ,
} ) ;
interface Person extends yup . InferType < typeof personSchema > {
// using interface instead of type generally gives nicer editor feedback
}当转换产生undefined输出值时，将使用模式的默认值。因此，设置默认值会影响模式的输出类型，本质上将其标记为“define()”。
import { string } from 'yup' ;
let value : string = string ( ) . default ( 'hi' ) . validate ( undefined ) ;
// vs
let value : string | undefined = string ( ) . validate ( undefined ) ;在某些情况下，TypeScript 类型已经存在，并且您希望确保您的模式生成兼容的类型：
import { object , number , string , ObjectSchema } from 'yup' ;
interface Person {
name : string ;
age ?: number ;
sex : 'male' | 'female' | 'other' | null ;
}
// will raise a compile-time type error if the schema does not produce a valid Person
let schema : ObjectSchema < Person > = object ( {
name : string ( ) . defined ( ) ,
age : number ( ) . optional ( ) ,
sex : string < 'male' | 'female' | 'other' > ( ) . nullable ( ) . defined ( ) ,
} ) ;
// errors:
// "Type 'number | undefined' is not assignable to type 'string'."
let badSchema : ObjectSchema < Person > = object ( {
name : number ( ) ,
} ) ;如果需要，您可以使用 TypeScript 的接口合并行为来扩展架构类型。类型扩展应该放在“环境”类型定义文件中，例如globals.d.ts 。请记住在您的应用程序代码中实际扩展 yup 类型！
当心！仅当类型定义完全相同（包括泛型）时，合并才有效。请查阅每种类型的 yup 源代码，以确保您正确定义它
// globals.d.ts
declare module 'yup' {
interface StringSchema < TType , TContext , TDefault , TFlags > {
append ( appendStr : string ) : this ;
}
}
// app.ts
import { addMethod , string } from 'yup' ;
addMethod ( string , 'append' , function append ( appendStr : string ) {
return this . transform ( ( value ) => ` ${ value } ${ appendStr } ` ) ;
} ) ;
string ( ) . append ( '~~~~' ) . cast ( 'hi' ) ; // 'hi~~~~'您必须启用strictNullChecks编译器选项才能使类型推断起作用。
我们还建议将strictFunctionTypes设置为false ，以获得功能更好的类型。是的，这会降低整体的可靠性，但是 TypeScript 已经禁用了对方法和构造函数的这种检查（来自 TS 文档的注释）：
在开发此功能的过程中，我们发现了大量本质上不安全的类层次结构，包括 DOM 中的一些。因此，该设置仅适用于以函数语法编写的函数，不适用于以方法语法编写的函数：
您的情况会有所不同，但我们发现此检查并不能防止许多真正的错误，同时会增加应用程序中繁重的显式类型转换的数量。
当验证测试未提供任何消息时，可以自定义默认错误消息。如果自定义字典中缺少任何消息，则错误消息将默认为 Yup 的消息。
import { setLocale } from 'yup' ;
setLocale ( {
mixed : {
default : 'Não é válido' ,
} ,
number : {
min : 'Deve ser maior que ${min}' ,
} ,
} ) ;
// now use Yup schemas AFTER you defined your custom dictionary
let schema = yup . object ( ) . shape ( {
name : yup . string ( ) ,
age : yup . number ( ) . min ( 18 ) ,
} ) ;
try {
await schema . validate ( { name : 'jimmy' , age : 11 } ) ;
} catch ( err ) {
err . name ; // => 'ValidationError'
err . errors ; // => ['Deve ser maior que 18']
}如果您需要多语言支持，yup 可以满足您的需求。函数setLocale接受可用于生成带有翻译键和值的错误对象的函数。这些可以输入到您最喜欢的 i18n 库中。
import { setLocale } from 'yup' ;
setLocale ( {
// use constant translation keys for messages without values
mixed : {
default : 'field_invalid' ,
} ,
// use functions to generate an error object that includes the value from the schema
number : {
min : ( { min } ) => ( { key : 'field_too_short' , values : { min } } ) ,
max : ( { max } ) => ( { key : 'field_too_big' , values : { max } } ) ,
} ,
} ) ;
// ...
let schema = yup . object ( ) . shape ( {
name : yup . string ( ) ,
age : yup . number ( ) . min ( 18 ) ,
} ) ;
try {
await schema . validate ( { name : 'jimmy' , age : 11 } ) ;
} catch ( err ) {
messages = err . errors . map ( ( err ) => i18next . t ( err . key ) ) ;
} yup模块导出。
// core schema
import {
mixed ,
string ,
number ,
boolean ,
bool ,
date ,
object ,
array ,
ref ,
lazy ,
} from 'yup' ;
// Classes
import {
Schema ,
MixedSchema ,
StringSchema ,
NumberSchema ,
BooleanSchema ,
DateSchema ,
ArraySchema ,
ObjectSchema ,
} from 'yup' ;
// Types
import type { InferType , ISchema , AnySchema , AnyObjectSchema } from 'yup' ; reach(schema: Schema, path: string, value?: object, context?: object): Schema对于嵌套模式， reach将根据提供的路径检索内部模式。
对于需要动态解析的嵌套模式，您可以提供一个value和一个可选的context对象。
import { reach } from 'yup' ;
let schema = object ( {
nested : object ( {
arr : array ( object ( { num : number ( ) . max ( 4 ) } ) ) ,
} ) ,
} ) ;
reach ( schema , 'nested.arr.num' ) ;
reach ( schema , 'nested.arr[].num' ) ;
reach ( schema , 'nested.arr[1].num' ) ;
reach ( schema , 'nested["arr"][1].num' ) ; addMethod(schemaType: Schema, name: string, method: ()=> Schema): void向核心模式类型添加新方法。 schemaType.prototype[name] = method的更友好便捷的方法。
import { addMethod , date } from 'yup' ;
addMethod ( date , 'format' , function format ( formats , parseStrict ) {
return this . transform ( ( value , originalValue , ctx ) => {
if ( ctx . isType ( value ) ) return value ;
value = Moment ( originalValue , formats , parseStrict ) ;
return value . isValid ( ) ? value . toDate ( ) : new Date ( '' ) ;
} ) ;
} ) ;如果要向所有模式类型添加方法，请扩展抽象基类： Schema
import { addMethod , Schema } from 'yup' ;
addMethod ( Schema , 'myMethod' , ... ) ref(path: string, options: { contextPrefix: string }): Ref创建对另一个同级或同级后代字段的引用。参考在验证/转换时解析并在指定的地方得到支持。引用按正确的顺序求值，以便在使用引用的字段之前解析引用值（注意循环依赖！）。
import { ref , object , string } from 'yup' ;
let schema = object ( {
baz : ref ( 'foo.bar' ) ,
foo : object ( {
bar : string ( ) ,
} ) ,
x : ref ( '$x' ) ,
} ) ;
schema . cast ( { foo : { bar : 'boom' } } , { context : { x : 5 } } ) ;
// => { baz: 'boom', x: 5, foo: { bar: 'boom' } } lazy((value: any) => Schema): Lazy创建一个在验证/转换时评估的模式。对于创建递归模式（如树）、多态字段和数组很有用。
警告！定义父子递归对象模式时，您需要将子对象的default()重置为null ，否则当您转换对象时，该对象将无限嵌套自身！
let node = object ( {
id : number ( ) ,
child : yup . lazy ( ( ) => node . default ( undefined ) ) ,
} ) ;
let renderable = yup . lazy ( ( value ) => {
switch ( typeof value ) {
case 'number' :
return number ( ) ;
case 'string' :
return string ( ) ;
default :
return mixed ( ) ;
}
} ) ;
let renderables = array ( ) . of ( renderable ) ; ValidationError(errors: string | Array<string>, value: any, path: string)验证失败时抛出，具有以下属性
name ：“验证错误”type ：失败的特定测试类型或测试“名称”。value : 测试的字段值；params ?: 测试输入，例如最大值、正则表达式等；path ：一个字符串，指示抛出错误的位置。根级别的path为空。errors ：错误消息数组inner ：在聚合错误的情况下，inner 是验证链中较早抛出的ValidationErrors数组。当abortEarly选项为false时，您可以在此处检查抛出的每个错误，或者， errors将包含每个内部错误的所有消息。Schema Schema是所有 schema 类型继承的抽象基类。它为所有其他模式类型提供了许多基本方法和属性。
注意：除非您要创建自定义架构类型，否则切勿直接使用架构。对于未知/任何类型，请使用
mixed()
Schema.clone(): Schema创建架构的深层副本。克隆在内部用于在每次模式状态更改时返回新模式。
Schema.label(label: string): Schema覆盖错误消息中使用的键名称。
Schema.meta(metadata: SchemaMetadata): Schema添加到元数据对象，对于使用架构存储不属于转换对象本身的数据很有用。
可以通过与CustomSchemaMetadata接口合并来定义自定义SchemaMetadata接口。首先在包中创建yup.d.ts文件并创建所需的CustomSchemaMetadata接口：
// yup.d.ts
import 'yup' ;
declare module 'yup' {
// Define your desired `SchemaMetadata` interface by merging the
// `CustomSchemaMetadata` interface.
export interface CustomSchemaMetadata {
placeholderText ?: string ;
tooltipText ?: string ;
// …
}
} Schema.describe(options?: ResolveOptions): SchemaDescription将架构详细信息（如元、标签和活动测试）收集到可序列化的描述对象中。
let schema = object ( {
name : string ( ) . required ( ) ,
} ) ;
let description = schema . describe ( ) ;对于具有动态组件（引用、惰性或条件）的模式，描述需要更多上下文才能准确返回模式描述。在这些情况下提供options
import { ref , object , string , boolean } from 'yup' ;
let schema = object ( {
isBig : boolean ( ) ,
count : number ( ) . when ( 'isBig' , {
is : true ,
then : ( schema ) => schema . min ( 5 ) ,
otherwise : ( schema ) => schema . min ( 0 ) ,
} ) ,
} ) ;
schema . describe ( { value : { isBig : true } } ) ;下面是描述类型，根据模式类型的不同，描述类型略有不同。
interface SchemaDescription {
type : string ;
label ?: string ;
meta : object | undefined ;
oneOf : unknown [ ] ;
notOneOf : unknown [ ] ;
default ?: unknown ;
nullable : boolean ;
optional : boolean ;
tests : Array < { name ?: string ; params : ExtraParams | undefined } > ;
// Present on object schema descriptions
fields : Record < string , SchemaFieldDescription > ;
// Present on array schema descriptions
innerType ?: SchemaFieldDescription ;
}
type SchemaFieldDescription =
| SchemaDescription
| SchemaRefDescription
| SchemaLazyDescription ;
interface SchemaRefDescription {
type : 'ref' ;
key : string ;
}
interface SchemaLazyDescription {
type : string ;
label ?: string ;
meta : object | undefined ;
} Schema.concat(schema: Schema): Schema通过组合两个架构来创建架构的新实例。只有相同类型的模式才能串联。 concat不是一个“合并”函数，因为提供的模式中的所有设置都会覆盖基础中的设置，包括类型、存在性和可为空性。
mixed < string > ( ) . defined ( ) . concat ( mixed < number > ( ) . nullable ( ) ) ;
// produces the equivalent to:
mixed < number > ( ) . defined ( ) . nullable ( ) ; Schema.validate(value: any, options?: object): Promise<InferType<Schema>, ValidationError>返回解析并验证输入值，返回解析的值或引发错误。此方法是异步的，并返回一个 Promise 对象，该对象由值实现，或由ValidationError拒绝。
value = await schema . validate ( { name : 'jimmy' , age : 24 } ) ;提供options来更具体地控制validate的行为。
interface Options {
// when true, parsing is skipped and the input is validated "as-is"
strict: boolean = false ;
// Throw on the first error or collect and return all
abortEarly: boolean = true ;
// Remove unspecified keys from objects
stripUnknown: boolean = false ;
// when `false` validations will be performed shallowly
recursive: boolean = true ;
// External values that can be provided to validations and conditionals
context ?: object ;
} Schema.validateSync(value: any, options?: object): InferType<Schema>如果可能，同步运行验证并返回结果值，或者抛出 ValidationError。接受与validate相同的所有选项。
仅当没有配置异步测试（例如返回 Promise 的测试）时，同步验证才有效。例如这将起作用：
let schema = number ( ) . test (
'is-42' ,
"this isn't the number i want" ,
( value ) => value != 42 ,
) ;
schema . validateSync ( 23 ) ; // throws ValidationError但这不会：
let schema = number ( ) . test ( 'is-42' , "this isn't the number i want" , ( value ) =>
Promise . resolve ( value != 42 ) ,
) ;
schema . validateSync ( 42 ) ; // throws Error Schema.validateAt(path: string, value: any, options?: object): Promise<InferType<Schema>, ValidationError>验证架构内的深层嵌套路径。与reach工作方式类似，但使用结果模式作为验证的主题。
笔记！这里的
value是相对于起始模式的根值，而不是嵌套路径处的值。
let schema = object ( {
foo : array ( ) . of (
object ( {
loose : boolean ( ) ,
bar : string ( ) . when ( 'loose' , {
is : true ,
otherwise : ( schema ) => schema . strict ( ) ,
} ) ,
} ) ,
) ,
} ) ;
let rootValue = {
foo : [ { bar : 1 } , { bar : 1 , loose : true } ] ,
} ;
await schema . validateAt ( 'foo[0].bar' , rootValue ) ; // => ValidationError: must be a string
await schema . validateAt ( 'foo[1].bar' , rootValue ) ; // => '1' Schema.validateSyncAt(path: string, value: any, options?: object): InferType<Schema>与validateAt相同但同步。
Schema.isValid(value: any, options?: object): Promise<boolean>当传入的值与架构匹配时返回true 。 isValid是异步的，返回一个 Promise 对象。
采用与validate()相同的选项。
Schema.isValidSync(value: any, options?: object): boolean当传入的值与架构匹配时，同步返回true 。
采用与validateSync()相同的选项，并且对异步测试有相同的注意事项。
Schema.cast(value: any, options = {}): InferType<Schema>尝试将传入的值强制转换为与架构匹配的值。例如：使用number()类型时， '5'将转换为5 。失败的转换通常返回null ，但也可能返回NaN和意外字符串等结果。
提供options来更具体地控制validate的行为。
interface CastOptions < TContext extends { } > {
// Remove undefined properties from objects
stripUnknown : boolean = false ;
// Throws a TypeError if casting doesn't produce a valid type
// note that the TS return type is inaccurate when this is `false`, use with caution
assert ?: boolean = true ;
// External values that used to resolve conditions and references
context ?: TContext ;
} Schema.isType(value: any): value is InferType<Schema>对传入的value运行类型检查。如果匹配则返回 true，但不会强制转换该值。当nullable()设置为 null 时null被视为该类型的有效值。您应该使用isType进行所有架构类型检查。
Schema.strict(enabled: boolean = false): Schema将strict选项设置为true 。严格模式会跳过强制和转换尝试，“按原样”验证值。
Schema.strip(enabled: boolean = true): Schema标记要从输出对象中删除的模式。仅作为嵌套架构使用。
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
schema . cast ( { notThis : 'foo' , useThis : 4 } ) ; // => { useThis: 4 }启用strip的模式具有never的推断类型，允许将它们从整体类型中删除：
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
InferType < typeof schema > ; /*
{
useThis?: number | undefined
}
*/ Schema.withMutation(builder: (current: Schema) => void): void首先是法律要求的 Rich Hickey 引言：
如果树林里有一棵树倒下，它会发出声音吗？
如果纯函数改变一些本地数据以产生不可变的返回值，可以吗？
withMutation允许您就地改变模式，而不是在每次更改之前克隆的默认行为。一般来说，这是不必要的，因为绝大多数模式更改发生在初始声明期间，并且在模式的生命周期中只发生一次，因此性能不是问题。然而，某些突变确实会在转换/验证时发生（例如使用when()的条件模式），或者在实例化模式对象时发生。
object ( )
. shape ( { key : string ( ) } )
. withMutation ( ( schema ) => {
return arrayOfObjectTests . forEach ( ( test ) => {
schema . test ( test ) ;
} ) ;
} ) ; Schema.default(value: any): Schema设置值undefined时使用的默认值。默认值是在执行转换之后、验证之前创建的，以帮助确保指定安全的默认值。每次使用时都会克隆默认值，这可能会导致对象和数组的性能损失。为了避免这种开销，您还可以传递一个返回新默认值的函数。请注意， null被视为单独的非空值。
yup . string . default ( 'nothing' ) ;
yup . object . default ( { number : 5 } ) ; // object will be cloned every time a default is needed
yup . object . default ( ( ) => ( { number : 5 } ) ) ; // this is cheaper
yup . date . default ( ( ) => new Date ( ) ) ; // also helpful for defaults that change over time Schema.getDefault(options?: object): Any检索之前设置的默认值。 getDefault将解决任何可能改变默认值的条件。可以选择传递带有context options （有关context的更多信息，请参阅Schema.validate ）。
Schema.nullable(message?: string | function): Schema指示null是架构的有效值。如果没有nullable() null会被视为不同类型，并且会导致Schema.isType()检查失败。
let schema = number ( ) . nullable ( ) ;
schema . cast ( null ) ; // null
InferType < typeof schema > ; // number | null Schema.nonNullable(message?: string | function): Schema与nullable相反，从架构的有效类型值中删除null 。默认情况下架构不可为空。
let schema = number ( ) . nonNullable ( ) ;
schema . cast ( null ) ; // TypeError
InferType < typeof schema > ; // number Schema.defined(): Schema需要架构的值。除undefined之外的所有字段值都满足此要求。
let schema = string ( ) . defined ( ) ;
schema . cast ( undefined ) ; // TypeError
InferType < typeof schema > ; // string Schema.optional(): Schema与defined()相反，允许给定类型使用undefined值。
let schema = string ( ) . optional ( ) ;
schema . cast ( undefined ) ; // undefined
InferType < typeof schema > ; // string | undefined Schema.required(message?: string | function): Schema将架构标记为必需，这将不允许使用undefined或null作为值。 required取消了调用optional()和nullable()的效果
当心！
string().required) 的工作方式略有不同，并且在需要时还可以防止空字符串值 ('')。
Schema.notRequired(): Schema将架构标记为不需要。这是schema.nullable().optional()的快捷方式；
Schema.typeError(message: string): Schema定义失败类型检查的错误消息。 ${value}和${type}插值可以在message参数中使用。
Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema别名： equals仅允许值集中的值。添加的值将从任何notOneOf值（如果存在）中删除。 ${values}插值可以在message参数中使用。如果提供了 ref 或 refs，则可以在消息参数中使用${resolved}插值来获取在验证时检查的解析值。
请注意，即使arrayOfValues中不包含undefined ， undefined也不会导致该验证器失败。如果您不希望undefined成为有效值，可以使用Schema.required 。
let schema = yup . mixed ( ) . oneOf ( [ 'jimmy' , 42 ] ) ;
await schema . isValid ( 42 ) ; // => true
await schema . isValid ( 'jimmy' ) ; // => true
await schema . isValid ( new Date ( ) ) ; // => false Schema.notOneOf(arrayOfValues: Array<any>, message?: string | function)禁止使用一组值中的值。添加的值将从oneOf值（如果存在）中删除。 ${values}插值可以在message参数中使用。如果提供了 ref 或 refs，则可以在消息参数中使用${resolved}插值来获取在验证时检查的解析值。
let schema = yup . mixed ( ) . notOneOf ( [ 'jimmy' , 42 ] ) ;
await schema . isValid ( 42 ) ; // => false
await schema . isValid ( new Date ( ) ) ; // => true Schema.when(keys: string | string[], builder: object | (values: any[], schema) => Schema): Schema根据同级或同级子字段调整架构。您可以提供一个对象文字，其中键is值或匹配器函数， then提供真实模式和/或otherwise提供失败条件。
is条件是严格比较的 ( === ) 如果您想使用不同形式的相等，您可以提供如下函数： is: (value) => value == true 。
您还可以在属性前添加$前缀，以指定依赖于validate()或cast而不是输入值传入的context的属性。
when条件相加时。
then和otherwise是指定的函数(schema: Schema) => Schema 。
let schema = object ( {
isBig : boolean ( ) ,
count : number ( )
. when ( 'isBig' , {
is : true , // alternatively: (val) => val == true
then : ( schema ) => schema . min ( 5 ) ,
otherwise : ( schema ) => schema . min ( 0 ) ,
} )
. when ( '$other' , ( [ other ] , schema ) =>
other === 4 ? schema . max ( 6 ) : schema ,
) ,
} ) ;
await schema . validate ( value , { context : { other : 4 } } ) ;您还可以指定多个从属键，在这种情况下，每个值都将作为参数传播。
let schema = object ( {
isSpecial : boolean ( ) ,
isBig : boolean ( ) ,
count : number ( ) . when ( [ 'isBig' , 'isSpecial' ] , {
is : true , // alternatively: (isBig, isSpecial) => isBig && isSpecial
then : ( schema ) => schema . min ( 5 ) ,
otherwise : ( schema ) => schema . min ( 0 ) ,
} ) ,
} ) ;
await schema . validate ( {
isBig : true ,
isSpecial : true ,
count : 10 ,
} ) ;或者，您可以提供一个返回模式的函数，使用当前模式的每个提供的键的值数组进行调用。
let schema = yup . object ( {
isBig : yup . boolean ( ) ,
count : yup . number ( ) . when ( 'isBig' , ( [ isBig ] , schema ) => {
return isBig ? schema . min ( 5 ) : schema . min ( 0 ) ;
} ) ,
} ) ;
await schema . validate ( { isBig : false , count : 4 } ) ; Schema.test(name: string, message: string | function | any, test: function): Schema向验证链添加测试函数。测试在任何对象被转换后运行。许多类型都内置了一些测试，但您可以轻松创建自定义测试。为了允许异步自定义验证，所有（或没有）测试都异步运行。这样做的后果是无法保证测试执行顺序。
所有测试都必须提供name 、错误message和验证函数，当当前value有效时必须返回true ，否则返回false或ValidationError 。要使测试异步返回一个解析true或false的 Promise 或ValidationError 。
对于message参数，您可以提供一个字符串，如果使用${param}语法指定，该字符串将插入某些值。默认情况下，所有测试消息都会传递一个path值，该路径值在嵌套模式中很有价值。
使用当前value调用test函数。对于更高级的验证，您可以使用备用签名来提供更多选项（见下文）：
let jimmySchema = string ( ) . test (
'is-jimmy' ,
'${path} is not Jimmy' ,
( value , context ) => value === 'jimmy' ,
) ;
// or make it async by returning a promise
let asyncJimmySchema = string ( )
. label ( 'First name' )
. test (
'is-jimmy' ,
( { label } ) => ` ${ label } is not Jimmy` , // a message can also be a function
async ( value , testContext ) =>
( await fetch ( '/is-jimmy/' + value ) ) . responseText === 'true' ,
) ;
await schema . isValid ( 'jimmy' ) ; // => true
await schema . isValid ( 'john' ) ; // => false使用特殊的上下文值（作为第二个参数）调用测试函数，该值公开一些有用的元数据和函数。对于非箭头函数，测试上下文也设置为函数this 。请注意，如果您通过this访问它，它将无法在箭头函数中工作。
testContext.path : 当前验证的字符串路径testContext.schema ：测试运行所针对的已解析架构对象。testContext.options ：调用 validate() 或 isValid() 的options对象testContext.parent ：在嵌套模式的情况下，这是父对象的值testContext.originalValue ：正在测试的原始值testContext.createError(Object: { path: String, message: String, params: Object }) ：创建并返回验证错误。对于动态设置path 、 params或更可能是错误message很有用。如果省略任一选项，它将使用当前路径或默认消息。 Schema.test(options: object): Schema替代test(..)签名。 options是一个包含以下一些选项的对象：
Options = {
// unique name identifying the test
name : string ;
// test function, determines schema validity
test: ( value : any ) => boolean ;
// the validation error message
message: string ;
// values passed to message for interpolation
params: ? object ;
// mark the test as exclusive, meaning only one test of the same name can be active at once
exclusive: boolean = false ;
}在混合排他和非排他测试的情况下，使用以下逻辑。如果将非独占测试添加到具有同名独占测试的架构中，则独占测试将被删除，并且将堆叠更多同名测试。
如果将独占测试添加到具有同名非独占测试的架构中，则先前的测试将被删除，并且更多的同名测试将相互替换。
let max = 64 ;
let schema = yup . string ( ) . test ( {
name : 'max' ,
exclusive : true ,
params : { max } ,
message : '${path} must be less than ${max} characters' ,
test : ( value ) => value == null || value . length <= max ,
} ) ; Schema.transform((currentValue: any, originalValue: any) => any): Schema向变换链添加变换。转换是转换过程的核心，每种类型的默认转换将值强制为特定类型（由isType()验证）。转换在验证之前运行，并且仅在架构未标记为strict （默认）时应用。有些类型具有内置的转换。
转换对于任意改变对象的转换方式很有用，但是，您应该注意不要改变传入的值。转换按顺序运行，因此每个value代表转换的当前状态，如果需要处理原始初始值，可以使用originalValue参数。
let schema = string ( ) . transform ( ( value , originalValue ) => {
return this . isType ( value ) && value !== null ? value . toUpperCase ( ) : value ;
} ) ;
schema . cast ( 'jimmy' ) ; // => 'JIMMY'每种类型都会为您处理基本的值强制转换为正确的类型，但有时您可能需要调整或细化默认行为。例如，如果您想使用与默认策略不同的日期解析策略，您可以通过转换来实现。
module . exports = function ( formats = 'MMM dd, yyyy' ) {
return date ( ) . transform ( ( value , originalValue , context ) => {
// check to see if the previous transform already parsed the date
if ( context . isType ( value ) ) return value ;
// the default coercion failed so let's try it with Moment.js instead
value = Moment ( originalValue , formats ) ;
// if it's valid return the date object, otherwise return an `InvalidDate`
return value . isValid ( ) ? value . toDate ( ) : new Date ( '' ) ;
} ) ;
} ;创建匹配所有类型或仅匹配您配置的类型的架构。继承自Schema 。混合类型默认扩展{}而不是any或unknown 。这是因为在 TypeScript 中， {}表示任何不为null或undefined的内容，yup 会明确处理这些内容。
import { mixed , InferType } from 'yup' ;
let schema = mixed ( ) . nullable ( ) ;
schema . validateSync ( 'string' ) ; // 'string';
schema . validateSync ( 1 ) ; // 1;
schema . validateSync ( new Date ( ) ) ; // Date;
InferType < typeof schema > ; // {} | undefined
InferType < typeof schema . nullable ( ) . defined ( ) > ; // {} | null自定义类型可以通过传递类型check函数来实现。这也将缩小架构的 TypeScript 类型。
import { mixed , InferType } from 'yup' ;
let objectIdSchema = yup
. mixed ( ( input ) : input is ObjectId => input instanceof ObjectId )
. transform ( ( value : any , input , ctx ) => {
if ( ctx . isType ( value ) ) return value ;
return new ObjectId ( value ) ;
} ) ;
await objectIdSchema . validate ( ObjectId ( '507f1f77bcf86cd799439011' ) ) ; // ObjectId("507f1f77bcf86cd799439011")
await objectIdSchema . validate ( '507f1f77bcf86cd799439011' ) ; // ObjectId("507f1f77bcf86cd799439011")
InferType < typeof objectIdSchema > ; // ObjectId定义字符串模式。继承自Schema 。
let schema = yup . string ( ) ;
await schema . isValid ( 'hello' ) ; // => true默认情况下， string的cast逻辑是对值（如果存在）调用toString 。
空值不会被强制（使用ensure()将空值强制为空字符串）。
失败的转换返回输入值。
string.required(message?: string | function): Schema与所需的mixed()模式相同，只是空字符串也被视为“缺失”值。
string.length(limit: number | Ref, message?: string | function): Schema设置字符串值所需的长度。 ${length}插值可以在message参数中使用
string.min(limit: number | Ref, message?: string | function): Schema设置字符串值的最小长度限制。 ${min}插值可以在message参数中使用
string.max(limit: number | Ref, message?: string | function): Schema设置字符串值的最大长度限制。 ${max}插值可以在message参数中使用
string.matches(regex: Regex, message?: string | function): Schema提供任意regex来匹配值。
let schema = string ( ) . matches ( / (hi|bye) / ) ;
await schema . isValid ( 'hi' ) ; // => true
await schema . isValid ( 'nope' ) ; // => false string.matches(regex: Regex, options: { message: string, excludeEmptyString: bool }): Schema string.matches与选项对象的替代签名。 excludeEmptyString如果为 true，则当值为空字符串时会短路正则表达式测试，从而更容易避免不匹配任何内容，而不会使正则表达式复杂化。
let schema = string ( ) . matches ( / (hi|bye) / , { excludeEmptyString : true } ) ;
await schema . isValid ( '' ) ; // => true string.email(message?: string | function): Schema使用 HTML 规范定义的相同正则表达式将值验证为电子邮件地址。
注意：仅使用代码验证电子邮件地址几乎是不可能的。不同的客户端和服务器接受不同的内容，并且许多与定义“有效”电子邮件的各种规范不同。验证电子邮件地址的唯一真正方法是向其发送验证电子邮件并检查用户是否收到它。考虑到这一点，yup 选择了一个相对简单的正则表达式，它并不涵盖所有情况，但与浏览器输入验证行为保持一致，因为 HTML 表单是 yup 的常见用例。
如果您有更具体的需求，请使用您自己的逻辑或正则表达式覆盖电子邮件方法：
yup . addMethod ( yup . string , 'email' , function validateEmail ( message ) {
return this . matches ( myEmailRegex , {
message ,
name : 'email' ,
excludeEmptyString : true ,
} ) ;
} ) ; string.url(message?: string | function): Schema通过正则表达式验证该值是否为有效 URL。
string.uuid(message?: string | function): Schema通过正则表达式验证该值是否为有效的 UUID。
string.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number})通过正则表达式将值验证为 ISO 日期时间。默认为 UTC 验证；不允许时区偏移（请参阅options.allowOffset ）。
与.date()不同， datetime不会将字符串转换为Date对象。与date相比， datetime还对日期时间字符串所需的格式提供了更好的自定义。
options.allowOffset ：允许时区偏移。 False 需要 UTC“Z”时区。 （默认值： false） options.precision precision ：要求日期具有一定的亚秒精度。 （默认值：null——任何（或没有）亚秒精度）
string.datetime(message?: string | function)当您不需要传递除message之外的选项时，可以使用string.datetime的替代签名。
string.ensure(): Schema将undefined值和null值转换为空字符串，并将default值设置为空字符串。
string.trim(message?: string | function): Schema通过删除前导和尾随空格来转换字符串值。如果设置了strict()它将仅验证该值是否被修剪。
string.lowercase(message?: string | function): Schema将字符串值转换为小写。如果设置了strict()它将仅验证该值是否为小写。
string.uppercase(message?: string | function): Schema将字符串值转换为大写。如果设置了strict()它将仅验证该值是否为大写。
定义数字模式。继承自Schema 。
let schema = yup . number ( ) ;
await schema . isValid ( 10 ) ; // => true number默认的cast逻辑是： parseFloat 。
失败的转换返回NaN 。
number.min(limit: number | Ref, message?: string | function): Schema设置允许的最小值。 ${min}插值可以在message参数中使用。
number.max(limit: number | Ref, message?: string | function): Schema设置允许的最大值。 ${max}插值可以在message参数中使用。
number.lessThan(max: number | Ref, message?: string | function): Schema值必须小于max 。 ${less}插值可以用在message参数中。
number.moreThan(min: number | Ref, message?: string | function): Schema值必须严格大于min 。 ${more}插值可以用在message参数中。
number.positive(message?: string | function): Schema值必须是正数。
number.negative(message?: string | function): Schema值必须是负数。
number.integer(message?: string | function): Schema验证数字是否为整数。
number.truncate(): Schema通过去除小数点右侧的数字将值强制为整数的转换。
number.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schema通过指定的Math方法调整值（默认为“round”）。
定义布尔模式。继承自Schema 。
let schema = yup . boolean ( ) ;
await schema . isValid ( true ) ; // => true定义日期模式。默认情况下，ISO 日期字符串将正确解析，有关更强大的解析选项，请参阅自述文件末尾的扩展模式类型。继承自Schema 。
let schema = yup . date ( ) ;
await schema . isValid ( new Date ( ) ) ; // => true date的默认cast逻辑是将值传递给Date构造函数，如果失败，它将尝试将日期解析为 ISO 日期字符串。
如果您不希望 ISO 字符串转换为
Date对象，请改用.datetime()。
失败的转换返回无效的日期。
date.min(limit: Date | string | Ref, message?: string | function): Schema设置允许的最短日期。当提供字符串时，它将首先尝试转换为日期并使用结果作为限制。
date.max(limit: Date | string | Ref, message?: string | function): Schema设置允许的最大日期，当提供字符串时，它将首先尝试转换为日期并使用结果作为限制。
定义数组模式。数组可以是类型化的，也可以是非类型化的，当指定元素类型时， cast和isValid也将应用于元素。传递到isValid的选项也会传递到子模式。
继承自Schema 。
let schema = yup . array ( ) . of ( yup . number ( ) . min ( 2 ) ) ;
await schema . isValid ( [ 2 , 3 ] ) ; // => true
await schema . isValid ( [ 1 , - 24 ] ) ; // => false
schema . cast ( [ '2' , '3' ] ) ; // => [2, 3]为了方便起见，您还可以将子类型模式传递给数组构造函数。
array ( ) . of ( yup . number ( ) ) ;
// or
array ( yup . number ( ) ) ;数组没有默认的转换行为。
array.of(type: Schema): this指定数组元素的架构。 of()是可选的，当省略时，数组模式将不会验证其内容。
array.json(): this尝试使用JSON.parse将输入字符串值解析为 JSON。
array.length(length: number | Ref, message?: string | function): this为数组设置特定的长度要求。 ${length}插值可以用在message参数中。
array.min(limit: number | Ref, message?: string | function): this设置数组的最小长度限制。 ${min}插值可以在message参数中使用。
array.max(limit: number | Ref, message?: string | function): this设置数组的最大长度限制。 ${max}插值可以在message参数中使用。
array.ensure(): this通过将默认值设置为[]并将null和undefined值也转换为空数组，确保该值是一个数组。任何非空、非数组值都将包装在数组中。
array ( ) . ensure ( ) . cast ( null ) ; // => []
array ( ) . ensure ( ) . cast ( 1 ) ; // => [1]
array ( ) . ensure ( ) . cast ( [ 1 ] ) ; // => [1] array.compact(rejector: (value) => boolean): Schema从数组中删除错误值。提供拒绝者功能可以让您自己指定拒绝标准。
array ( ) . compact ( ) . cast ( [ '' , 1 , 0 , 4 , false , null ] ) ; // => [1, 4]
array ( )
. compact ( function ( v ) {
return v == null ;
} )
. cast ( [ '' , 1 , 0 , 4 , false , null ] ) ; // => ['', 1, 0, 4, false]元组是固定长度的数组，其中每个项目都有不同的类型。
继承自Schema 。
import { tuple , string , number , InferType } from 'yup' ;
let schema = tuple ( [
string ( ) . label ( 'name' ) ,
number ( ) . label ( 'age' ) . positive ( ) . integer ( ) ,
] ) ;
await schema . validate ( [ 'James' , 3 ] ) ; // ['James', 3]
await schema . validate ( [ 'James' , - 24 ] ) ; // => ValidationError: age must be a positive number
InferType < typeof schema > // [string, number] | undefined元组没有默认的转换行为。
定义对象模式。传递到isValid的选项也会传递到子模式。继承自Schema 。
yup . object ( {
name : string ( ) . required ( ) ,
age : number ( ) . required ( ) . positive ( ) . integer ( ) ,
email : string ( ) . email ( ) ,
website : string ( ) . url ( ) ,
} ) ;对象模式没有应用任何默认转换。
对象模式已经设置了默认值，它“构建”了对象形状，并设置了字段的任何默认值：
let schema = object ( {
name : string ( ) . default ( '' ) ,
} ) ;
schema . default ( ) ; // -> { name: '' }这可能有点令人惊讶，但通常很有用，因为它允许大型嵌套模式创建填充整个形状而不仅仅是根对象的默认值。有一个问题！尽管。对于可选但包含非可选字段的嵌套对象模式可能会以意外的方式失败：
let schema = object ( {
id : string ( ) . required ( ) ,
names : object ( {
first : string ( ) . required ( ) ,
} ) ,
} ) ;
schema . isValid ( { id : 1 } ) ; // false! names.first is required这是因为 yup 在运行验证之前强制转换输入对象，这将产生：
{ id: '1', names: { first: undefined }}
在验证阶段， names存在并经过验证，发现names.first首先丢失。如果您希望避免这种行为，请执行以下操作之一：
names.default(undefined)names.nullable().default(null) object.shape(fields: object, noSortEdges?: Array<[string, string]>): Schema定义对象的键和所述键的模式。
请注意，您可以链接shape方法，其作用类似于Object.assign 。
object ( {
a : string ( ) ,
b : number ( ) ,
} ) . shape ( {
b : string ( ) ,
c : number ( ) ,
} ) ;将与以下完全相同：
object ( {
a : string ( ) ,
b : string ( ) ,
c : number ( ) ,
} ) ; object.json(): this尝试使用JSON.parse将输入字符串值解析为 JSON。
object.concat(schemaB: ObjectSchema): ObjectSchema通过将schemaB中的所有设置和字段应用到基础架构来创建对象架构，从而生成新架构。对象形状与schemaB中的公共字段浅层合并，优先于基本字段。
object.pick(keys: string[]): Schema从原始字段的子集创建新架构。
let person = object ( {
age : number ( ) . default ( 30 ) . required ( ) ,
name : string ( ) . default ( 'pat' ) . required ( ) ,
color : string ( ) . default ( 'red' ) . required ( ) ,
} ) ;
let nameAndAge = person . pick ( [ 'name' , 'age' ] ) ;
nameAndAge . getDefault ( ) ; // => { age: 30, name: 'pat'} object.omit(keys: string[]): Schema创建一个省略字段的新架构。
let person = object ( {
age : number ( ) . default ( 30 ) . required ( ) ,
name : string ( ) . default ( 'pat' ) . required ( ) ,
color : string ( ) . default ( 'red' ) . required ( ) ,
} ) ;
let nameAndAge = person . omit ( [ 'color' ] ) ;
nameAndAge . getDefault ( ) ; // => { age: 30, name: 'pat'} object.from(fromKey: string, toKey: string, alias: boolean = false): this将指定密钥转换为新密钥。如果alias为true则旧密钥将被保留。
let schema = object ( {
myProp : mixed ( ) ,
Other : mixed ( ) ,
} )
. from ( 'prop' , 'myProp' )
. from ( 'other' , 'Other' , true ) ;
schema . cast ( { prop : 5 , other : 6 } ) ; // => { myProp: 5, other: 6, Other: 6 } object.noUnknown(onlyKnownKeys: boolean = true, message?: string | function): Schema验证对象值仅包含shape中指定的键，传递false作为第一个参数以禁用检查。当不处于严格模式时，将密钥限制为已知，还会启用stripUnknown选项。
object.camelCase(): Schema将所有对象键转换为驼峰命名法
object.constantCase(): Schema将所有对象键转换为 CONSTANT_CASE。
