yup

ใช่

Yup เป็นตัวสร้างสคีมาสำหรับการแยกวิเคราะห์และตรวจสอบค่ารันไทม์ กำหนดสคีมา แปลงค่าให้ตรงกัน ยืนยันรูปร่างของค่าที่มีอยู่ หรือทั้งสองอย่าง ใช่สคีมาแสดงออกได้อย่างมากและอนุญาตให้สร้างแบบจำลองที่ซับซ้อน การตรวจสอบความถูกต้องที่พึ่งพาอาศัยกัน หรือการแปลงค่า

คุณกำลังดูเอกสารสำหรับ v1.0.0 ของ yup มีเอกสารก่อน v1 ให้ใช้งาน: ที่นี่

คุณสมบัตินักฆ่า :

• อินเทอร์เฟซสคีมาที่กระชับแต่แสดงออกได้ชัดเจน ซึ่งติดตั้งไว้สำหรับสร้างโมเดลข้อมูลแบบง่ายไปจนถึงโมเดลข้อมูลที่ซับซ้อน
• การสนับสนุน TypeScript ที่มีประสิทธิภาพ สรุปประเภทคงที่จากสคีมา หรือตรวจสอบให้แน่ใจว่าสคีมาใช้ประเภทอย่างถูกต้อง
• รองรับการตรวจสอบความถูกต้องแบบอะซิงก์ในตัว จำลองการตรวจสอบฝั่งเซิร์ฟเวอร์และฝั่งไคลเอ็นต์ได้ดีพอๆ กัน
• ขยายได้: เพิ่มวิธีการและสคีมาที่ปลอดภัยสำหรับประเภทของคุณเอง
• รายละเอียดข้อผิดพลาดมากมาย ทำให้การแก้ไขจุดบกพร่องเป็นเรื่องง่าย

เริ่มต้นใช้งาน

สคีมาประกอบด้วยการดำเนินการแยกวิเคราะห์ (การแปลง) เช่นเดียวกับการยืนยัน (การทดสอบ) เกี่ยวกับค่าอินพุต ตรวจสอบค่าอินพุตเพื่อแยกวิเคราะห์และเรียกใช้ชุดการยืนยันที่กำหนดค่าไว้ เชื่อมโยงวิธีการต่างๆ เข้าด้วยกันเพื่อสร้างสคีมา

 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 } ,
) ; 

สารบัญ

• พื้นฐานของสคีมา
  • การแยกวิเคราะห์: การแปลง
  • การตรวจสอบความถูกต้อง: การทดสอบ
    • การปรับแต่งข้อผิดพลาด
  • องค์ประกอบและการใช้ซ้ำ
• การรวม TypeScript
  • ค่าเริ่มต้นของสคีมา
  • ตรวจสอบให้แน่ใจว่าสคีมาตรงกับประเภทที่มีอยู่
  • การขยายสคีมาในตัวด้วยวิธีการใหม่
  • การกำหนดค่า TypeScript
• การปรับแต่งข้อความแสดงข้อผิดพลาด
  • การแปลเป็นภาษาท้องถิ่นและ i18n
• เอพีไอ
  • yup
    • reach(schema: Schema, path: string, value?: object, context?: object): Schema
    • addMethod(schemaType: Schema, name: string, method: ()=> Schema): void
    • ref(path: string, options: { contextPrefix: string }): Ref
    • lazy((value: any) => Schema): Lazy
    • ValidationError(errors: string | Array<string>, value: any, path: string)
  • Schema
    • Schema.clone(): Schema
    • Schema.label(label: string): Schema
    • Schema.meta(metadata: SchemaMetadata): Schema
    • Schema.describe(options?: ResolveOptions): SchemaDescription
    • Schema.concat(schema: Schema): Schema
    • Schema.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): boolean
    • Schema.cast(value: any, options = {}): InferType<Schema>
    • Schema.isType(value: any): value is InferType<Schema>
    • Schema.strict(enabled: boolean = false): Schema
    • Schema.strip(enabled: boolean = true): Schema
    • Schema.withMutation(builder: (current: Schema) => void): void
    • Schema.default(value: any): Schema
    • Schema.getDefault(options?: object): Any
    • Schema.nullable(message?: string | function): Schema
    • Schema.nonNullable(message?: string | function): Schema
    • Schema.defined(): Schema
    • Schema.optional(): Schema
    • Schema.required(message?: string | function): Schema
    • Schema.notRequired(): Schema
    • Schema.typeError(message: string): Schema
    • Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema Alias: equals
    • Schema.notOneOf(arrayOfValues: Array<any>, message?: string | function)
    • Schema.when(keys: string | string[], builder: object | (values: any[], schema) => Schema): Schema
    • Schema.test(name: string, message: string | function | any, test: function): Schema
    • Schema.test(options: object): Schema
    • Schema.transform((currentValue: any, originalValue: any) => any): Schema
  • ผสม
  • เชือก
    • string.required(message?: string | function): Schema
    • string.length(limit: number | Ref, message?: string | function): Schema
    • string.min(limit: number | Ref, message?: string | function): Schema
    • string.max(limit: number | Ref, message?: string | function): Schema
    • string.matches(regex: Regex, message?: string | function): Schema
    • string.matches(regex: Regex, options: { message: string, excludeEmptyString: bool }): Schema
    • string.email(message?: string | function): Schema
    • string.url(message?: string | function): Schema
    • string.uuid(message?: string | function): Schema
    • string.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number})
    • string.datetime(message?: string | function)
    • string.ensure(): Schema
    • string.trim(message?: string | function): Schema
    • string.lowercase(message?: string | function): Schema
    • string.uppercase(message?: string | function): Schema
  • ตัวเลข
    • number.min(limit: number | Ref, message?: string | function): Schema
    • number.max(limit: number | Ref, message?: string | function): Schema
    • number.lessThan(max: number | Ref, message?: string | function): Schema
    • number.moreThan(min: number | Ref, message?: string | function): Schema
    • 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
  • บูลีน
  • วันที่
    • date.min(limit: Date | string | Ref, message?: string | function): Schema
    • date.max(limit: Date | string | Ref, message?: string | function): Schema
  • อาร์เรย์
    • array.of(type: Schema): this
    • array.json(): this
    • array.length(length: number | Ref, message?: string | function): this
    • array.min(limit: number | Ref, message?: string | function): this
    • array.max(limit: number | Ref, message?: string | function): this
    • array.ensure(): this
    • array.compact(rejector: (value) => boolean): Schema
  • สิ่งอันดับ
  • วัตถุ
    • ค่าเริ่มต้นของสคีมาออบเจ็กต์
    • object.shape(fields: object, noSortEdges?: Array<[string, string]>): Schema
    • object.json(): this
    • object.concat(schemaB: ObjectSchema): ObjectSchema
    • object.pick(keys: string[]): Schema
    • object.omit(keys: string[]): Schema
    • object.from(fromKey: string, toKey: string, alias: boolean = false): this
    • object.noUnknown(onlyKnownKeys: boolean = true, message?: string | function): Schema
    • object.camelCase(): Schema
    • object.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

ใช่สคีมาสร้างอินเทอร์เฟซ 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 ด้วยเหตุนี้ การตั้งค่าเริ่มต้นจึงส่งผลต่อประเภทเอาต์พุตของสคีมา โดยพื้นฐานแล้วจะทำเครื่องหมายเป็น "กำหนด ()"

 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~~~~'

การกำหนดค่า TypeScript

คุณ ต้อง เปิดใช้งานตัวเลือกคอมไพเลอร์ 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']
}

การแปลเป็นภาษาท้องถิ่นและ i18n

หากคุณต้องการการสนับสนุนหลายภาษา คุณก็พร้อมแล้ว ฟังก์ชัน 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

สร้างสคีมาที่ได้รับการประเมิน ณ เวลาตรวจสอบ/ส่ง มีประโยชน์สำหรับการสร้างสคีมาแบบเรียกซ้ำเช่น Trees สำหรับฟิลด์และอาร์เรย์แบบ polymorphic

คำเตือน! เมื่อกำหนดสคีมาอ็อบเจ็กต์แบบเรียกซ้ำพาเรนต์และลูก คุณต้องรีเซ็ตค่า 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 ?: อินพุตทดสอบ เช่น ค่าสูงสุด regex ฯลฯ
• path : สตริงที่ระบุว่ามีข้อผิดพลาดเกิดขึ้นที่ไหน path ว่างเปล่าที่ระดับรูท
• errors : อาร์เรย์ของข้อความแสดงข้อผิดพลาด
• inner : ในกรณีที่เกิดข้อผิดพลาดโดยรวม Inner คืออาร์เรย์ของ ValidationErrors ที่เกิดขึ้นก่อนหน้านี้ในห่วงโซ่การตรวจสอบ เมื่อตัวเลือก abortEarly เป็น false คุณจะสามารถตรวจสอบแต่ละข้อผิดพลาดที่เกิดขึ้นได้ หรือ errors จะมีข้อความทั้งหมดจากข้อผิดพลาดภายในแต่ละข้อ

Schema

Schema เป็นคลาสฐานนามธรรมที่ประเภทสคีมาทั้งหมดสืบทอดมา โดยจัดเตรียมวิธีการพื้นฐานและคุณสมบัติจำนวนหนึ่งให้กับประเภทสคีมาอื่นๆ ทั้งหมด

หมายเหตุ: เว้นแต่ว่าคุณกำลังสร้างประเภทสคีมาที่กำหนดเอง ไม่ควรใช้สคีมาโดยตรง ไม่ทราบ/ประเภทใดๆ ให้ใช้ mixed()

Schema.clone(): Schema

สร้างสำเนาแบบลึกของสคีมา โคลนถูกใช้ภายในเพื่อส่งคืนสคีมาใหม่ทุกครั้งที่มีการเปลี่ยนแปลงสถานะของสคีมา

Schema.label(label: string): Schema

แทนที่ชื่อคีย์ที่ใช้ในข้อความแสดงข้อผิดพลาด

Schema.meta(metadata: SchemaMetadata): Schema

เพิ่มไปยังออบเจ็กต์ข้อมูลเมตาซึ่งมีประโยชน์สำหรับการจัดเก็บข้อมูลด้วยสคีมาซึ่งไม่ได้เป็นของออบเจ็กต์การส่งเอง

อินเทอร์เฟซ SchemaMetadata แบบกำหนดเองสามารถกำหนดได้ผ่านการผสานเข้ากับอินเทอร์เฟซ CustomSchemaMetadata เริ่มต้นด้วยการสร้างไฟล์ 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>

พยายามที่จะบังคับค่าที่ส่งผ่านให้เป็นค่าที่ตรงกับสคีมา ตัวอย่างเช่น: '5' จะแปลงเป็น 5 เมื่อใช้ประเภท number() โดยทั่วไปการแคสต์ที่ล้มเหลวจะส่งคืน 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 ที่ส่งผ่าน หากตรงกัน จะส่งกลับค่าจริง แต่จะไม่แปลงค่า เมื่อตั้งค่า nullable() ให้เป็น null จะถือเป็นค่าที่ถูกต้องของประเภทนั้น คุณควรใช้ isType สำหรับการตรวจสอบประเภท Schema ทั้งหมด

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 ที่จำเป็นตามกฎหมาย:

ต้นไม้ล้มในป่ามีเสียงไหม?

หากฟังก์ชัน pure กลายพันธุ์ข้อมูลในเครื่องบางส่วนเพื่อสร้างค่าส่งคืนที่ไม่เปลี่ยนรูป ไม่เป็นไรใช่ไหม

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 จะแก้ไขเงื่อนไขใด ๆ ที่อาจเปลี่ยนแปลงค่าเริ่มต้น เลือกที่จะส่ง options ที่มี context (สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ 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 Alias: equals

อนุญาตเฉพาะค่าจากชุดค่าเท่านั้น ค่าที่เพิ่มจะถูกลบออกจากค่า notOneOf ใด ๆ หากมีอยู่ การแก้ไข ${values} สามารถใช้ในอาร์กิวเมนต์ message ได้ หากมีการระบุการอ้างอิงหรือการอ้างอิง การ ${resolved} สามารถใช้ในอาร์กิวเมนต์ข้อความเพื่อรับค่าที่แก้ไขแล้วที่ได้รับการตรวจสอบ ณ เวลาตรวจสอบ

โปรดทราบ undefined ทำให้เครื่องมือตรวจสอบนี้ล้มเหลว แม้ว่าไม่ undefined กำหนดไว้ใน arrayOfValues ​​ก็ตาม หากคุณไม่ต้องการให้ 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 ได้ หากมีการระบุการอ้างอิงหรือการอ้างอิง การ ${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

คุณยังสามารถใส่คำนำหน้าคุณสมบัติด้วย $ เพื่อระบุคุณสมบัติที่ขึ้นอยู่กับ context ที่ส่งเข้ามาโดย validate() หรือ cast แทนค่าอินพุต

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 ข้อผิดพลาด และฟังก์ชันการตรวจสอบความถูกต้องที่จะต้องคืนค่า true เมื่อ value ปัจจุบันถูกต้องและ false หรือ ValidationError มิฉะนั้น หากต้องการให้การทดสอบอะซิงก์ส่งคืนสัญญาที่แก้ไข true หรือ false หรือ ValidationError

สำหรับอาร์กิวเมนต์ message คุณสามารถระบุสตริงซึ่งจะประมาณค่าบางค่าหากระบุโดยใช้ไวยากรณ์ ${param} ตามค่าเริ่มต้น ข้อความทดสอบทั้งหมดจะถูกส่งผ่านค่า path ซึ่งมีค่าในสคีมาที่ซ้อนกัน

ฟังก์ชัน test ถูกเรียกด้วย value ปัจจุบัน สำหรับการตรวจสอบขั้นสูงเพิ่มเติม คุณสามารถใช้ลายเซ็นสำรองเพื่อให้ตัวเลือกเพิ่มเติม (ดูด้านล่าง):

 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 : ออบเจ็กต์ options ที่ตรวจสอบ () หรือ isValid() ถูกเรียกด้วย
• 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

ตามค่าเริ่มต้น ลอจิก cast ของ string คือการเรียก 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 เมื่อเป็นจริง ให้ลัดวงจรการทดสอบ regex เมื่อค่าเป็นสตริงว่าง ทำให้ง่ายต่อการหลีกเลี่ยงการจับคู่สิ่งใดเลยโดยไม่ทำให้ regex ซับซ้อน

 let schema = string ( ) . matches ( / (hi|bye) / , { excludeEmptyString : true } ) ;

await schema . isValid ( '' ) ; // => true 

string.email(message?: string | function): Schema

ตรวจสอบค่าเป็นที่อยู่อีเมลโดยใช้ regex เดียวกันกับที่กำหนดโดยข้อกำหนด HTML

ระวัง: การตรวจสอบความถูกต้องของที่อยู่อีเมลแทบจะเป็นไปไม่ได้เลยเพียงแค่ใช้รหัส ไคลเอนต์และเซิร์ฟเวอร์ที่แตกต่างกันยอมรับสิ่งต่าง ๆ และหลายอย่างแตกต่างจากข้อกำหนดต่าง ๆ ที่กำหนดอีเมลที่ "ถูกต้อง" วิธีเดียวที่แท้จริงในการตรวจสอบที่อยู่อีเมลคือการส่งอีเมลยืนยันไปยังที่อยู่อีเมลนั้นและตรวจสอบว่าผู้ใช้ได้รับที่อยู่อีเมลแล้ว ด้วยเหตุนี้ yup จึงเลือก regex ที่ค่อนข้างง่ายซึ่งไม่ครอบคลุมทุกกรณี แต่สอดคล้องกับพฤติกรรมการตรวจสอบอินพุตของเบราว์เซอร์ เนื่องจากรูปแบบ HTML เป็นกรณีการใช้งานทั่วไปสำหรับ yup

หากคุณมีความต้องการเฉพาะเจาะจงมากขึ้น โปรดแทนที่วิธีอีเมลด้วยตรรกะหรือ regex ของคุณเอง:

 yup . addMethod ( yup . string , 'email' , function validateEmail ( message ) {
  return this . matches ( myEmailRegex , {
    message ,
    name : 'email' ,
    excludeEmptyString : true ,
  } ) ;
} ) ; 

string.url(message?: string | function): Schema

ตรวจสอบค่าเป็น URL ที่ถูกต้องผ่านทาง regex

string.uuid(message?: string | function): Schema

ตรวจสอบค่าเป็น UUID ที่ถูกต้องผ่าน regex

string.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number})

ตรวจสอบค่าเป็นวันที่และเวลา ISO ผ่าน regex ค่าเริ่มต้นเป็นการตรวจสอบ UTC ไม่อนุญาตให้ใช้การชดเชยเขตเวลา (ดู options.allowOffset )

ไม่เหมือนกับ .date() datetime จะไม่แปลงสตริงเป็นวัตถุ Date datetime ยังให้การปรับแต่งที่ดีกว่ารูปแบบที่ต้องการของสตริง datetime มากกว่า date ที่

options.allowOffset : อนุญาตการชดเชยโซนเวลา False ต้องใช้เขตเวลา UTC 'Z' (ค่าเริ่มต้น: false) options.precision : ต้องมีความแม่นยำรองวินาทีในวันที่ (ค่าเริ่มต้น: null -- ความแม่นยำย่อยวินาทีใด ๆ (หรือไม่มี))

string.datetime(message?: string | function)

ลายเซ็นสำรองสำหรับ string.datetime ที่สามารถใช้ได้เมื่อคุณไม่จำเป็นต้องส่งตัวเลือกอื่นนอกเหนือจาก message

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

ตรรกะ cast เริ่มต้นของ number คือ: 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 ที่ระบุ (ค่าเริ่มต้นคือ 'ปัดเศษ')

บูลีน

กำหนดสคีมาบูลีน สืบทอดมาจาก Schema

 let schema = yup . boolean ( ) ;

await schema . isValid ( true ) ; // => true

วันที่

กำหนดสคีมาวันที่ ตามค่าเริ่มต้น สตริงวันที่ ISO จะแยกวิเคราะห์อย่างถูกต้อง สำหรับตัวเลือกการแยกวิเคราะห์ที่มีประสิทธิภาพมากขึ้น โปรดดูประเภทสคีมาแบบขยายที่ส่วนท้ายของ readme สืบทอดมาจาก Schema

 let schema = yup . date ( ) ;

await schema . isValid ( new Date ( ) ) ; // => true

ตรรกะ cast เริ่มต้นของ date จะถูกส่งผ่านค่าไปยังตัวสร้าง 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 โดยใช้ JSON.parse

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 ( ) ,
} ) ;

สคีมาวัตถุไม่มีการแปลงเริ่มต้นใดๆ

ค่าเริ่มต้นของสคีมาออบเจ็กต์

สคีมาของวัตถุมาพร้อมกับค่าเริ่มต้นที่ตั้งไว้แล้ว ซึ่ง "สร้าง" รูปร่างของวัตถุ a ตั้งค่าเริ่มต้นสำหรับฟิลด์:

 let schema = object ( {
  name : string ( ) . default ( '' ) ,
} ) ;

schema . default ( ) ; // -> { name: '' }

นี่อาจจะน่าประหลาดใจเล็กน้อย แต่มักจะมีประโยชน์ เนื่องจากช่วยให้สคีมาขนาดใหญ่ที่ซ้อนกันสามารถสร้างค่าเริ่มต้นที่เติมเต็มรูปร่างทั้งหมด ไม่ใช่แค่ออบเจ็กต์รูท มีหนึ่ง gotcha! แม้ว่า. สำหรับสคีมาออบเจ็กต์ที่ซ้อนกันซึ่งเป็นทางเลือกแต่รวมฟิลด์ที่ไม่เป็นทางเลือกอาจล้มเหลวในลักษณะที่ไม่คาดคิด:

 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

กำหนดคีย์ของออบเจ็กต์และสกีมาสำหรับคีย์ดังกล่าว

โปรดทราบว่าคุณสามารถใช้วิธี chain shape ซึ่งทำหน้าที่เหมือนกับ Object.assign

 object ( {
  a : string ( ) ,
  b : number ( ) ,
} ) . shape ( {
  b : string ( ) ,
  c : number ( ) ,
} ) ;

จะเหมือนกับ:

 object ( {
  a : string ( ) ,
  b : string ( ) ,
  c : number ( ) ,
} ) ; 

object.json(): this

พยายามแยกวิเคราะห์ค่าสตริงอินพุตเป็น JSON โดยใช้ JSON.parse

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

แปลงคีย์วัตถุทั้งหมดเป็น CamelCase

object.constantCase(): Schema

แปลงคีย์วัตถุทั้งหมดเป็น CONSTANT_CASE