yup
v1 Because I finally got around to it
Sí, es un creador de esquemas para el análisis y validación de valores en tiempo de ejecución. Defina un esquema, transforme un valor para que coincida, afirme la forma de un valor existente, o ambas cosas. Sí, los esquemas son extremadamente expresivos y permiten modelar validaciones complejas e interdependientes o transformaciones de valores.
Estás viendo documentos para la versión 1.0.0 de sí, los documentos anteriores a la v1 están disponibles: aquí
Características asesinas :
Los esquemas se componen de acciones de análisis (transformaciones), así como de afirmaciones (pruebas) sobre el valor de entrada. Valide un valor de entrada para analizarlo y ejecutar el conjunto configurado de aserciones. Encadene métodos para construir un esquema.
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
}*/Utilice un esquema para forzar o "transmitir" un valor de entrada al tipo correcto y, opcionalmente, transformar ese valor en valores más concretos y específicos, sin hacer más afirmaciones.
// 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 }¿Sabe que su valor de entrada ya está analizado? Puede validar "estrictamente" una entrada y evitar la sobrecarga de ejecutar la lógica de análisis.
// ValidationError "age is not a number"
let parsedUser = await userSchema . validate (
{
name : 'jimmy' ,
age : '24' ,
} ,
{ strict : true } ,
) ; yupreach(schema: Schema, path: string, value?: object, context?: object): SchemaaddMethod(schemaType: Schema, name: string, method: ()=> Schema): voidref(path: string, options: { contextPrefix: string }): Reflazy((value: any) => Schema): LazyValidationError(errors: string | Array<string>, value: any, path: string)SchemaSchema.clone(): SchemaSchema.label(label: string): SchemaSchema.meta(metadata: SchemaMetadata): SchemaSchema.describe(options?: ResolveOptions): SchemaDescriptionSchema.concat(schema: Schema): SchemaSchema.validate(value: any, options?: object): Promise<InferType<Schema>, ValidationError>Schema.validateSync(value: any, options?: object): InferType<Schema>Schema.validateAt(path: string, value: any, options?: object): Promise<InferType<Schema>, ValidationError>Schema.validateSyncAt(path: string, value: any, options?: object): InferType<Schema>Schema.isValid(value: any, options?: object): Promise<boolean>Schema.isValidSync(value: any, options?: object): booleanSchema.cast(value: any, options = {}): InferType<Schema>Schema.isType(value: any): value is InferType<Schema>Schema.strict(enabled: boolean = false): SchemaSchema.strip(enabled: boolean = true): SchemaSchema.withMutation(builder: (current: Schema) => void): voidSchema.default(value: any): SchemaSchema.getDefault(options?: object): AnySchema.nullable(message?: string | function): SchemaSchema.nonNullable(message?: string | function): SchemaSchema.defined(): SchemaSchema.optional(): SchemaSchema.required(message?: string | function): SchemaSchema.notRequired(): SchemaSchema.typeError(message: string): SchemaSchema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema : equalsSchema.notOneOf(arrayOfValues: Array<any>, message?: string | function)Schema.when(keys: string | string[], builder: object | (values: any[], schema) => Schema): SchemaSchema.test(name: string, message: string | function | any, test: function): SchemaSchema.test(options: object): SchemaSchema.transform((currentValue: any, originalValue: any) => any): Schemastring.required(message?: string | function): Schemastring.length(limit: number | Ref, message?: string | function): Schemastring.min(limit: number | Ref, message?: string | function): Schemastring.max(limit: number | Ref, message?: string | function): Schemastring.matches(regex: Regex, message?: string | function): Schemastring.matches(regex: Regex, options: { message: string, excludeEmptyString: bool }): Schemastring.email(message?: string | function): Schemastring.url(message?: string | function): Schemastring.uuid(message?: string | function): Schemastring.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number})string.datetime(message?: string | function)string.ensure(): Schemastring.trim(message?: string | function): Schemastring.lowercase(message?: string | function): Schemastring.uppercase(message?: string | function): Schemanumber.min(limit: number | Ref, message?: string | function): Schemanumber.max(limit: number | Ref, message?: string | function): Schemanumber.lessThan(max: number | Ref, message?: string | function): Schemanumber.moreThan(min: number | Ref, message?: string | function): Schemanumber.positive(message?: string | function): Schemanumber.negative(message?: string | function): Schemanumber.integer(message?: string | function): Schemanumber.truncate(): Schemanumber.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schemadate.min(limit: Date | string | Ref, message?: string | function): Schemadate.max(limit: Date | string | Ref, message?: string | function): Schemaarray.of(type: Schema): thisarray.json(): thisarray.length(length: number | Ref, message?: string | function): thisarray.min(limit: number | Ref, message?: string | function): thisarray.max(limit: number | Ref, message?: string | function): thisarray.ensure(): thisarray.compact(rejector: (value) => boolean): Schemaobject.shape(fields: object, noSortEdges?: Array<[string, string]>): Schemaobject.json(): thisobject.concat(schemaB: ObjectSchema): ObjectSchemaobject.pick(keys: string[]): Schemaobject.omit(keys: string[]): Schemaobject.from(fromKey: string, toKey: string, alias: boolean = false): thisobject.noUnknown(onlyKnownKeys: boolean = true, message?: string | function): Schemaobject.camelCase(): Schemaobject.constantCase(): SchemaLas definiciones de esquemas se componen de "transformaciones" de análisis que manipulan las entradas en la forma y el tipo deseados, "pruebas", que hacen afirmaciones sobre los datos analizados. El esquema también almacena una gran cantidad de "metadatos", detalles sobre el esquema en sí, que se pueden usar para mejorar los mensajes de error, crear herramientas que consuman el esquema dinámicamente o serializar el esquema en otro formato.
Para ser lo más flexible posible, permite ejecutar tanto el análisis como las aserciones por separado para satisfacer necesidades específicas.
Cada tipo integrado implementa un análisis de tipos básico, lo que resulta útil al analizar datos serializados, como JSON. Además, los tipos implementan transformaciones específicas de tipo que se pueden habilitar.
let num = number ( ) . cast ( '1' ) ; // 1
let obj = object ( {
firstName : string ( ) . lowercase ( ) . trim ( ) ,
} )
. json ( )
. camelCase ( )
. cast ( '{"first_name": "jAnE "}' ) ; // { firstName: 'jane' }Se pueden agregar transformaciones personalizadas
let reversedString = string ( )
. transform ( ( currentValue ) => currentValue . split ( '' ) . reverse ( ) . join ( '' ) )
. cast ( 'dlrow olleh' ) ; // "hello world" Las transformaciones forman una "canalización", donde el valor de una transformación anterior se canaliza a la siguiente. Cuando un valor de entrada no está undefined sí se aplicará el esquema predeterminado si está configurado.
¡Cuidado! No se garantiza que los valores sean tipos válidos en funciones de transformación. Es posible que las transformaciones anteriores hayan fallado. Por ejemplo, una transformación numérica puede recibir el valor de entrada,
NaN, o un número.
Sí, el esquema ejecuta "pruebas" sobre los valores de entrada. Las pruebas afirman que los insumos se ajustan a algunos criterios. Las pruebas se diferencian de las transformaciones en que no cambian ni alteran la entrada (o su tipo) y generalmente se reservan para comprobaciones que son difíciles, si no imposibles, de representar en tipos estáticos.
string ( )
. min ( 3 , 'must be at least 3 characters long' )
. email ( 'must be a valid email' )
. validate ( 'no' ) ; // ValidationErrorAl igual que con las transformaciones, las pruebas se pueden personalizar sobre la marcha.
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"Aviso: a diferencia de las transformaciones, se garantiza que
valueen una prueba personalizada sea del tipo correcto (en este caso, una cadena opcional). Aún puede serundefinedonulldependiendo de su esquema; en esos casos, es posible que desee devolvertruepara los valores ausentes a menos que su transformación haga afirmaciones relacionadas con la presencia. La opción de pruebaskipAbsenthará esto por usted si está configurada.
En el caso más simple, una función de prueba devuelve true o false dependiendo de si se aprobó la verificación. En el caso de una prueba fallida, sí arrojará un ValidationError con su mensaje (o el predeterminado) para esa prueba. ValidationErrors también contiene muchos otros metadatos sobre la prueba, incluido su nombre, con qué argumentos (si los hay) se llamó y la ruta al campo fallido en el caso de una validación anidada.
Los mensajes de error también se pueden crear sobre la marcha para personalizar cómo falla el esquema.
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' } )Los esquemas son inmutables, cada llamada al método devuelve un nuevo objeto de esquema. Reutilícelos y páselos sin temor a mutar en otra instancia.
let optionalString = string ( ) . optional ( ) ;
let definedString = optionalString . defined ( ) ;
let value = undefined ;
optionalString . isValid ( value ) ; // true
definedString . isValid ( value ) ; // false Sí, el esquema produce interfaces TypeScript estáticas. Utilice InferType para extraer esa interfaz:
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
} El valor predeterminado de un esquema se utiliza cuando la conversión produce un valor de salida undefined . Debido a esto, establecer un valor predeterminado afecta el tipo de salida del esquema, esencialmente marcándolo como "definido()".
import { string } from 'yup' ;
let value : string = string ( ) . default ( 'hi' ) . validate ( undefined ) ;
// vs
let value : string | undefined = string ( ) . validate ( undefined ) ;En algunos casos, ya existe un tipo de TypeScript y desea asegurarse de que su esquema produzca un tipo compatible:
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 ( ) ,
} ) ; Puede utilizar el comportamiento de fusión de la interfaz de TypeScript para ampliar los tipos de esquema si es necesario. Las extensiones de tipo deben ir en un archivo de definición de tipo "ambiental", como su globals.d.ts . ¡Recuerde extender el tipo yup en el código de su aplicación!
¡Cuidado! la fusión solo funciona si la definición del tipo es exactamente la misma, incluidos los genéricos. Consulte el código fuente de sí para cada tipo para asegurarse de que lo está definiendo correctamente.
// 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~~~~' Debe tener habilitada la opción del compilador strictNullChecks para que funcione la inferencia de tipos.
También recomendamos configurar strictFunctionTypes en false para tipos funcionalmente mejores. Sí, esto reduce la solidez general, sin embargo, TypeScript ya desactiva esta verificación de métodos y constructores (nota de documentos de TS):
Durante el desarrollo de esta característica, descubrimos una gran cantidad de jerarquías de clases inherentemente inseguras, incluidas algunas en el DOM. Debido a esto, la configuración solo se aplica a funciones escritas en sintaxis de función, no a aquellas en sintaxis de método:
Su kilometraje variará, pero hemos descubierto que esta verificación no previene muchos de los errores reales, al tiempo que aumenta la cantidad de conversión de tipos explícita y onerosa en las aplicaciones.
Los mensajes de error predeterminados se pueden personalizar para cuando no se proporciona ningún mensaje con una prueba de validación. Si falta algún mensaje en el diccionario personalizado, el mensaje de error predeterminado será el de Sí.
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']
} Si necesita soporte en varios idiomas, sí lo tiene cubierto. La función setLocale acepta funciones que se pueden usar para generar objetos de error con claves y valores de traducción. Estos pueden introducirse en su biblioteca i18n favorita.
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 ) ) ;
} yupLa exportación del módulo.
// 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 Para esquemas anidados, reach recuperará un esquema interno basado en la ruta proporcionada.
Para esquemas anidados que deben resolverse dinámicamente, puede proporcionar un value y, opcionalmente, un objeto 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 Agrega un nuevo método a los tipos de esquemas principales. Un método conveniente más amigable para 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 ( '' ) ;
} ) ;
} ) ; Si desea agregar un método a TODOS los tipos de esquema, extienda la clase base abstracta: Schema
import { addMethod , Schema } from 'yup' ;
addMethod ( Schema , 'myMethod' , ... ) ref(path: string, options: { contextPrefix: string }): RefCrea una referencia a otro campo hermano o descendiente de hermanos. Las referencias se resuelven en el momento de la validación/cast y se admiten cuando se especifica. Las referencias se evalúan en el orden adecuado para que el valor de la referencia se resuelva antes que el campo que utiliza la referencia (¡tenga cuidado con las dependencias circulares!).
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): LazyCrea un esquema que se evalúa en el momento de la validación/transmisión. Útil para crear esquemas recursivos como árboles, para campos y matrices polimórficos.
¡PRECAUCIÓN! Al definir el esquema de objeto recursivo padre-hijo, desea restablecer el default() a null en el niño; de lo contrario, el objeto se anidará infinitamente cuando lo emita.
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)Lanzado en validaciones fallidas, con las siguientes propiedades
name : "Error de validación"type : el tipo de prueba específico o "nombre" de la prueba que falló.value : el valor del campo que se probó;params ?: Las entradas de prueba, como el valor máximo, expresiones regulares, etc.;path : una cadena que indica dónde se produjo el error. path está vacía en el nivel raíz.errors : conjunto de mensajes de errorinner : en el caso de errores agregados, interno es una matriz de ValidationErrors lanzada anteriormente en la cadena de validación. Cuando la opción abortEarly es false , aquí es donde puede inspeccionar cada error arrojado; alternativamente, errors tendrán todos los mensajes de cada error interno.Schema Schema es la clase base abstracta de la que heredan todos los tipos de esquema. Proporciona una serie de métodos y propiedades básicos para todos los demás tipos de esquemas.
Nota: a menos que esté creando un tipo de esquema personalizado, Schema nunca debe usarse directamente. Para tipos desconocidos o de cualquier tipo, utilice
mixed()
Schema.clone(): SchemaCrea una copia profunda del esquema. La clonación se utiliza internamente para devolver un nuevo esquema con cada cambio de estado del esquema.
Schema.label(label: string): SchemaAnula el nombre de la clave que se utiliza en los mensajes de error.
Schema.meta(metadata: SchemaMetadata): SchemaAgrega a un objeto de metadatos, útil para almacenar datos con un esquema, que no pertenece al objeto de conversión en sí.
Se puede definir una interfaz SchemaMetadata personalizada fusionándola con la interfaz CustomSchemaMetadata . Comience creando un archivo yup.d.ts en su paquete y creando la interfaz CustomSchemaMetadata que desee:
// 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): SchemaDescriptionRecopila detalles del esquema (como meta, etiquetas y pruebas activas) en un objeto de descripción serializable.
let schema = object ( {
name : string ( ) . required ( ) ,
} ) ;
let description = schema . describe ( ) ; Para esquemas con componentes dinámicos (referencias, diferidos o condiciones), la descripción requiere más contexto para devolver con precisión la descripción del esquema. En estos casos proporcionar 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 } } ) ;Y a continuación se muestran los tipos de descripción, que difieren un poco según el tipo de esquema.
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 Crea una nueva instancia del esquema combinando dos esquemas. Sólo se pueden concatenar esquemas del mismo tipo. concat no es una función de "fusión" en el sentido de que todas las configuraciones del esquema proporcionado anulan las de la base, incluido el tipo, la presencia y la capacidad de nulos.
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> Devuelve los análisis y valida un valor de entrada, devolviendo el valor analizado o arrojando un error. Este método es asíncrono y devuelve un objeto Promise, que se cumple con el valor o se rechaza con un ValidationError .
value = await schema . validate ( { name : 'jimmy' , age : 24 } ) ; Proporcionar options para controlar más específicamente el comportamiento de 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> Ejecuta validaciones de forma sincrónica si es posible y devuelve el valor resultante o arroja un ValidationError. Acepta las mismas opciones que validate .
La validación síncrona solo funciona si no hay pruebas asíncronas configuradas, por ejemplo, pruebas que devuelven una Promesa. Por ejemplo, esto funcionará:
let schema = number ( ) . test (
'is-42' ,
"this isn't the number i want" ,
( value ) => value != 42 ,
) ;
schema . validateSync ( 23 ) ; // throws ValidationErrorsin embargo esto no:
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> Valide una ruta profundamente anidada dentro del esquema. Similar a cómo funciona reach , pero utiliza el esquema resultante como tema de validación.
¡Nota! El
valueaquí es el valor raíz relativo al esquema inicial, no el valor en la ruta anidada.
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> Igual que validateAt pero sincrónico.
Schema.isValid(value: any, options?: object): Promise<boolean> Devuelve true cuando el valor pasado coincide con el esquema. isValid es asíncrono y devuelve un objeto Promise.
Toma las mismas opciones que validate() .
Schema.isValidSync(value: any, options?: object): boolean Devuelve true sincrónicamente cuando el valor pasado coincide con el esquema.
Toma las mismas opciones que validateSync() y tiene las mismas advertencias sobre las pruebas asíncronas.
Schema.cast(value: any, options = {}): InferType<Schema> Intenta forzar el valor pasado a un valor que coincida con el esquema. Por ejemplo: '5' se convertirá en 5 cuando se utilice el tipo number() . Las conversiones fallidas generalmente devuelven null , pero también pueden devolver resultados como NaN y cadenas inesperadas.
Proporcionar options para controlar más específicamente el comportamiento de 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> Ejecuta una verificación de tipo contra el value pasado. Devuelve verdadero si coincide, no convierte el valor. Cuando se establece nullable() se considera null un valor válido del tipo. Debe utilizar isType para todas las comprobaciones de tipos de esquema.
Schema.strict(enabled: boolean = false): Schema Establece la opción strict en true . Los esquemas estrictos omiten los intentos de coerción y transformación, validando el valor "tal cual".
Schema.strip(enabled: boolean = true): SchemaMarca un esquema para eliminarlo de un objeto de salida. Solo funciona como esquema anidado.
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
schema . cast ( { notThis : 'foo' , useThis : 4 } ) ; // => { useThis: 4 } Los esquemas con strip habilitado tienen un tipo inferido de never , lo que permite eliminarlos del tipo general:
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
InferType < typeof schema > ; /*
{
useThis?: number | undefined
}
*/ Schema.withMutation(builder: (current: Schema) => void): voidPrimero, la cita de Rich Hickey legalmente requerida:
Si un árbol cae en el bosque, ¿hace algún sonido?
Si una función pura muta algunos datos locales para producir un valor de retorno inmutable, ¿está bien?
withMutation le permite mutar el esquema en su lugar, en lugar del comportamiento predeterminado que clona antes de cada cambio. Generalmente, esto no es necesario ya que la gran mayoría de los cambios en el esquema ocurren durante la declaración inicial y solo ocurren una vez durante la vida útil del esquema, por lo que el rendimiento no es un problema. Sin embargo, ciertas mutaciones ocurren en el momento de la conversión/validación (como el esquema condicional que usa when() ) o al crear una instancia de un objeto de esquema.
object ( )
. shape ( { key : string ( ) } )
. withMutation ( ( schema ) => {
return arrayOfObjectTests . forEach ( ( test ) => {
schema . test ( test ) ;
} ) ;
} ) ; Schema.default(value: any): Schema Establece un valor predeterminado para usar cuando el valor no está undefined . Los valores predeterminados se crean después de ejecutar las transformaciones, pero antes de las validaciones, para ayudar a garantizar que se especifiquen valores predeterminados seguros. El valor predeterminado se clonará en cada uso, lo que puede generar una penalización en el rendimiento de los objetos y matrices. Para evitar esta sobrecarga, también puede pasar una función que devuelva un nuevo valor predeterminado. Tenga en cuenta que null se considera un valor independiente no vacío.
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 Recupera un valor predeterminado previamente establecido. getDefault resolverá cualquier condición que pueda alterar el valor predeterminado. Opcionalmente, pase options con context (para obtener más información sobre context consulte Schema.validate ).
Schema.nullable(message?: string | function): Schema Indica que null es un valor válido para el esquema. Sin nullable() null se trata como un tipo diferente y fallará las comprobaciones Schema.isType() .
let schema = number ( ) . nullable ( ) ;
schema . cast ( null ) ; // null
InferType < typeof schema > ; // number | null Schema.nonNullable(message?: string | function): Schema Lo contrario de nullable , elimina null de los valores de tipo válidos para el esquema. Los esquemas no admiten valores NULL de forma predeterminada .
let schema = number ( ) . nonNullable ( ) ;
schema . cast ( null ) ; // TypeError
InferType < typeof schema > ; // number Schema.defined(): Schema Requerir un valor para el esquema. Todos los valores de campo, excepto undefined cumplen con este requisito.
let schema = string ( ) . defined ( ) ;
schema . cast ( undefined ) ; // TypeError
InferType < typeof schema > ; // string Schema.optional(): Schema Lo opuesto a defined() permite valores undefined para el tipo dado.
let schema = string ( ) . optional ( ) ;
schema . cast ( undefined ) ; // undefined
InferType < typeof schema > ; // string | undefined Schema.required(message?: string | function): Schema Marque el esquema según sea necesario, lo que no permitirá un valor undefined o null . required niega los efectos de llamar optional() y nullable()
¡Cuidado!
string().required) funciona un poco diferente y además evita valores de cadena vacíos ('') cuando es necesario.
Schema.notRequired(): Schema Marque el esquema como no requerido. Este es un atajo para schema.nullable().optional() ;
Schema.typeError(message: string): Schema Defina un mensaje de error para comprobaciones de tipos fallidas. La interpolación ${value} y ${type} se puede utilizar en el argumento message .
Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema : equals Solo permita valores del conjunto de valores. Los valores agregados se eliminan de cualquier valor notOneOf si está presente. La interpolación ${values} se puede utilizar en el argumento message . Si se proporcionan una o más referencias, la interpolación ${resolved} se puede usar en el argumento del mensaje para obtener los valores resueltos que se verificaron en el momento de la validación.
Tenga en cuenta que undefined no falla en este validador, incluso cuando undefined no está incluido en arrayOfValues . Si no desea que undefined sea un valor válido, puede usar 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) No permitir valores de un conjunto de valores. Los valores agregados se eliminan de los valores oneOf si están presentes. La interpolación ${values} se puede utilizar en el argumento message . Si se proporcionan una o más referencias, la interpolación ${resolved} se puede usar en el argumento del mensaje para obtener los valores resueltos que se verificaron en el momento de la validación.
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 Ajuste el esquema según los campos de un hermano o de hijos de hermanos. Puede proporcionar un objeto literal donde la clave is un valor o una función de comparación, then proporcione el esquema verdadero y/o otherwise para la condición de falla.
is condiciones se comparan estrictamente ( === ) si desea utilizar una forma diferente de igualdad, puede proporcionar una función como: is: (value) => value == true .
También puede anteponer propiedades con $ para especificar una propiedad que depende del context pasado por validate() o cast en lugar del valor de entrada.
when las condiciones son aditivas.
then y otherwise se especifican funciones (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 } } ) ;También puede especificar más de una clave dependiente, en cuyo caso cada valor se distribuirá como argumento.
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 ,
} ) ;Alternativamente, puede proporcionar una función que devuelva un esquema, llamado con una matriz de valores para cada clave proporcionada en el esquema actual.
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): SchemaAgrega una función de prueba a la cadena de validación. Las pruebas se ejecutan después de lanzar cualquier objeto. Muchos tipos tienen algunas pruebas integradas, pero puedes crear pruebas personalizadas fácilmente. Para permitir validaciones personalizadas asincrónicas, todas (o ninguna) las pruebas se ejecutan de forma asincrónica. Una consecuencia de esto es que no se puede garantizar el orden de ejecución de la prueba.
Todas las pruebas deben proporcionar un name , un message de error y una función de validación que debe devolver true cuando el value actual es válido y false o un ValidationError en caso contrario. Para hacer que una prueba sea asíncrona, devuelva una promesa que resuelva true o false o un ValidationError .
Para el argumento message , puede proporcionar una cadena que interpolará ciertos valores si se especifica usando la sintaxis ${param} . De forma predeterminada, a todos los mensajes de prueba se les pasa un valor path que es valioso en esquemas anidados.
La función test se llama con el value actual. Para validaciones más avanzadas, puede utilizar la firma alternativa para proporcionar más opciones (ver a continuación):
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 Las funciones de prueba se llaman con un valor de contexto especial, como segundo argumento, que expone algunos metadatos y funciones útiles. Para funciones que no son de flecha, el contexto de prueba también se establece como la función this . Cuidado, si accedes a través de this no funcionará en la función de flecha.
testContext.path : la ruta de la cadena de la validación actualtestContext.schema : el objeto de esquema resuelto contra el que se ejecuta la prueba.testContext.options : el objeto options que valida() o isValid() fue llamado contestContext.parent : en el caso de un esquema anidado, este es el valor del objeto principaltestContext.originalValue : el valor original que se está probandotestContext.createError(Object: { path: String, message: String, params: Object }) : crea y devuelve un error de validación. Útil para configurar dinámicamente la path , params o, más probablemente, el message de error. Si se omite alguna de las opciones, se utilizará la ruta actual o el mensaje predeterminado. Schema.test(options: object): Schema Firma de test(..) . options es un objeto que contiene algunas de las siguientes opciones:
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 ;
}En el caso de mezclar pruebas exclusivas y no exclusivas, se utiliza la siguiente lógica. Si se agrega una prueba no exclusiva a un esquema con una prueba exclusiva del mismo nombre, la prueba exclusiva se elimina y se acumularán más pruebas con el mismo nombre.
Si se agrega una prueba exclusiva a un esquema con pruebas no exclusivas del mismo nombre, las pruebas anteriores se eliminan y las pruebas posteriores con el mismo nombre se reemplazarán entre sí.
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 Agrega una transformación a la cadena de transformación. Las transformaciones son fundamentales para el proceso de conversión; las transformaciones predeterminadas para cada tipo obligan a los valores al tipo específico (como lo verifica isType() ). Las transformaciones se ejecutan antes de las validaciones y solo se aplican cuando el esquema no está marcado como strict (el valor predeterminado). Algunos tipos tienen transformaciones incorporadas.
Las transformaciones son útiles para alterar arbitrariamente cómo se convierte el objeto; sin embargo, debes tener cuidado de no mutar el valor pasado. Las transformaciones se ejecutan secuencialmente, por lo que cada value representa el estado actual de la conversión; puede usar el parámetro originalValue si necesita trabajar en el valor inicial sin formato.
let schema = string ( ) . transform ( ( value , originalValue ) => {
return this . isType ( value ) && value !== null ? value . toUpperCase ( ) : value ;
} ) ;
schema . cast ( 'jimmy' ) ; // => 'JIMMY'Cada tipo manejará la coerción básica de valores al tipo adecuado para usted, pero ocasionalmente es posible que desee ajustar o refinar el comportamiento predeterminado. Por ejemplo, si desea utilizar una estrategia de análisis de fechas diferente a la predeterminada, puede hacerlo con una transformación.
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 ( '' ) ;
} ) ;
} ; Crea un esquema que coincide con todos los tipos, o solo con los que configura. Hereda de Schema . Los tipos mixtos extienden {} de forma predeterminada en lugar de any o unknown . Esto se debe a que en TypeScript {} significa cualquier cosa que no sea null o undefined y que sí se trate de manera distinta.
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 Los tipos personalizados se pueden implementar pasando una función check de tipo. Esto también limitará el tipo de TypeScript para el esquema.
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 Defina un esquema de cadena. Hereda de Schema .
let schema = yup . string ( ) ;
await schema . isValid ( 'hello' ) ; // => true De forma predeterminada, la lógica cast de string es llamar toString en el valor si existe.
los valores vacíos no están obligados (use ensure() para convertir valores vacíos en cadenas vacías).
Las conversiones fallidas devuelven el valor de entrada.
string.required(message?: string | function): Schema Lo mismo que se requiere el esquema mixed() , excepto que las cadenas vacías también se consideran valores "faltantes".
string.length(limit: number | Ref, message?: string | function): Schema Establezca una longitud requerida para el valor de la cadena. La interpolación ${length} se puede utilizar en el argumento message .
string.min(limit: number | Ref, message?: string | function): Schema Establezca un límite de longitud mínimo para el valor de la cadena. La interpolación ${min} se puede utilizar en el argumento message .
string.max(limit: number | Ref, message?: string | function): Schema Establezca un límite de longitud máxima para el valor de la cadena. La interpolación ${max} se puede utilizar en el argumento message .
string.matches(regex: Regex, message?: string | function): Schema Proporcione una regex arbitraria para hacer coincidir el valor.
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 Una firma alternativa para string.matches con un objeto de opciones. excludeEmptyString , cuando es verdadero, cortocircuita la prueba de expresiones regulares cuando el valor es una cadena vacía, lo que hace que sea más fácil evitar que no coincida con nada sin complicar la expresión regular.
let schema = string ( ) . matches ( / (hi|bye) / , { excludeEmptyString : true } ) ;
await schema . isValid ( '' ) ; // => true string.email(message?: string | function): SchemaValida el valor como una dirección de correo electrónico utilizando la misma expresión regular definida por la especificación HTML.
CUIDADO: Validar direcciones de correo electrónico es casi imposible con solo un código. Diferentes clientes y servidores aceptan cosas diferentes y muchos difieren de las distintas especificaciones que definen los correos electrónicos "válidos". La ÚNICA forma real de validar una dirección de correo electrónico es enviarle un correo electrónico de verificación y comprobar que el usuario la recibió. Con eso en mente, yup elige una expresión regular relativamente simple que no cubre todos los casos, pero se alinea con el comportamiento de validación de entradas del navegador, ya que los formularios HTML son un caso de uso común para yup.
Si tiene necesidades más específicas, anule el método de correo electrónico con su propia lógica o expresión regular:
yup . addMethod ( yup . string , 'email' , function validateEmail ( message ) {
return this . matches ( myEmailRegex , {
message ,
name : 'email' ,
excludeEmptyString : true ,
} ) ;
} ) ; string.url(message?: string | function): SchemaValida el valor como una URL válida mediante una expresión regular.
string.uuid(message?: string | function): SchemaValida el valor como un UUID válido mediante una expresión regular.
string.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number}) Valida el valor como fecha y hora ISO mediante una expresión regular. El valor predeterminado es la validación UTC; No se permiten compensaciones de zona horaria (consulte options.allowOffset ).
A diferencia de .date() , datetime no convertirá la cadena en un objeto Date . datetime también proporciona una mayor personalización sobre el formato requerido de la cadena de fecha y hora que date .
options.allowOffset : permite un desplazamiento de zona horaria. Falso requiere la zona horaria UTC 'Z'. (predeterminado: falso) options.precision : requiere una cierta precisión de menos de un segundo en la fecha. (predeterminado: nulo: cualquier (o ninguna) precisión inferior a un segundo)
string.datetime(message?: string | function) Una firma alternativa para string.datetime que se puede usar cuando no necesita pasar opciones distintas a message .
string.ensure(): Schema Transforma valores null y no undefined en una cadena vacía y establece el default en una cadena vacía.
string.trim(message?: string | function): Schema Transforma valores de cadena eliminando espacios en blanco iniciales y finales. Si se establece strict() solo validará que el valor esté recortado.
string.lowercase(message?: string | function): Schema Transforma el valor de la cadena a minúsculas. Si se establece strict() solo validará que el valor esté en minúsculas.
string.uppercase(message?: string | function): Schema Transforma el valor de la cadena a mayúsculas. Si se establece strict() solo validará que el valor esté en mayúsculas.
Defina un esquema numérico. Hereda de Schema .
let schema = yup . number ( ) ;
await schema . isValid ( 10 ) ; // => true La lógica cast predeterminada del number es: parseFloat .
Las conversiones fallidas devuelven NaN .
number.min(limit: number | Ref, message?: string | function): Schema Establezca el valor mínimo permitido. La interpolación ${min} se puede utilizar en el argumento message .
number.max(limit: number | Ref, message?: string | function): Schema Establezca el valor máximo permitido. La interpolación ${max} se puede utilizar en el argumento message .
number.lessThan(max: number | Ref, message?: string | function): Schema El valor debe ser menor que max . La interpolación ${less} se puede utilizar en el argumento message .
number.moreThan(min: number | Ref, message?: string | function): Schema El valor debe ser estrictamente mayor que min . La interpolación ${more} se puede utilizar en el argumento message .
number.positive(message?: string | function): SchemaEl valor debe ser un número positivo.
number.negative(message?: string | function): SchemaEl valor debe ser un número negativo.
number.integer(message?: string | function): SchemaValida que un número sea un número entero.
number.truncate(): SchemaTransformación que convierte el valor en un número entero eliminando los dígitos a la derecha del punto decimal.
number.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schema Ajusta el valor mediante el método Math especificado (el valor predeterminado es "redondear").
Defina un esquema booleano. Hereda de Schema .
let schema = yup . boolean ( ) ;
await schema . isValid ( true ) ; // => true Defina un esquema de fecha. De forma predeterminada, las cadenas de fecha ISO se analizarán correctamente; para obtener opciones de análisis más sólidas, consulte los tipos de esquema extendidos al final del archivo Léame. Hereda de Schema .
let schema = yup . date ( ) ;
await schema . isValid ( new Date ( ) ) ; // => true La lógica cast predeterminada de date es pasar el valor al constructor Date ; de lo contrario, intentará analizar la fecha como una cadena de fecha ISO.
Si desea que las cadenas ISO no se conviertan en un objeto
Date, utilice.datetime()en su lugar.
Las conversiones fallidas devuelven una fecha no válida.
date.min(limit: Date | string | Ref, message?: string | function): SchemaEstablezca la fecha mínima permitida. Cuando se proporciona una cadena, primero intentará convertirla a una fecha y utilizar el resultado como límite.
date.max(limit: Date | string | Ref, message?: string | function): SchemaEstablezca la fecha máxima permitida. Cuando se proporciona una cadena, primero intentará convertirla a una fecha y utilizar el resultado como límite.
Defina un esquema de matriz. Las matrices se pueden escribir o no. Al especificar el tipo de elemento, cast e isValid también se aplicarán a los elementos. Las opciones pasadas a isValid también se pasan a los esquemas secundarios.
Hereda de 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]También puede pasar un esquema de subtipo al constructor de la matriz para su comodidad.
array ( ) . of ( yup . number ( ) ) ;
// or
array ( yup . number ( ) ) ;Las matrices no tienen un comportamiento de conversión predeterminado.
array.of(type: Schema): this Especifique el esquema de los elementos de la matriz. of() es opcional y cuando se omite, el esquema de matriz no validará su contenido.
array.json(): this Intente analizar los valores de la cadena de entrada como JSON utilizando JSON.parse .
array.length(length: number | Ref, message?: string | function): this Establezca un requisito de longitud específico para la matriz. La interpolación ${length} se puede utilizar en el argumento message .
array.min(limit: number | Ref, message?: string | function): this Establezca un límite de longitud mínimo para la matriz. La interpolación ${min} se puede utilizar en el argumento message .
array.max(limit: number | Ref, message?: string | function): this Establezca un límite de longitud máxima para la matriz. La interpolación ${max} se puede utilizar en el argumento message .
array.ensure(): this Garantiza que el valor sea una matriz, estableciendo el valor predeterminado en [] y transformando valores null e undefined en una matriz vacía también. Cualquier valor que no esté vacío ni sea una matriz se incluirá en una matriz.
array ( ) . ensure ( ) . cast ( null ) ; // => []
array ( ) . ensure ( ) . cast ( 1 ) ; // => [1]
array ( ) . ensure ( ) . cast ( [ 1 ] ) ; // => [1] array.compact(rejector: (value) => boolean): SchemaElimina los valores falsos de la matriz. Proporcionar una función de rechazo le permite especificar los criterios de rechazo usted mismo.
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]Las tuplas son matrices de longitud fija donde cada elemento tiene un tipo distinto.
Hereda de 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] | undefinedlas tuplas no tienen un comportamiento de conversión predeterminado.
Definir un esquema de objeto. Las opciones pasadas a isValid también se pasan a los esquemas secundarios. Hereda de Schema .
yup . object ( {
name : string ( ) . required ( ) ,
age : number ( ) . required ( ) . positive ( ) . integer ( ) ,
email : string ( ) . email ( ) ,
website : string ( ) . url ( ) ,
} ) ;El esquema de objeto no tiene aplicada ninguna transformación predeterminada.
El esquema de objeto viene con un valor predeterminado ya establecido, que "construye" la forma del objeto y establece los valores predeterminados para los campos:
let schema = object ( {
name : string ( ) . default ( '' ) ,
} ) ;
schema . default ( ) ; // -> { name: '' }Esto puede resultar un poco sorprendente, pero suele ser útil ya que permite que un esquema anidado grande cree valores predeterminados que llenen toda la forma y no solo el objeto raíz. ¡Hay un problema! aunque. Para esquemas de objetos anidados que son opcionales pero que incluyen campos no opcionales pueden fallar de maneras inesperadas:
let schema = object ( {
id : string ( ) . required ( ) ,
names : object ( {
first : string ( ) . required ( ) ,
} ) ,
} ) ;
schema . isValid ( { id : 1 } ) ; // false! names.first is requiredEsto se debe a que sí lanza el objeto de entrada antes de ejecutar la validación, lo que producirá:
{ id: '1', names: { first: undefined }}
Durante la fase de validación names existen, y se validan, encontrando names.first que falta. Si desea evitar este comportamiento, realice una de las siguientes acciones:
names.default(undefined)names.nullable().default(null) object.shape(fields: object, noSortEdges?: Array<[string, string]>): SchemaDefinir las claves del objeto y los esquemas para dichas claves.
Tenga en cuenta que puede encadenar el método shape , que actúa como Object.assign .
object ( {
a : string ( ) ,
b : number ( ) ,
} ) . shape ( {
b : string ( ) ,
c : number ( ) ,
} ) ;sería exactamente lo mismo que:
object ( {
a : string ( ) ,
b : string ( ) ,
c : number ( ) ,
} ) ; object.json(): this Intente analizar los valores de la cadena de entrada como JSON utilizando JSON.parse .
object.concat(schemaB: ObjectSchema): ObjectSchema Crea un esquema de objeto, aplicando todas las configuraciones y campos del schemaB a la base, produciendo un nuevo esquema. La forma del objeto se fusiona superficialmente con los campos comunes del schemaB que tienen prioridad sobre los campos base.
object.pick(keys: string[]): SchemaCree un nuevo esquema a partir de un subconjunto de los campos del original.
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[]): SchemaCree un nuevo esquema con campos omitidos.
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 Transforma la clave especificada en una nueva clave. Si alias es true , se dejará la clave anterior.
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 Valide que el valor del objeto solo contenga claves especificadas en shape , pase false como primer argumento para deshabilitar la verificación. Restringir las claves a conocidas también habilita la opción stripUnknown , cuando no está en modo estricto.
object.camelCase(): SchemaTransforma todas las claves de objetos a camelCase
object.constantCase(): SchemaTransforma todas las claves de objetos a CONSTANT_CASE.
