yup
v1 Because I finally got around to it
Yup é um construtor de esquema para análise e validação de valor de tempo de execução. Defina um esquema, transforme um valor para corresponder, declare a forma de um valor existente ou ambos. Os esquemas Yup são extremamente expressivos e permitem modelar validações complexas e interdependentes ou transformação de valor.
Você está visualizando documentos para a versão 1.0.0, sim, documentos anteriores à versão 1 estão disponíveis: aqui
Recursos matadores :
O esquema é composto por ações de análise (transformações), bem como asserções (testes) sobre o valor de entrada. Valide um valor de entrada para analisá-lo e execute o conjunto configurado de asserções. Encadeie métodos para construir um 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
}*/Use um esquema para coagir ou "transformar" um valor de entrada no tipo correto e, opcionalmente, transformar esse valor em valores mais concretos e específicos, sem fazer mais afirmações.
// 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 }Você sabe que seu valor de entrada já foi analisado? Você pode validar "estritamente" uma entrada e evitar a sobrecarga da execução da lógica de análise.
// 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(): SchemaAs definições de esquema são compostas de "transformações" de análise que manipulam as entradas na forma e tipo desejado, "testes", que fazem afirmações sobre os dados analisados. O esquema também armazena vários "metadados", detalhes sobre o próprio esquema, que podem ser usados para melhorar mensagens de erro, construir ferramentas que consomem esquema dinamicamente ou serializar o esquema em outro formato.
Para ser o mais flexível possível, o yup permite executar a análise e as asserções separadamente para atender às necessidades específicas
Cada tipo integrado implementa análise de tipo básica, o que é útil ao analisar dados serializados, como JSON. Além disso, os tipos implementam transformações específicas do tipo que podem ser habilitadas.
let num = number ( ) . cast ( '1' ) ; // 1
let obj = object ( {
firstName : string ( ) . lowercase ( ) . trim ( ) ,
} )
. json ( )
. camelCase ( )
. cast ( '{"first_name": "jAnE "}' ) ; // { firstName: 'jane' }Transformações personalizadas podem ser adicionadas
let reversedString = string ( )
. transform ( ( currentValue ) => currentValue . split ( '' ) . reverse ( ) . join ( '' ) )
. cast ( 'dlrow olleh' ) ; // "hello world" As transformações formam um "pipeline", onde o valor de uma transformação anterior é canalizado para a próxima. Quando um valor de entrada é undefined o yup aplicará o esquema padrão se estiver configurado.
Atenção! não há garantia de que os valores sejam tipos válidos em funções de transformação. As transformações anteriores podem ter falhado. Por exemplo, uma transformação numérica pode receber o valor de entrada
NaNou um número.
Sim, o esquema executa "testes" sobre os valores de entrada. Os testes afirmam que as entradas estão em conformidade com alguns critérios. Os testes são distintos das transformações, pois não alteram nem alteram a entrada (ou seu tipo) e geralmente são reservados para verificações que são difíceis, senão impossíveis, de representar em tipos estáticos.
string ( )
. min ( 3 , 'must be at least 3 characters long' )
. email ( 'must be a valid email' )
. validate ( 'no' ) ; // ValidationErrorTal como acontece com as transformações, os testes podem ser personalizados dinamicamente
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"Atenção: ao contrário das transformações,
valueem um teste personalizado tem a garantia de ser do tipo correto (nesse caso, uma string opcional). Ainda pode serundefinedounulldependendo do seu esquema. Nesses casos, você pode querer retornartruepara valores ausentes, a menos que sua transformação faça afirmações relacionadas à presença. A opção de testeskipAbsentfará isso para você, se definida.
No caso mais simples, uma função de teste retorna true ou false dependendo se a verificação foi aprovada. No caso de um teste com falha, sim lançará um ValidationError com sua mensagem (ou o padrão) para esse teste. ValidationErrors também contém vários outros metadados sobre o teste, incluindo seu nome, com quais argumentos (se houver) ele foi chamado e o caminho para o campo com falha no caso de uma validação aninhada.
Mensagens de erro também podem ser construídas dinamicamente para personalizar como o esquema falha.
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' } )Os esquemas são imutáveis, cada chamada de método retorna um novo objeto de esquema. Reutilize e distribua-os sem medo de transformar outra instância.
let optionalString = string ( ) . optional ( ) ;
let definedString = optionalString . defined ( ) ;
let value = undefined ;
optionalString . isValid ( value ) ; // true
definedString . isValid ( value ) ; // false O esquema Sim produz interfaces TypeScript estáticas. Use InferType para extrair essa interface:
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
} O padrão de um esquema é usado quando a conversão produz um valor de saída undefined . Por causa disso, definir um padrão afeta o tipo de saída do esquema, marcando-o essencialmente como "definido ()".
import { string } from 'yup' ;
let value : string = string ( ) . default ( 'hi' ) . validate ( undefined ) ;
// vs
let value : string | undefined = string ( ) . validate ( undefined ) ;Em alguns casos, já existe um tipo TypeScript e você deseja garantir que seu esquema produza um tipo compatível:
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 ( ) ,
} ) ; Você pode usar o comportamento de mesclagem de interface do TypeScript para estender os tipos de esquema, se necessário. As extensões de tipo devem estar em um arquivo de definição de tipo "ambiente", como globals.d.ts . Lembre-se de estender o tipo yup no código do seu aplicativo!
Atenção! a fusão só funciona se a definição do tipo for exatamente a mesma, incluindo genéricos. Consulte o código-fonte yup de cada tipo para garantir que você o está definindo corretamente
// 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~~~~' Você deve ter a opção do compilador strictNullChecks habilitada para que a inferência de tipo funcione.
Também recomendamos configurações strictFunctionTypes para false , para tipos funcionalmente melhores. Sim, isso reduz a integridade geral, no entanto, o TypeScript já desativa essa verificação para métodos e construtores (nota dos documentos do TS):
Durante o desenvolvimento deste recurso, descobrimos um grande número de hierarquias de classes inerentemente inseguras, incluindo algumas no DOM. Por causa disso, a configuração se aplica apenas a funções escritas na sintaxe de função, e não àquelas na sintaxe de método:
Sua milhagem irá variar, mas descobrimos que essa verificação não evita muitos bugs reais, ao mesmo tempo que aumenta a quantidade onerosa de conversão de tipo explícito em aplicativos.
As mensagens de erro padrão podem ser personalizadas quando nenhuma mensagem é fornecida com um teste de validação. Se alguma mensagem estiver faltando no dicionário personalizado, a mensagem de erro será padronizada como a de 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']
} Se você precisar de suporte multilíngue, sim, você terá tudo o que precisa. A função setLocale aceita funções que podem ser utilizadas para gerar objetos de erro com chaves e valores de tradução. Eles podem ser inseridos em sua 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 ) ) ;
} yupA exportação do 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 aninhados, reach recuperará um esquema interno com base no caminho fornecido.
Para esquemas aninhados que precisam ser resolvidos dinamicamente, você pode fornecer um value e, opcionalmente, um 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 Adiciona um novo método aos tipos de esquema principais. Um método de conveniência mais amigável 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 ( '' ) ;
} ) ;
} ) ; Se você deseja adicionar um método a TODOS os tipos de esquema, estenda a classe base abstrata: Schema
import { addMethod , Schema } from 'yup' ;
addMethod ( Schema , 'myMethod' , ... ) ref(path: string, options: { contextPrefix: string }): RefCria uma referência a outro campo irmão ou descendente de irmão. As referências são resolvidas no momento da validação/conversão e suportadas quando especificado. As referências são avaliadas na ordem correta para que o valor da referência seja resolvido antes do campo usando a referência (tenha cuidado com as dependências 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): LazyCria um esquema que é avaliado no momento da validação/conversão. Útil para criar esquemas recursivos como Árvores, para campos e matrizes polimórficos.
CUIDADO! Ao definir o esquema de objeto recursivo pai-filho, você deseja redefinir o default() para null no filho - caso contrário, o objeto se aninhará infinitamente quando você o converter!
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)Lançado em validações com falha, com as seguintes propriedades
name : "Erro de validação"type : o tipo de teste específico ou "nome" do teste que falhou.value : O valor do campo que foi testado;params ?: As entradas de teste, como valor máximo, regex, etc;path : uma string, indicando onde o erro foi gerado. path está vazio no nível raiz.errors : matriz de mensagens de erroinner : no caso de erros agregados, inner é uma matriz de ValidationErrors lançada anteriormente na cadeia de validação. Quando a opção abortEarly é false é aqui que você pode inspecionar cada erro lançado; alternativamente, errors terão todas as mensagens de cada erro interno.Schema Schema é a classe base abstrata da qual todos os tipos de esquema herdam. Ele fornece vários métodos e propriedades básicas para todos os outros tipos de esquema.
Nota: a menos que você esteja criando um tipo de esquema personalizado, Schema nunca deve ser usado diretamente. Para tipos desconhecidos/qualquer tipo, use
mixed()
Schema.clone(): SchemaCria uma cópia profunda do esquema. Clone é usado internamente para retornar um novo esquema a cada mudança de estado do esquema.
Schema.label(label: string): SchemaSubstitui o nome da chave usado em mensagens de erro.
Schema.meta(metadata: SchemaMetadata): SchemaAdiciona a um objeto de metadados, útil para armazenar dados com um esquema, que não pertence ao próprio objeto de conversão.
Uma interface SchemaMetadata customizada pode ser definida por meio da fusão com a interface CustomSchemaMetadata . Comece criando um arquivo yup.d.ts em seu pacote e criando a interface CustomSchemaMetadata desejada:
// 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): SchemaDescriptionColeta detalhes do esquema (como meta, rótulos e testes ativos) em um objeto de descrição serializável.
let schema = object ( {
name : string ( ) . required ( ) ,
} ) ;
let description = schema . describe ( ) ; Para esquema com componentes dinâmicos (referências, preguiçosos ou condições), descrever requer mais contexto para retornar com precisão a descrição do esquema. Nestes casos, forneça 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 } } ) ;E abaixo estão os tipos de descrição, que diferem um pouco dependendo do 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 Cria uma nova instância do esquema combinando dois esquemas. Somente esquemas do mesmo tipo podem ser concatenados. concat não é uma função de "mesclagem" no sentido de que todas as configurações do esquema fornecido substituem as da base, incluindo tipo, presença e nulidade.
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> Retorna as análises e valida um valor de entrada, retornando o valor analisado ou gerando um erro. Este método é assíncrono e retorna um objeto Promise, que é cumprido com o valor ou rejeitado com ValidationError .
value = await schema . validate ( { name : 'jimmy' , age : 24 } ) ; Forneça options para controlar mais especificamente o comportamento 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> Executa validações de forma síncrona, se possível , e retorna o valor resultante ou lança um ValidationError. Aceita todas as mesmas opções de validate .
A validação síncrona só funciona se não houver testes assíncronos configurados, por exemplo, testes que retornam uma Promise. Por exemplo, isso funcionará:
let schema = number ( ) . test (
'is-42' ,
"this isn't the number i want" ,
( value ) => value != 42 ,
) ;
schema . validateSync ( 23 ) ; // throws ValidationErrorno entanto, isso não irá:
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 um caminho profundamente aninhado no esquema. Semelhante ao funcionamento reach , mas usa o esquema resultante como assunto para validação.
Observação! O
valueaqui é o valor raiz relativo ao esquema inicial, não o valor no caminho aninhado.
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> O mesmo que validateAt mas síncrono.
Schema.isValid(value: any, options?: object): Promise<boolean> Retorna true quando o valor passado corresponde ao esquema. isValid é assíncrono e retorna um objeto Promise.
Toma as mesmas opções que validate() .
Schema.isValidSync(value: any, options?: object): boolean Retorna sincronizadamente true quando o valor passado corresponde ao esquema.
Toma as mesmas opções que validateSync() e tem as mesmas advertências em relação aos testes assíncronos.
Schema.cast(value: any, options = {}): InferType<Schema> Tenta forçar o valor transmitido a um valor que corresponda ao esquema. Por exemplo: '5' será convertido em 5 ao usar o tipo number() . As conversões com falha geralmente retornam null , mas também podem retornar resultados como NaN e strings inesperadas.
Forneça options para controlar mais especificamente o comportamento 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> Executa uma verificação de tipo em relação ao value passado. Retorna verdadeiro se corresponder, não converte o valor. Quando nullable() é definido, null é considerado um valor válido do tipo. Você deve usar isType para todas as verificações de tipo de esquema.
Schema.strict(enabled: boolean = false): Schema Define a opção strict como true . Esquemas estritos ignoram tentativas de coerção e transformação, validando o valor "como está".
Schema.strip(enabled: boolean = true): SchemaMarca um esquema a ser removido de um objeto de saída. Funciona apenas como um esquema aninhado.
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
schema . cast ( { notThis : 'foo' , useThis : 4 } ) ; // => { useThis: 4 } O esquema com strip enabled possui um tipo inferido de never , permitindo que sejam removidos do tipo geral:
let schema = object ( {
useThis : number ( ) ,
notThis : string ( ) . strip ( ) ,
} ) ;
InferType < typeof schema > ; /*
{
useThis?: number | undefined
}
*/ Schema.withMutation(builder: (current: Schema) => void): voidPrimeiro, a citação de Rich Hickey legalmente exigida:
Se uma árvore cai na floresta, ela faz barulho?
Se uma função pura altera alguns dados locais para produzir um valor de retorno imutável, tudo bem?
withMutation permite que você altere o esquema em vigor, em vez do comportamento padrão que é clonado antes de cada alteração. Geralmente isso não é necessário, pois a grande maioria das alterações de esquema ocorre durante a declaração inicial e ocorre apenas uma vez durante a vida útil do esquema, portanto, o desempenho não é um problema. No entanto, certas mutações ocorrem no momento da conversão/validação (como esquema condicional usando when() ) ou ao instanciar um objeto de esquema.
object ( )
. shape ( { key : string ( ) } )
. withMutation ( ( schema ) => {
return arrayOfObjectTests . forEach ( ( test ) => {
schema . test ( test ) ;
} ) ;
} ) ; Schema.default(value: any): Schema Define um valor padrão a ser usado quando o valor for undefined . Os padrões são criados após a execução das transformações, mas antes das validações, para ajudar a garantir que os padrões seguros sejam especificados. O valor padrão será clonado a cada uso, o que pode incorrer em penalidades de desempenho para objetos e matrizes. Para evitar essa sobrecarga você também pode passar uma função que retorne um novo padrão. Observe que null é considerado um valor separado e não vazio.
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 Recuperar um valor padrão definido anteriormente. getDefault resolverá quaisquer condições que possam alterar o padrão. Opcionalmente, passe options com context (para obter mais informações sobre context consulte Schema.validate ).
Schema.nullable(message?: string | function): Schema Indica que null é um valor válido para o esquema. Sem nullable() null é tratado como um tipo diferente e falhará nas verificações Schema.isType() .
let schema = number ( ) . nullable ( ) ;
schema . cast ( null ) ; // null
InferType < typeof schema > ; // number | null Schema.nonNullable(message?: string | function): Schema O oposto de nullable , remove null dos valores de tipo válidos para o esquema. Os esquemas não são anuláveis por padrão .
let schema = number ( ) . nonNullable ( ) ;
schema . cast ( null ) ; // TypeError
InferType < typeof schema > ; // number Schema.defined(): Schema Exija um valor para o esquema. Todos os valores de campo, exceto undefined atendem a esse requisito.
let schema = string ( ) . defined ( ) ;
schema . cast ( undefined ) ; // TypeError
InferType < typeof schema > ; // string Schema.optional(): Schema O oposto de defined() permite valores undefined para um determinado tipo.
let schema = string ( ) . optional ( ) ;
schema . cast ( undefined ) ; // undefined
InferType < typeof schema > ; // string | undefined Schema.required(message?: string | function): Schema Marque o esquema como obrigatório, o que não permitirá undefined ou null como valor. required nega os efeitos de chamar optional() e nullable()
Atenção!
string().required) funciona de maneira um pouco diferente e, adicionalmente, evita valores de string vazios ('') quando necessário.
Schema.notRequired(): Schema Marque o esquema como não obrigatório. Este é um atalho para schema.nullable().optional() ;
Schema.typeError(message: string): Schema Defina uma mensagem de erro para verificações de tipo com falha. A interpolação ${value} e ${type} pode ser usada no argumento message .
Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema Alias: equals Permitir apenas valores do conjunto de valores. Os valores adicionados são removidos de quaisquer valores notOneOf , se presentes. A interpolação ${values} pode ser usada no argumento message . Se uma referência ou refs forem fornecidas, a interpolação ${resolved} poderá ser usada no argumento da mensagem para obter os valores resolvidos que foram verificados no momento da validação.
Observe que undefined não falha neste validador, mesmo quando undefined não está incluído em arrayOfValues . Se não quiser que undefined seja um valor válido, você pode 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) Proibir valores de um conjunto de valores. Os valores adicionados são removidos dos valores oneOf se presentes. A interpolação ${values} pode ser usada no argumento message . Se uma referência ou refs forem fornecidas, a interpolação ${resolved} poderá ser usada no argumento da mensagem para obter os valores resolvidos que foram verificados no momento da validação.
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 o esquema com base nos campos irmão ou filho irmão. Você pode fornecer um objeto literal onde a chave is um valor ou uma função de correspondência e, then fornece o esquema verdadeiro e/ou otherwise para a condição de falha.
is condições são estritamente comparadas ( === ). Se você quiser usar uma forma diferente de igualdade, poderá fornecer uma função como: is: (value) => value == true .
Você também pode prefixar propriedades com $ para especificar uma propriedade que depende do context passado por validate() ou cast em vez do valor de entrada.
when as condições são aditivas.
then e otherwise são funções especificadas (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 } } ) ;Você também pode especificar mais de uma chave dependente; nesse caso, cada valor será distribuído como um 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, você pode fornecer uma função que retorne um esquema, chamado com uma matriz de valores para cada chave fornecida no esquema atual.
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): SchemaAdiciona uma função de teste à cadeia de validação. Os testes são executados após a conversão de qualquer objeto. Muitos tipos possuem alguns testes integrados, mas você pode criar testes personalizados facilmente. Para permitir validações personalizadas assíncronas, todos (ou nenhum) testes são executados de forma assíncrona. Uma consequência disso é que a ordem de execução do teste não pode ser garantida.
Todos os testes devem fornecer um name , uma message de erro e uma função de validação que deve retornar true quando o value atual for válido e false ou ValidationError caso contrário. Para fazer um teste assíncrono retornar uma promessa que resolva true ou false ou um ValidationError .
Para o argumento message você pode fornecer uma string que irá interpolar certos valores se especificado usando a sintaxe ${param} . Por padrão, todas as mensagens de teste recebem um valor path que é valioso em esquemas aninhados.
A função test é chamada com o value atual. Para validações mais avançadas você pode usar a assinatura alternativa para fornecer mais opções (veja abaixo):
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 As funções de teste são chamadas com um valor de contexto especial, como segundo argumento, que expõe alguns metadados e funções úteis. Para funções que não sejam de seta, o contexto de teste também é definido como a função this . Cuidado, se você acessá-lo por meio this não funcionará na função de seta.
testContext.path : o caminho da string da validação atualtestContext.schema : o objeto de esquema resolvido no qual o teste está sendo executado.testContext.options : o objeto options com o qual validar() ou isValid() foi chamadotestContext.parent : no caso de esquema aninhado, este é o valor do objeto paitestContext.originalValue : o valor original que está sendo testadotestContext.createError(Object: { path: String, message: String, params: Object }) : cria e retorna um erro de validação. Útil para definir dinamicamente o path , params ou, mais provavelmente, a message de erro. Se alguma das opções for omitida, será usado o caminho atual ou a mensagem padrão. Schema.test(options: object): Schema Assinatura de test(..) . options é um objeto que contém algumas das seguintes opções:
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 ;
}No caso de misturar testes exclusivos e não exclusivos, a seguinte lógica é usada. Se um teste não exclusivo for adicionado a um esquema com um teste exclusivo de mesmo nome, o teste exclusivo será removido e outros testes de mesmo nome serão empilhados.
Se um teste exclusivo for adicionado a um esquema com testes não exclusivos com o mesmo nome, os testes anteriores serão removidos e outros testes com o mesmo nome substituirão uns aos outros.
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 Adiciona uma transformação à cadeia de transformação. As transformações são fundamentais para o processo de conversão, as transformações padrão para cada tipo forçam os valores para o tipo específico (conforme verificado por isType() ). as transformações são executadas antes das validações e aplicadas somente quando o esquema não está marcado como strict (o padrão). Alguns tipos possuem transformações integradas.
As transformações são úteis para alterar arbitrariamente a forma como o objeto é convertido; no entanto, você deve tomar cuidado para não alterar o valor passado. As transformações são executadas sequencialmente para que cada value represente o estado atual da conversão. Você pode usar o parâmetro originalValue se precisar trabalhar no valor inicial bruto.
let schema = string ( ) . transform ( ( value , originalValue ) => {
return this . isType ( value ) && value !== null ? value . toUpperCase ( ) : value ;
} ) ;
schema . cast ( 'jimmy' ) ; // => 'JIMMY'Cada tipo lidará com a coerção básica de valores para o tipo adequado para você, mas ocasionalmente você pode querer ajustar ou refinar o comportamento padrão. Por exemplo, se você quiser usar uma estratégia de análise de data diferente da padrão, poderá fazer isso com uma transformação.
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 ( '' ) ;
} ) ;
} ; Cria um esquema que corresponde a todos os tipos ou apenas aos que você configura. Herda do Schema . Os tipos mistos estendem {} por padrão em vez de any ou unknown . Isso ocorre porque no TypeScript {} significa qualquer coisa que não seja null ou undefined e que yup trate distintamente.
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 Tipos personalizados podem ser implementados passando uma função check de tipo. Isso também restringirá o tipo TypeScript do 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 um esquema de string. Herda do Schema .
let schema = yup . string ( ) ;
await schema . isValid ( 'hello' ) ; // => true Por padrão, a lógica cast de string é chamar toString no valor, se ele existir.
valores vazios não são forçados (use ensure() para forçar valores vazios a strings vazias).
As conversões com falha retornam o valor de entrada.
string.required(message?: string | function): Schema O mesmo que o esquema mixed() requerido, exceto que strings vazias também são consideradas valores “ausentes”.
string.length(limit: number | Ref, message?: string | function): Schema Defina um comprimento necessário para o valor da string. A interpolação ${length} pode ser usada no argumento message
string.min(limit: number | Ref, message?: string | function): Schema Defina um limite mínimo de comprimento para o valor da string. A interpolação ${min} pode ser usada no argumento message
string.max(limit: number | Ref, message?: string | function): Schema Defina um limite máximo de comprimento para o valor da string. A interpolação ${max} pode ser usada no argumento message
string.matches(regex: Regex, message?: string | function): Schema Forneça um regex arbitrário para corresponder ao 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 Uma assinatura alternativa para string.matches com um objeto de opções. excludeEmptyString , quando verdadeiro, causa curto-circuito no teste de regex quando o valor é uma string vazia, tornando mais fácil evitar a correspondência de nada sem complicar o regex.
let schema = string ( ) . matches ( / (hi|bye) / , { excludeEmptyString : true } ) ;
await schema . isValid ( '' ) ; // => true string.email(message?: string | function): SchemaValida o valor como um endereço de e-mail usando o mesmo regex definido pela especificação HTML.
CUIDADO: Validar endereços de e-mail é quase impossível apenas com código. Diferentes clientes e servidores aceitam coisas diferentes e muitos divergem das várias especificações que definem e-mails “válidos”. A ÚNICA maneira real de validar um endereço de e-mail é enviar um e-mail de verificação para ele e verificar se o usuário o recebeu. Com isso em mente, yup escolhe um regex relativamente simples que não cobre todos os casos, mas se alinha ao comportamento de validação de entrada do navegador, já que os formulários HTML são um caso de uso comum para yup.
Se você tiver necessidades mais específicas, substitua o método email por sua própria lógica ou regex:
yup . addMethod ( yup . string , 'email' , function validateEmail ( message ) {
return this . matches ( myEmailRegex , {
message ,
name : 'email' ,
excludeEmptyString : true ,
} ) ;
} ) ; string.url(message?: string | function): SchemaValida o valor como um URL válido por meio de uma regex.
string.uuid(message?: string | function): SchemaValida o valor como um UUID válido por meio de uma regex.
string.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number}) Valida o valor como uma data e hora ISO por meio de um regex. O padrão é validação UTC; compensações de fuso horário não são permitidas (consulte options.allowOffset ).
Ao contrário de .date() , datetime não converterá a string em um objeto Date . datetime também fornece maior personalização sobre o formato necessário da string datetime do que date .
options.allowOffset : permite um deslocamento de fuso horário. False requer fuso horário UTC 'Z'. (padrão: false) options.precision : Requer uma certa precisão de menos de um segundo na data. (padrão: null -- qualquer (ou nenhuma) precisão de subsegundo)
string.datetime(message?: string | function) Uma assinatura alternativa para string.datetime que pode ser usada quando você não precisa passar outras opções além de message .
string.ensure(): Schema Transforma valores undefined e null em uma string vazia junto com a definição do default para uma string vazia.
string.trim(message?: string | function): Schema Transforma valores de string removendo espaços em branco iniciais e finais. Se strict() for definido, apenas validará que o valor foi cortado.
string.lowercase(message?: string | function): Schema Transforma o valor da string em minúsculas. Se strict() for definido, apenas validará que o valor está em letras minúsculas.
string.uppercase(message?: string | function): Schema Transforma o valor da string em letras maiúsculas. Se strict() for definido, apenas validará se o valor está em letras maiúsculas.
Defina um esquema numérico. Herda do Schema .
let schema = yup . number ( ) ;
await schema . isValid ( 10 ) ; // => true A lógica cast padrão de number é: parseFloat .
Conjurações com falha retornam NaN .
number.min(limit: number | Ref, message?: string | function): Schema Defina o valor mínimo permitido. A interpolação ${min} pode ser usada no argumento message .
number.max(limit: number | Ref, message?: string | function): Schema Defina o valor máximo permitido. A interpolação ${max} pode ser usada no argumento message .
number.lessThan(max: number | Ref, message?: string | function): Schema O valor deve ser menor que max . A interpolação ${less} pode ser usada no argumento message .
number.moreThan(min: number | Ref, message?: string | function): Schema O valor deve ser estritamente maior que min . A interpolação ${more} pode ser usada no argumento message .
number.positive(message?: string | function): SchemaO valor deve ser um número positivo.
number.negative(message?: string | function): SchemaO valor deve ser um número negativo.
number.integer(message?: string | function): SchemaValida que um número é um número inteiro.
number.truncate(): SchemaTransformação que converte o valor em um número inteiro removendo os dígitos à direita da vírgula decimal.
number.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schema Ajusta o valor através do método especificado de Math (o padrão é 'arredondar').
Defina um esquema booleano. Herda do Schema .
let schema = yup . boolean ( ) ;
await schema . isValid ( true ) ; // => true Defina um esquema de data. Por padrão, as strings de data ISO serão analisadas corretamente. Para opções de análise mais robustas, consulte os tipos de esquema estendidos no final do leia-me. Herda do Schema .
let schema = yup . date ( ) ;
await schema . isValid ( new Date ( ) ) ; // => true A lógica cast padrão de date é passar o valor para o construtor Date ; caso contrário, ele tentará analisar a data como uma string de data ISO.
Se você quiser que as strings ISO não sejam convertidas em um objeto
Date, use.datetime().
As conversões com falha retornam uma data inválida.
date.min(limit: Date | string | Ref, message?: string | function): SchemaDefina a data mínima permitida. Quando uma string é fornecida, ela tentará primeiro converter para uma data e usar o resultado como limite.
date.max(limit: Date | string | Ref, message?: string | function): SchemaDefina a data máxima permitida. Quando uma string é fornecida, ela tentará converter primeiro para uma data e usará o resultado como limite.
Defina um esquema de matriz. Os arrays podem ser digitados ou não. Ao especificar o tipo de elemento, cast e isValid também serão aplicados aos elementos. As opções passadas para isValid também são passadas para esquemas filhos.
Herda do 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]Você também pode passar um esquema de subtipo para o construtor do array por conveniência.
array ( ) . of ( yup . number ( ) ) ;
// or
array ( yup . number ( ) ) ;Matrizes não têm comportamento de conversão padrão.
array.of(type: Schema): this Especifique o esquema dos elementos da matriz. of() é opcional e quando omitido o esquema do array não validará seu conteúdo.
array.json(): this Tente analisar valores de string de entrada como JSON usando JSON.parse .
array.length(length: number | Ref, message?: string | function): this Defina um requisito de comprimento específico para a matriz. A interpolação ${length} pode ser usada no argumento message .
array.min(limit: number | Ref, message?: string | function): this Defina um limite mínimo de comprimento para a matriz. A interpolação ${min} pode ser usada no argumento message .
array.max(limit: number | Ref, message?: string | function): this Defina um limite máximo de comprimento para a matriz. A interpolação ${max} pode ser usada no argumento message .
array.ensure(): this Garante que o valor seja uma matriz, definindo o padrão como [] e transformando também valores null e undefined em uma matriz vazia. Qualquer valor não vazio e que não seja de matriz será agrupado em uma matriz.
array ( ) . ensure ( ) . cast ( null ) ; // => []
array ( ) . ensure ( ) . cast ( 1 ) ; // => [1]
array ( ) . ensure ( ) . cast ( [ 1 ] ) ; // => [1] array.compact(rejector: (value) => boolean): SchemaRemove valores falsos da matriz. Fornecer uma função de rejeitador permite que você mesmo especifique os critérios de rejeição.
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]Tuplas são matrizes de comprimento fixo onde cada item possui um tipo distinto.
Herda do 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] | undefinedtuplas não têm comportamento de conversão padrão.
Defina um esquema de objeto. As opções passadas para isValid também são passadas para esquemas filhos. Herda do Schema .
yup . object ( {
name : string ( ) . required ( ) ,
age : number ( ) . required ( ) . positive ( ) . integer ( ) ,
email : string ( ) . email ( ) ,
website : string ( ) . url ( ) ,
} ) ;o esquema do objeto não tem nenhuma transformação padrão aplicada.
O esquema do objeto vem com um valor padrão já definido, que "constrói" a forma do objeto e define quaisquer padrões para os campos:
let schema = object ( {
name : string ( ) . default ( '' ) ,
} ) ;
schema . default ( ) ; // -> { name: '' }Isso pode ser um pouco surpreendente, mas geralmente é útil, pois permite que esquemas grandes e aninhados criem valores padrão que preencham toda a forma e não apenas o objeto raiz. Há uma pegadinha! no entanto. Para esquemas de objetos aninhados que são opcionais, mas incluem campos não opcionais, podem falhar de maneiras inesperadas:
let schema = object ( {
id : string ( ) . required ( ) ,
names : object ( {
first : string ( ) . required ( ) ,
} ) ,
} ) ;
schema . isValid ( { id : 1 } ) ; // false! names.first is requiredIsso ocorre porque yup lança o objeto de entrada antes de executar a validação que produzirá:
{ id: '1', names: { first: undefined }}
Durante a fase de validação names existem e são validados, encontrando-se names.first ausentes. Se você deseja evitar esse comportamento, siga um destes procedimentos:
names.default(undefined)names.nullable().default(null) object.shape(fields: object, noSortEdges?: Array<[string, string]>): SchemaDefina as chaves do objeto e os esquemas dessas chaves.
Observe que você pode encadear o método shape , que atua como Object.assign .
object ( {
a : string ( ) ,
b : number ( ) ,
} ) . shape ( {
b : string ( ) ,
c : number ( ) ,
} ) ;seria exatamente igual a:
object ( {
a : string ( ) ,
b : string ( ) ,
c : number ( ) ,
} ) ; object.json(): this Tente analisar valores de string de entrada como JSON usando JSON.parse .
object.concat(schemaB: ObjectSchema): ObjectSchema Cria um esquema de objeto, aplicando todas as configurações e campos do schemaB à base, produzindo um novo esquema. A forma do objeto é mesclada superficialmente com os campos comuns do schemaB tendo precedência sobre os campos base.
object.pick(keys: string[]): SchemaCrie um novo esquema a partir de um subconjunto dos campos do 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[]): SchemaCrie um novo esquema com 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 a chave especificada em uma nova chave. Se alias for true , a chave antiga será deixada.
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 se o valor do objeto contém apenas chaves especificadas em shape , passe false como primeiro argumento para desabilitar a verificação. Restringir chaves a conhecidas também habilita a opção stripUnknown , quando não estiver no modo estrito.
object.camelCase(): SchemaTransforma todas as chaves de objeto em camelCase
object.constantCase(): SchemaTransforma todas as chaves de objeto em CONSTANT_CASE.
