yup
v1 Because I finally got around to it
Yup adalah pembuat skema untuk penguraian dan validasi nilai runtime. Tentukan skema, ubah nilai agar sesuai, tegaskan bentuk nilai yang ada, atau keduanya. Skema Yup sangat ekspresif dan memungkinkan pemodelan validasi yang kompleks dan saling bergantung, atau transformasi nilai.
Anda melihat dokumen untuk v1.0.0 ya, dokumen sebelum v1 tersedia: di sini
Fitur Pembunuh :
Skema terdiri dari tindakan penguraian (transformasi) serta pernyataan (pengujian) tentang nilai masukan. Validasi nilai input untuk menguraikannya dan menjalankan serangkaian pernyataan yang dikonfigurasi. Menyatukan metode untuk membangun skema.
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
}*/Gunakan skema untuk memaksa atau "melemparkan" nilai input ke tipe yang benar, dan secara opsional mengubah nilai tersebut menjadi nilai yang lebih konkret dan spesifik, tanpa membuat pernyataan lebih lanjut.
// 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 }Tahukah Anda bahwa nilai masukan Anda sudah diurai? Anda dapat "secara ketat" memvalidasi input, dan menghindari overhead menjalankan logika parsing.
// 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 Alias: 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(): SchemaDefinisi skema, terdiri dari penguraian "transformasi" yang memanipulasi masukan ke dalam bentuk dan jenis yang diinginkan, "pengujian", yang membuat pernyataan atas data yang diurai. Skema juga menyimpan sekumpulan "metadata", detail tentang skema itu sendiri, yang dapat digunakan untuk memperbaiki pesan kesalahan, membuat alat yang menggunakan skema secara dinamis, atau membuat serial skema ke dalam format lain.
Agar fleksibel secara maksimal, yup memungkinkan menjalankan parsing dan pernyataan secara terpisah untuk menyesuaikan dengan kebutuhan spesifik
Setiap tipe bawaan mengimplementasikan penguraian tipe dasar, yang berguna saat mengurai data serial, seperti JSON. Selain itu tipe mengimplementasikan transformasi tipe spesifik yang dapat diaktifkan.
let num = number ( ) . cast ( '1' ) ; // 1
let obj = object ( {
firstName : string ( ) . lowercase ( ) . trim ( ) ,
} )
. json ( )
. camelCase ( )
. cast ( '{"first_name": "jAnE "}' ) ; // { firstName: 'jane' }Transformasi khusus dapat ditambahkan
let reversedString = string ( )
. transform ( ( currentValue ) => currentValue . split ( '' ) . reverse ( ) . join ( '' ) )
. cast ( 'dlrow olleh' ) ; // "hello world" Transformasi membentuk "pipa", di mana nilai transformasi sebelumnya disalurkan ke transformasi berikutnya. Ketika nilai input undefined yup akan menerapkan skema default jika dikonfigurasi.
Hati-Hati! nilai tidak dijamin menjadi tipe yang valid dalam fungsi transformasi. Transformasi sebelumnya mungkin gagal. Misalnya transformasi bilangan dapat menerima nilai masukan,
NaN, atau bilangan.
Skema Yup menjalankan "tes" pada nilai input. Pengujian menegaskan bahwa masukan memenuhi beberapa kriteria. Pengujian berbeda dari transformasi, karena pengujian tersebut tidak mengubah atau mengubah masukan (atau tipenya) dan biasanya dicadangkan untuk pemeriksaan yang sulit, bahkan tidak mungkin, untuk direpresentasikan dalam tipe statis.
string ( )
. min ( 3 , 'must be at least 3 characters long' )
. email ( 'must be a valid email' )
. validate ( 'no' ) ; // ValidationErrorSeperti halnya transformasi, pengujian dapat disesuaikan dengan cepat
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"Perhatian: tidak seperti transformasi,
valuedalam pengujian khusus dijamin merupakan tipe yang benar (dalam hal ini string opsional). Ini mungkin masihundefinedataunulltergantung pada skema Anda. Dalam kasus tersebut, Anda mungkin ingin mengembalikantrueuntuk nilai yang tidak ada kecuali transformasi Anda membuat pernyataan terkait kehadiran. Opsi tesskipAbsentakan melakukan ini untuk Anda jika disetel.
Dalam kasus yang paling sederhana, fungsi pengujian mengembalikan true atau false tergantung pada apakah pemeriksaan berhasil atau tidak. Jika pengujian gagal, ya, Anda akan menampilkan ValidationError dengan pesan Anda (atau default) untuk pengujian tersebut. ValidationErrors juga berisi banyak metadata lain tentang pengujian, termasuk namanya, argumen apa (jika ada) yang digunakan untuk memanggilnya, dan jalur ke bidang yang gagal dalam kasus validasi bertingkat.
Pesan kesalahan juga dapat dibuat dengan cepat untuk menyesuaikan kegagalan skema.
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' } )Skema tidak dapat diubah, setiap pemanggilan metode mengembalikan objek skema baru. Gunakan kembali dan sebarkan tanpa takut mutasi pada instance lain.
let optionalString = string ( ) . optional ( ) ;
let definedString = optionalString . defined ( ) ;
let value = undefined ;
optionalString . isValid ( value ) ; // true
definedString . isValid ( value ) ; // false Skema Yup menghasilkan antarmuka TypeScript statis. Gunakan InferType untuk mengekstrak antarmuka itu:
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
} Default skema digunakan ketika casting menghasilkan nilai output undefined . Oleh karena itu, menyetel default akan memengaruhi jenis keluaran skema, yang pada dasarnya menandainya sebagai "didefinisikan()".
import { string } from 'yup' ;
let value : string = string ( ) . default ( 'hi' ) . validate ( undefined ) ;
// vs
let value : string | undefined = string ( ) . validate ( undefined ) ;Dalam beberapa kasus, tipe TypeScript sudah ada, dan Anda ingin memastikan bahwa skema Anda menghasilkan tipe yang kompatibel:
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 ( ) ,
} ) ; Anda dapat menggunakan perilaku penggabungan antarmuka TypeScript untuk memperluas tipe skema jika diperlukan. Jenis ekstensi harus dimasukkan dalam file definisi tipe "ambient" seperti globals.d.ts Anda. Ingatlah untuk benar-benar memperluas tipe yup dalam kode aplikasi Anda!
Hati-Hati! penggabungan hanya berfungsi jika definisi tipenya persis sama, termasuk generik. Konsultasikan kode sumber yup untuk setiap jenis untuk memastikan Anda mendefinisikannya dengan benar
// 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~~~~' Anda harus mengaktifkan opsi kompiler strictNullChecks agar inferensi tipe dapat berfungsi.
Kami juga merekomendasikan pengaturan strictFunctionTypes ke false , untuk tipe yang lebih baik secara fungsional. Ya, ini mengurangi kesehatan secara keseluruhan, namun TypeScript sudah menonaktifkan pemeriksaan metode dan konstruktor ini (catatan dari dokumen TS):
Selama pengembangan fitur ini, kami menemukan sejumlah besar hierarki kelas yang pada dasarnya tidak aman, termasuk beberapa di DOM. Oleh karena itu, pengaturan ini hanya berlaku pada fungsi yang ditulis dalam sintaks fungsi, bukan pada sintaks metode:
Jarak tempuh Anda akan bervariasi, namun kami menemukan bahwa pemeriksaan ini tidak mencegah banyak bug nyata, sekaligus meningkatkan jumlah transmisi tipe eksplisit yang memberatkan dalam aplikasi.
Pesan kesalahan default dapat disesuaikan ketika tidak ada pesan yang diberikan dengan uji validasi. Jika ada pesan yang hilang dalam kamus khusus, pesan kesalahan akan default ke pesan 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']
} Jika Anda memerlukan dukungan multi-bahasa, ya, Anda siap membantu. Fungsi setLocale menerima fungsi yang dapat digunakan untuk menghasilkan objek kesalahan dengan kunci dan nilai terjemahan. Ini dapat dimasukkan ke perpustakaan i18n favorit Anda.
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 ) ) ;
} yupEkspor modul.
// 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 Untuk skema bertingkat, reach akan mengambil skema dalam berdasarkan jalur yang disediakan.
Untuk skema bertingkat yang perlu diselesaikan secara dinamis, Anda dapat memberikan value dan objek context secara opsional.
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 Menambahkan metode baru ke tipe skema inti. Metode praktis yang lebih ramah untuk 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 ( '' ) ;
} ) ;
} ) ; Jika Anda ingin menambahkan metode ke SEMUA tipe skema, perluas kelas dasar abstrak: Schema
import { addMethod , Schema } from 'yup' ;
addMethod ( Schema , 'myMethod' , ... ) ref(path: string, options: { contextPrefix: string }): RefMembuat referensi ke bidang saudara atau keturunan saudara lainnya. Referensi diselesaikan pada waktu validasi/cast dan didukung jika ditentukan. Referensi dievaluasi dalam urutan yang benar sehingga nilai ref diselesaikan sebelum bidang menggunakan ref (hati-hati terhadap ketergantungan melingkar!).
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): LazyMembuat skema yang dievaluasi pada waktu validasi/cast. Berguna untuk membuat skema rekursif seperti Pohon, untuk bidang dan array polimorfik.
PERINGATAN! Saat mendefinisikan skema objek rekursif induk-anak, Anda ingin menyetel ulang default() ke null pada skema turunan—jika tidak, objek akan bersarang tanpa batas saat Anda mentransmisikannya!
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)Dilemparkan pada validasi yang gagal, dengan properti berikut
name : "ValidationError"type : jenis tes tertentu atau "nama" tes, yang gagal.value : Nilai bidang yang diuji;params ?: Input pengujian, seperti nilai maksimal, regex, dll;path : sebuah string, yang menunjukkan di mana kesalahan terjadi. path kosong di tingkat root.errors : serangkaian pesan kesalahaninner : dalam kasus kesalahan agregat, inner adalah array dari ValidationErrors yang dilemparkan sebelumnya dalam rantai validasi. Jika opsi abortEarly false di sinilah Anda dapat memeriksa setiap kesalahan yang terjadi, alternatifnya, errors akan memiliki semua pesan dari setiap kesalahan dalam.Schema Schema adalah kelas dasar abstrak yang diwarisi oleh semua tipe skema. Ini menyediakan sejumlah metode dasar dan properti untuk semua jenis skema lainnya.
Catatan: kecuali Anda membuat tipe skema khusus, Skema tidak boleh digunakan secara langsung. Untuk tipe yang tidak diketahui/apa pun, gunakan
mixed()
Schema.clone(): SchemaMembuat salinan skema yang mendalam. Klon digunakan secara internal untuk mengembalikan skema baru dengan setiap perubahan status skema.
Schema.label(label: string): SchemaMengganti nama kunci yang digunakan dalam pesan kesalahan.
Schema.meta(metadata: SchemaMetadata): SchemaMenambahkan ke objek metadata, berguna untuk menyimpan data dengan skema, yang bukan milik objek cast itu sendiri.
Antarmuka SchemaMetadata khusus dapat ditentukan melalui penggabungan dengan antarmuka CustomSchemaMetadata . Mulailah dengan membuat file yup.d.ts di paket Anda dan membuat antarmuka CustomSchemaMetadata yang Anda inginkan:
// 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): SchemaDescriptionMengumpulkan detail skema (seperti meta, label, dan pengujian aktif) ke dalam objek deskripsi yang dapat diserialkan.
let schema = object ( {
name : string ( ) . required ( ) ,
} ) ;
let description = schema . describe ( ) ; Untuk skema dengan komponen dinamis (referensi, malas, atau kondisi), deskripsikan memerlukan lebih banyak konteks agar dapat mengembalikan deskripsi skema secara akurat. Dalam kasus ini berikan 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 } } ) ;Dan di bawah ini adalah tipe deskripsinya, yang sedikit berbeda tergantung pada tipe skemanya.
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 Membuat instance skema baru dengan menggabungkan dua skema. Hanya skema dengan tipe yang sama yang dapat digabungkan. concat bukan fungsi "penggabungan" dalam arti bahwa semua pengaturan dari skema yang disediakan, menimpa pengaturan di dasar, termasuk jenis, keberadaan, dan nullabilitas.
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> Mengembalikan penguraian dan memvalidasi nilai masukan, mengembalikan nilai yang diurai, atau menimbulkan kesalahan. Metode ini tidak sinkron dan mengembalikan objek Promise, yang dipenuhi nilainya, atau ditolak dengan ValidationError .
value = await schema . validate ( { name : 'jimmy' , age : 24 } ) ; Berikan options untuk mengontrol perilaku validate secara lebih spesifik.
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> Menjalankan validasi secara sinkron jika memungkinkan dan mengembalikan nilai yang dihasilkan, atau memunculkan ValidationError. Menerima semua opsi yang sama seperti validate .
Validasi sinkron hanya berfungsi jika tidak ada pengujian asinkron yang dikonfigurasi, misalnya pengujian yang mengembalikan Janji. Misalnya ini akan berhasil:
let schema = number ( ) . test (
'is-42' ,
"this isn't the number i want" ,
( value ) => value != 42 ,
) ;
schema . validateSync ( 23 ) ; // throws ValidationErrornamun hal ini tidak akan terjadi:
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> Validasi jalur yang sangat bertumpuk dalam skema. Mirip dengan cara kerja reach , tetapi menggunakan skema yang dihasilkan sebagai subjek validasi.
Catatan!
valuedi sini adalah nilai akar yang relatif terhadap skema awal, bukan nilai pada jalur bersarang.
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> Sama seperti validateAt tetapi sinkron.
Schema.isValid(value: any, options?: object): Promise<boolean> Mengembalikan true ketika nilai yang diteruskan cocok dengan skema. isValid tidak sinkron dan mengembalikan objek Promise.
Mengambil opsi yang sama seperti validate() .
Schema.isValidSync(value: any, options?: object): boolean Secara sinkron mengembalikan true ketika nilai yang diteruskan cocok dengan skema.
Mengambil opsi yang sama seperti validateSync() dan memiliki peringatan yang sama seputar pengujian asinkron.
Schema.cast(value: any, options = {}): InferType<Schema> Upaya untuk memaksa nilai yang diteruskan ke nilai yang cocok dengan skema. Misalnya: '5' akan diubah menjadi 5 saat menggunakan tipe number() . Pemeran yang gagal biasanya mengembalikan null , tetapi mungkin juga mengembalikan hasil seperti NaN dan string yang tidak diharapkan.
Berikan options untuk mengontrol perilaku validate secara lebih spesifik.
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> Menjalankan pemeriksaan tipe terhadap value yang diteruskan. Ia mengembalikan nilai benar jika cocok, tidak memberikan nilai. Ketika nullable() disetel, null dianggap sebagai nilai tipe yang valid. Anda harus menggunakan isType untuk semua pemeriksaan jenis Skema.
Schema.strict(enabled: boolean = false): Schema Menyetel opsi strict ke true . Skema yang ketat melewatkan upaya pemaksaan dan transformasi, memvalidasi nilai "sebagaimana adanya".
Schema.strip(enabled: boolean = true): SchemaMenandai skema yang akan dihapus dari objek keluaran. Hanya berfungsi sebagai skema bersarang.
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
schema . cast ( { notThis : 'foo' , useThis : 4 } ) ; // => { useThis: 4 } Skema dengan strip yang diaktifkan memiliki tipe yang disimpulkan never , sehingga memungkinkannya untuk dihapus dari tipe keseluruhan:
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
InferType < typeof schema > ; /*
{
useThis?: number | undefined
}
*/ Schema.withMutation(builder: (current: Schema) => void): voidPertama, kutipan Rich Hickey yang diwajibkan secara hukum:
Jika pohon tumbang di hutan, apakah menimbulkan suara?
Jika fungsi murni mengubah beberapa data lokal untuk menghasilkan nilai kembalian yang tidak dapat diubah, apakah boleh?
withMutation memungkinkan Anda untuk mengubah skema yang ada, alih-alih perilaku default yang dikloning sebelum setiap perubahan. Umumnya hal ini tidak diperlukan karena sebagian besar perubahan skema terjadi selama deklarasi awal, dan hanya terjadi sekali selama masa pakai skema, sehingga kinerja tidak menjadi masalah. Namun mutasi tertentu terjadi pada waktu cast/validasi, (seperti penggunaan skema bersyarat when() ), atau saat membuat instance objek skema.
object ( )
. shape ( { key : string ( ) } )
. withMutation ( ( schema ) => {
return arrayOfObjectTests . forEach ( ( test ) => {
schema . test ( test ) ;
} ) ;
} ) ; Schema.default(value: any): Schema Menetapkan nilai default untuk digunakan ketika nilainya undefined . Default dibuat setelah transformasi dijalankan, tetapi sebelum validasi, untuk membantu memastikan bahwa default aman ditentukan. Nilai default akan dikloning pada setiap penggunaan, yang dapat menimbulkan penalti kinerja untuk objek dan array. Untuk menghindari overhead ini, Anda juga dapat meneruskan fungsi yang mengembalikan default baru. Perhatikan bahwa null dianggap sebagai nilai tidak kosong yang terpisah.
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 Ambil nilai default yang ditetapkan sebelumnya. getDefault akan menyelesaikan segala kondisi yang dapat mengubah default. Secara opsional, berikan options dengan context (untuk info lebih lanjut tentang context lihat Schema.validate ).
Schema.nullable(message?: string | function): Schema Menunjukkan bahwa null adalah nilai yang valid untuk skema. Tanpa nullable() null diperlakukan sebagai tipe yang berbeda dan akan gagal dalam pemeriksaan Schema.isType() .
let schema = number ( ) . nullable ( ) ;
schema . cast ( null ) ; // null
InferType < typeof schema > ; // number | null Schema.nonNullable(message?: string | function): Schema Kebalikan dari nullable , menghapus null dari nilai tipe yang valid untuk skema. Skema tidak dapat dibatalkan secara default .
let schema = number ( ) . nonNullable ( ) ;
schema . cast ( null ) ; // TypeError
InferType < typeof schema > ; // number Schema.defined(): Schema Memerlukan nilai untuk skema. Semua nilai bidang selain undefined memenuhi persyaratan ini.
let schema = string ( ) . defined ( ) ;
schema . cast ( undefined ) ; // TypeError
InferType < typeof schema > ; // string Schema.optional(): Schema Kebalikan dari defined() memungkinkan nilai undefined untuk tipe tertentu.
let schema = string ( ) . optional ( ) ;
schema . cast ( undefined ) ; // undefined
InferType < typeof schema > ; // string | undefined Schema.required(message?: string | function): Schema Tandai skema sebagai wajib, yang tidak akan memperbolehkan nilai undefined atau null . required meniadakan efek pemanggilan optional() dan nullable()
Hati-Hati!
string().required) bekerja sedikit berbeda dan juga mencegah nilai string kosong ('') bila diperlukan.
Schema.notRequired(): Schema Tandai skema sebagai tidak diperlukan. Ini adalah jalan pintas untuk schema.nullable().optional() ;
Schema.typeError(message: string): Schema Tentukan pesan kesalahan untuk pemeriksaan jenis yang gagal. Interpolasi ${value} dan ${type} dapat digunakan dalam argumen message .
Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema Alias: equals Hanya izinkan nilai dari kumpulan nilai. Nilai yang ditambahkan akan dihapus dari nilai notOneOf apa pun jika ada. Interpolasi ${values} dapat digunakan dalam argumen message . Jika ref atau ref disediakan, interpolasi ${resolved} dapat digunakan dalam argumen pesan untuk mendapatkan nilai penyelesaian yang diperiksa pada waktu validasi.
Perhatikan bahwa undefined tidak menggagalkan validator ini, bahkan ketika undefined tidak disertakan dalam arrayOfValues . Jika Anda tidak ingin undefined menjadi nilai yang valid, Anda dapat menggunakan 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) Larang nilai dari sekumpulan nilai. Nilai yang ditambahkan akan dihapus dari nilai oneOf jika ada. Interpolasi ${values} dapat digunakan dalam argumen message . Jika ref atau ref disediakan, interpolasi ${resolved} dapat digunakan dalam argumen pesan untuk mendapatkan nilai penyelesaian yang diperiksa pada waktu validasi.
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 Sesuaikan skema berdasarkan bidang saudara atau anak saudara. Anda dapat memberikan objek literal yang kuncinya is nilai atau fungsi pencocokan, then memberikan skema sebenarnya dan/atau otherwise untuk kondisi kegagalan.
kondisi is dibandingkan secara ketat ( === ) jika Anda ingin menggunakan bentuk persamaan yang berbeda, Anda dapat menyediakan fungsi seperti: is: (value) => value == true .
Anda juga dapat mengawali properti dengan $ untuk menentukan properti yang bergantung pada context yang diteruskan oleh validate() atau cast sebagai ganti nilai input.
when kondisi bersifat aditif.
then dan otherwise adalah fungsi yang ditentukan (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 } } ) ;Anda juga dapat menentukan lebih dari satu kunci dependen, dalam hal ini setiap nilai akan disebarkan sebagai argumen.
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 ,
} ) ;Alternatifnya, Anda dapat menyediakan fungsi yang mengembalikan skema, yang dipanggil dengan array nilai untuk setiap kunci yang disediakan pada skema saat ini.
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): SchemaMenambahkan fungsi pengujian ke rantai validasi. Pengujian dijalankan setelah objek apa pun dilemparkan. Banyak jenis yang memiliki beberapa pengujian bawaan, namun Anda dapat membuat pengujian khusus dengan mudah. Untuk mengizinkan validasi khusus asinkron, semua (atau tidak sama sekali) pengujian dijalankan secara asinkron. Konsekuensinya adalah perintah pelaksanaan pengujian tidak dapat dijamin.
Semua pengujian harus memberikan name , message kesalahan, dan fungsi validasi yang harus mengembalikan true ketika value saat ini valid dan false atau ValidationError sebaliknya. Untuk membuat pengujian async, kembalikan janji yang menyelesaikan true atau false atau ValidationError .
Untuk argumen message Anda dapat memberikan string yang akan menginterpolasi nilai tertentu jika ditentukan menggunakan sintaks ${param} . Secara default, semua pesan pengujian diberikan nilai path yang berharga dalam skema bersarang.
Fungsi test dipanggil dengan value saat ini. Untuk validasi lebih lanjut, Anda dapat menggunakan tanda tangan alternatif untuk memberikan lebih banyak opsi (lihat di bawah):
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 Fungsi pengujian dipanggil dengan nilai konteks khusus, sebagai argumen kedua, yang memperlihatkan beberapa metadata dan fungsi yang berguna. Untuk fungsi non-panah, konteks pengujian juga ditetapkan sebagai fungsi this . Hati-hati, jika Anda mengaksesnya melalui this fungsi panah tidak akan berfungsi.
testContext.path : jalur string validasi saat initestContext.schema : objek skema terselesaikan yang menjadi lawan pengujian.testContext.options : objek options yang validasi() atau isValid() dipanggiltestContext.parent : dalam kasus skema bersarang, ini adalah nilai objek induktestContext.originalValue : nilai asli yang sedang diujitestContext.createError(Object: { path: String, message: String, params: Object }) : membuat dan mengembalikan kesalahan validasi. Berguna untuk menyetel path , params , atau lebih mungkin lagi, message kesalahan secara dinamis. Jika salah satu pilihan dihilangkan maka akan menggunakan jalur saat ini, atau pesan default. Schema.test(options: object): Schema test(..) tanda tangan. options adalah objek yang berisi beberapa opsi berikut:
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 ;
}Dalam kasus pencampuran tes eksklusif dan non-eksklusif, logika berikut digunakan. Jika pengujian non-eksklusif ditambahkan ke skema dengan pengujian eksklusif dengan nama yang sama, pengujian eksklusif tersebut dihapus dan pengujian selanjutnya dengan nama yang sama akan ditumpuk.
Jika pengujian eksklusif ditambahkan ke skema dengan pengujian non-eksklusif dengan nama yang sama, pengujian sebelumnya akan dihapus dan pengujian selanjutnya dengan nama yang sama akan saling menggantikan.
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 Menambahkan transformasi ke rantai transformasi. Transformasi sangat penting dalam proses casting, transformasi default untuk setiap tipe memaksa nilai ke tipe tertentu (sebagaimana diverifikasi oleh isType() ). transformasi dijalankan sebelum validasi dan hanya diterapkan ketika skema tidak ditandai sebagai strict (default). Beberapa tipe telah membangun transformasi.
Transformasi berguna untuk mengubah cara objek dilemparkan secara sewenang-wenang, namun Anda harus berhati-hati agar tidak mengubah nilai yang diteruskan. Transformasi dijalankan secara berurutan sehingga setiap value mewakili status pemeran saat ini, Anda dapat menggunakan parameter originalValue jika Anda perlu mengerjakan nilai awal mentah.
let schema = string ( ) . transform ( ( value , originalValue ) => {
return this . isType ( value ) && value !== null ? value . toUpperCase ( ) : value ;
} ) ;
schema . cast ( 'jimmy' ) ; // => 'JIMMY'Setiap tipe akan menangani pemaksaan nilai dasar ke tipe yang sesuai untuk Anda, namun terkadang Anda mungkin ingin menyesuaikan atau menyempurnakan perilaku default. Misalnya, jika Anda ingin menggunakan strategi penguraian tanggal yang berbeda dari strategi default, Anda dapat melakukannya dengan transformasi.
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 ( '' ) ;
} ) ;
} ; Membuat skema yang cocok dengan semua tipe, atau hanya skema yang Anda konfigurasikan. Mewarisi dari Schema . Tipe campuran memperluas {} secara default, bukan any atau unknown . Ini karena dalam TypeScript {} berarti segala sesuatu yang bukan null atau undefined yang diperlakukan dengan jelas.
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 Tipe khusus dapat diimplementasikan dengan meneruskan fungsi check tipe. Ini juga akan mempersempit tipe TypeScript untuk skema tersebut.
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 Tentukan skema string. Mewarisi dari Schema .
let schema = yup . string ( ) ;
await schema . isValid ( 'hello' ) ; // => true Secara default, logika cast string adalah memanggil toString pada nilai jika ada.
nilai kosong tidak dipaksakan (gunakan ensure() untuk memaksa nilai kosong menjadi string kosong).
Pemeran yang gagal mengembalikan nilai input.
string.required(message?: string | function): Schema Sama seperti skema mixed() yang diperlukan, hanya saja string kosong juga dianggap nilai 'hilang'.
string.length(limit: number | Ref, message?: string | function): Schema Tetapkan panjang yang diperlukan untuk nilai string. Interpolasi ${length} dapat digunakan dalam argumen message
string.min(limit: number | Ref, message?: string | function): Schema Tetapkan batas panjang minimum untuk nilai string. Interpolasi ${min} dapat digunakan dalam argumen message
string.max(limit: number | Ref, message?: string | function): Schema Tetapkan batas panjang maksimum untuk nilai string. Interpolasi ${max} dapat digunakan dalam argumen message
string.matches(regex: Regex, message?: string | function): Schema Berikan regex sewenang-wenang untuk mencocokkan nilainya.
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 Tanda tangan alternatif untuk string.matches dengan objek opsi. excludeEmptyString , jika benar, menyebabkan hubungan pendek pada pengujian regex ketika nilainya adalah string kosong, membuatnya lebih mudah untuk menghindari pencocokan apa pun tanpa mempersulit regex.
let schema = string ( ) . matches ( / (hi|bye) / , { excludeEmptyString : true } ) ;
await schema . isValid ( '' ) ; // => true string.email(message?: string | function): SchemaMemvalidasi nilai sebagai alamat email menggunakan regex yang sama seperti yang ditentukan oleh spesifikasi HTML.
HATI-HATI: Memvalidasi alamat email hampir tidak mungkin dilakukan hanya dengan kode. Klien dan server yang berbeda menerima hal yang berbeda dan banyak yang berbeda dari berbagai spesifikasi yang mendefinisikan email "valid". SATU-SATUNYA cara nyata untuk memvalidasi alamat email adalah dengan mengirimkan email verifikasi ke alamat tersebut dan memeriksa apakah pengguna mendapatkannya. Dengan mengingat hal tersebut, ya, pilih regex yang relatif sederhana yang tidak mencakup semua kasus, namun selaras dengan perilaku validasi masukan browser karena formulir HTML adalah kasus penggunaan umum untuk Anda.
Jika Anda memiliki kebutuhan yang lebih spesifik, harap ganti metode email dengan logika atau regex Anda sendiri:
yup . addMethod ( yup . string , 'email' , function validateEmail ( message ) {
return this . matches ( myEmailRegex , {
message ,
name : 'email' ,
excludeEmptyString : true ,
} ) ;
} ) ; string.url(message?: string | function): SchemaMemvalidasi nilai sebagai URL yang valid melalui regex.
string.uuid(message?: string | function): SchemaMemvalidasi nilai sebagai UUID yang valid melalui regex.
string.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number}) Memvalidasi nilai sebagai tanggal waktu ISO melalui regex. Default untuk validasi UTC; offset zona waktu tidak diizinkan (lihat options.allowOffset ).
Berbeda dengan .date() , datetime tidak akan mengonversi string menjadi objek Date . datetime juga memberikan penyesuaian yang lebih besar terhadap format string datetime yang diperlukan dibandingkan date .
options.allowOffset : Mengizinkan offset zona waktu. Salah memerlukan zona waktu UTC 'Z'. (default: false) options.precision : Membutuhkan presisi sub-detik tertentu pada tanggal tersebut. (default: null -- presisi subdetik apa pun (atau tidak sama sekali))
string.datetime(message?: string | function) Tanda tangan alternatif untuk string.datetime yang dapat digunakan saat Anda tidak perlu meneruskan opsi selain message .
string.ensure(): Schema Mengubah nilai undefined dan null menjadi string kosong bersama dengan menyetel default ke string kosong.
string.trim(message?: string | function): Schema Mengubah nilai string dengan menghapus spasi di awal dan akhir. Jika strict() disetel, ini hanya akan memvalidasi bahwa nilainya dipangkas.
string.lowercase(message?: string | function): Schema Mengubah nilai string menjadi huruf kecil. Jika strict() disetel, ini hanya akan memvalidasi bahwa nilainya adalah huruf kecil.
string.uppercase(message?: string | function): Schema Mengubah nilai string menjadi huruf besar. Jika strict() disetel, ini hanya akan memvalidasi bahwa nilainya adalah huruf besar.
Tentukan skema angka. Mewarisi dari Schema .
let schema = yup . number ( ) ;
await schema . isValid ( 10 ) ; // => true Logika cast number default adalah: parseFloat .
Pemeran yang gagal mengembalikan NaN .
number.min(limit: number | Ref, message?: string | function): Schema Tetapkan nilai minimum yang diizinkan. Interpolasi ${min} dapat digunakan dalam argumen message .
number.max(limit: number | Ref, message?: string | function): Schema Tetapkan nilai maksimum yang diizinkan. Interpolasi ${max} dapat digunakan dalam argumen message .
number.lessThan(max: number | Ref, message?: string | function): Schema Nilai harus kurang dari max . Interpolasi ${less} dapat digunakan dalam argumen message .
number.moreThan(min: number | Ref, message?: string | function): Schema Nilai harus benar-benar lebih besar dari min . Interpolasi ${more} dapat digunakan dalam argumen message .
number.positive(message?: string | function): SchemaNilai harus berupa angka positif.
number.negative(message?: string | function): SchemaNilai harus berupa angka negatif.
number.integer(message?: string | function): SchemaMemvalidasi bahwa suatu angka adalah bilangan bulat.
number.truncate(): SchemaTransformasi yang memaksa nilai menjadi bilangan bulat dengan menghilangkan angka di sebelah kanan koma desimal.
number.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schema Menyesuaikan nilai melalui metode Math yang ditentukan (defaultnya adalah 'bulat').
Tentukan skema boolean. Mewarisi dari Schema .
let schema = yup . boolean ( ) ;
await schema . isValid ( true ) ; // => true Tentukan skema Tanggal. Secara default, string tanggal ISO akan diurai dengan benar, untuk opsi penguraian yang lebih kuat, lihat jenis skema perluasan di akhir readme. Mewarisi dari Schema .
let schema = yup . date ( ) ;
await schema . isValid ( new Date ( ) ) ; // => true Logika cast default date adalah meneruskan nilai ke konstruktor Date , jika gagal, ia akan mencoba mengurai tanggal sebagai string tanggal ISO.
Jika Anda ingin string ISO tidak dilemparkan ke objek
Date, gunakan.datetime()sebagai gantinya.
Pemeran yang gagal menghasilkan Tanggal yang tidak valid.
date.min(limit: Date | string | Ref, message?: string | function): SchemaTetapkan tanggal minimum yang diperbolehkan. Ketika sebuah string disediakan, ia akan mencoba mentransmisikan tanggal terlebih dahulu dan menggunakan hasilnya sebagai batasnya.
date.max(limit: Date | string | Ref, message?: string | function): SchemaTetapkan tanggal maksimum yang diperbolehkan, Ketika string diberikan, string akan mencoba mentransmisikan tanggal terlebih dahulu dan menggunakan hasilnya sebagai batas.
Tentukan skema array. Array bisa diketik atau tidak, Saat menentukan tipe elemen, cast dan isValid akan berlaku untuk elemen juga. Opsi yang diteruskan ke isValid juga diteruskan ke skema anak.
Mewarisi dari 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]Anda juga dapat meneruskan skema subtipe ke konstruktor array untuk memudahkan.
array ( ) . of ( yup . number ( ) ) ;
// or
array ( yup . number ( ) ) ;Array tidak memiliki perilaku transmisi default.
array.of(type: Schema): this Tentukan skema elemen array. of() bersifat opsional dan ketika dihilangkan skema array tidak akan memvalidasi isinya.
array.json(): this Coba parsing nilai string masukan sebagai JSON menggunakan JSON.parse .
array.length(length: number | Ref, message?: string | function): this Tetapkan persyaratan panjang tertentu untuk array. Interpolasi ${length} dapat digunakan dalam argumen message .
array.min(limit: number | Ref, message?: string | function): this Tetapkan batas panjang minimum untuk array. Interpolasi ${min} dapat digunakan dalam argumen message .
array.max(limit: number | Ref, message?: string | function): this Tetapkan batas panjang maksimum untuk array. Interpolasi ${max} dapat digunakan dalam argumen message .
array.ensure(): this Memastikan bahwa nilainya adalah array, dengan menyetel default ke [] dan juga mengubah nilai null dan undefined menjadi array kosong. Nilai apa pun yang tidak kosong dan bukan array akan dimasukkan ke dalam array.
array ( ) . ensure ( ) . cast ( null ) ; // => []
array ( ) . ensure ( ) . cast ( 1 ) ; // => [1]
array ( ) . ensure ( ) . cast ( [ 1 ] ) ; // => [1] array.compact(rejector: (value) => boolean): SchemaMenghapus nilai palsu dari array. Menyediakan fungsi penolakan memungkinkan Anda menentukan sendiri kriteria penolakan.
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]Tupel, adalah array dengan panjang tetap di mana setiap item memiliki tipe berbeda.
Mewarisi dari 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] | undefinedtupel tidak memiliki perilaku transmisi default.
Tentukan skema objek. Opsi yang diteruskan ke isValid juga diteruskan ke skema anak. Mewarisi dari Schema .
yup . object ( {
name : string ( ) . required ( ) ,
age : number ( ) . required ( ) . positive ( ) . integer ( ) ,
email : string ( ) . email ( ) ,
website : string ( ) . url ( ) ,
} ) ;skema objek tidak menerapkan transformasi default apa pun.
Skema objek hadir dengan nilai default yang telah ditetapkan, yang "membangun" bentuk objek, dan menetapkan nilai default apa pun untuk bidang:
let schema = object ( {
name : string ( ) . default ( '' ) ,
} ) ;
schema . default ( ) ; // -> { name: '' }Ini mungkin sedikit mengejutkan, namun biasanya berguna karena memungkinkan skema bersarang yang besar untuk membuat nilai default yang mengisi keseluruhan bentuk dan bukan hanya objek akar. Ada satu hal yang perlu diketahui! meskipun. Untuk skema objek bertumpuk yang opsional namun menyertakan bidang non opsional mungkin gagal dengan cara yang tidak terduga:
let schema = object ( {
id : string ( ) . required ( ) ,
names : object ( {
first : string ( ) . required ( ) ,
} ) ,
} ) ;
schema . isValid ( { id : 1 } ) ; // false! names.first is requiredIni karena ya, cast objek input sebelum menjalankan validasi yang akan menghasilkan:
{ id: '1', names: { first: undefined }}
Selama fase validasi, names ada, dan divalidasi, menemukan names.first hilang. Jika Anda ingin menghindari perilaku ini, lakukan salah satu hal berikut:
names.default(undefined)names.nullable().default(null) object.shape(fields: object, noSortEdges?: Array<[string, string]>): SchemaTentukan kunci objek dan skema untuk kunci tersebut.
Perhatikan bahwa Anda dapat merangkai metode shape , yang bertindak seperti Object.assign .
object ( {
a : string ( ) ,
b : number ( ) ,
} ) . shape ( {
b : string ( ) ,
c : number ( ) ,
} ) ;akan sama persis dengan:
object ( {
a : string ( ) ,
b : string ( ) ,
c : number ( ) ,
} ) ; object.json(): this Coba parsing nilai string masukan sebagai JSON menggunakan JSON.parse .
object.concat(schemaB: ObjectSchema): ObjectSchema Membuat skema objek, dengan menerapkan semua pengaturan dan bidang dari schemaB ke dasar, menghasilkan skema baru. Bentuk objek digabungkan secara dangkal dengan bidang umum dari schemaB yang diutamakan daripada bidang dasar.
object.pick(keys: string[]): SchemaBuat skema baru dari subkumpulan bidang asli.
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[]): SchemaBuat skema baru dengan bidang dihilangkan.
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 Mengubah kunci tertentu menjadi kunci baru. Jika alias true maka kunci lama akan tersisa.
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 Validasi bahwa nilai objek hanya berisi kunci yang ditentukan dalam shape , berikan false sebagai argumen pertama untuk menonaktifkan pemeriksaan. Membatasi kunci untuk diketahui, juga mengaktifkan opsi stripUnknown , bila tidak dalam mode ketat.
object.camelCase(): SchemaMengubah semua kunci objek menjadi camelCase
object.constantCase(): SchemaMengubah semua kunci objek menjadi CONSTANT_CASE.
