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。
