yup 다운로드 - yup 소스코드 다운로드

예

그렇습니다. 런타임 값 구문 분석 및 유효성 검사를 위한 스키마 빌더입니다. 스키마를 정의하고, 일치하도록 값을 변환하고, 기존 값의 형태를 확인하거나 둘 다를 수행합니다. 예, 스키마는 표현력이 매우 뛰어나며 복잡하고 상호 의존적인 검증 또는 가치 변환을 모델링할 수 있습니다.

당신은 v1.0.0에 대한 문서를 보고 있습니다. v1 이전 문서는 여기에서 볼 수 있습니다.

킬러 기능 :

단순하면서도 복잡한 데이터 모델을 모델링할 수 있는 간결하면서도 표현력이 풍부한 스키마 인터페이스
강력한 TypeScript 지원. 스키마에서 정적 유형을 추론하거나 스키마가 유형을 올바르게 구현하는지 확인하세요.
내장된 비동기 검증 지원. 서버측 및 클라이언트측 검증을 동일하게 모델링합니다.
확장 가능: 자신만의 유형 안전 메서드 및 스키마 추가
풍부한 오류 세부정보로 디버깅이 쉬워집니다.

시작하기

스키마는 구문 분석 작업(변환)과 입력 값에 대한 어설션(테스트)으로 구성됩니다. 입력 값을 검증하여 구문 분석하고 구성된 어설션 세트를 실행합니다. 스키마를 구축하는 방법을 함께 연결합니다.

 import { object , string , number , date , InferType } from 'yup' ;

let userSchema = object ( {
  name : string ( ) . required ( ) ,
  age : number ( ) . required ( ) . positive ( ) . integer ( ) ,
  email : string ( ) . email ( ) ,
  website : string ( ) . url ( ) . nullable ( ) ,
  createdOn : date ( ) . default ( ( ) => new Date ( ) ) ,
} ) ;

// parse and assert validity
let user = await userSchema . validate ( await fetchUser ( ) ) ;

type User = InferType < typeof userSchema > ;
/* {
  name: string;
  age: number;
  email?: string | undefined
  website?: string | null | undefined
  createdOn: Date
}*/

스키마를 사용하여 입력 값을 올바른 유형으로 강제 변환하거나 "캐스트"하고 선택적으로 추가 어설션 없이 해당 값을 보다 구체적이고 구체적인 값으로 변환할 수 있습니다.

 // Attempts to coerce values to the correct type
let parsedUser = userSchema . cast ( {
  name : 'jimmy' ,
  age : '24' ,
  createdOn : '2014-09-23T19:25:25Z' ,
} ) ;
// ✅  { name: 'jimmy', age: 24, createdOn: Date }

입력 값이 이미 구문 분석되었음을 알고 계십니까? 입력의 유효성을 "엄격하게" 확인하고 구문 분석 논리 실행에 따른 오버헤드를 피할 수 있습니다.

 //   ValidationError "age is not a number"
let parsedUser = await userSchema . validate (
  {
    name : 'jimmy' ,
    age : '24' ,
  } ,
  { strict : true } ,
) ;

스키마 기본 사항
- 구문 분석: 변환
- 검증: 테스트
  - 오류 맞춤설정
- 구성 및 재사용
타입스크립트 통합
- 스키마 기본값
- 스키마가 기존 유형과 일치하는지 확인
- 새로운 방법으로 내장 스키마 확장
- 타입스크립트 구성
오류 메시지 사용자 정의
- 현지화 및 i18n
API
- yup
  - reach(schema: Schema, path: string, value?: object, context?: object): Schema
  - addMethod(schemaType: Schema, name: string, method: ()=> Schema): void
  - ref(path: string, options: { contextPrefix: string }): Ref
  - lazy((value: any) => Schema): Lazy
  - ValidationError(errors: string | Array<string>, value: any, path: string)
- Schema
  - Schema.clone(): Schema
  - Schema.label(label: string): Schema
  - Schema.meta(metadata: SchemaMetadata): Schema
  - Schema.describe(options?: ResolveOptions): SchemaDescription
  - Schema.concat(schema: Schema): Schema
  - Schema.validate(value: any, options?: object): Promise<InferType<Schema>, ValidationError>
  - Schema.validateSync(value: any, options?: object): InferType<Schema>
  - Schema.validateAt(path: string, value: any, options?: object): Promise<InferType<Schema>, ValidationError>
  - Schema.validateSyncAt(path: string, value: any, options?: object): InferType<Schema>
  - Schema.isValid(value: any, options?: object): Promise<boolean>
  - Schema.isValidSync(value: any, options?: object): boolean
  - Schema.cast(value: any, options = {}): InferType<Schema>
  - Schema.isType(value: any): value is InferType<Schema>
  - Schema.strict(enabled: boolean = false): Schema
  - Schema.strip(enabled: boolean = true): Schema
  - Schema.withMutation(builder: (current: Schema) => void): void
  - Schema.default(value: any): Schema
  - Schema.getDefault(options?: object): Any
  - Schema.nullable(message?: string | function): Schema
  - Schema.nonNullable(message?: string | function): Schema
  - Schema.defined(): Schema
  - Schema.optional(): Schema
  - Schema.required(message?: string | function): Schema
  - Schema.notRequired(): Schema
  - Schema.typeError(message: string): Schema
  - Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema 별칭: equals
  - Schema.notOneOf(arrayOfValues: Array<any>, message?: string | function)
  - Schema.when(keys: string | string[], builder: object | (values: any[], schema) => Schema): Schema
  - Schema.test(name: string, message: string | function | any, test: function): Schema
  - Schema.test(options: object): Schema
  - Schema.transform((currentValue: any, originalValue: any) => any): Schema
- 혼합된
- 끈
  - string.required(message?: string | function): Schema
  - string.length(limit: number | Ref, message?: string | function): Schema
  - string.min(limit: number | Ref, message?: string | function): Schema
  - string.max(limit: number | Ref, message?: string | function): Schema
  - string.matches(regex: Regex, message?: string | function): Schema
  - string.matches(regex: Regex, options: { message: string, excludeEmptyString: bool }): Schema
  - string.email(message?: string | function): Schema
  - string.url(message?: string | function): Schema
  - string.uuid(message?: string | function): Schema
  - string.datetime(options?: {message?: string | function, allowOffset?: boolean, precision?: number})
  - string.datetime(message?: string | function)
  - string.ensure(): Schema
  - string.trim(message?: string | function): Schema
  - string.lowercase(message?: string | function): Schema
  - string.uppercase(message?: string | function): Schema
- 숫자
  - number.min(limit: number | Ref, message?: string | function): Schema
  - number.max(limit: number | Ref, message?: string | function): Schema
  - number.lessThan(max: number | Ref, message?: string | function): Schema
  - number.moreThan(min: number | Ref, message?: string | function): Schema
  - number.positive(message?: string | function): Schema
  - number.negative(message?: string | function): Schema
  - number.integer(message?: string | function): Schema
  - number.truncate(): Schema
  - number.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schema
- 부울
- 날짜
  - date.min(limit: Date | string | Ref, message?: string | function): Schema
  - date.max(limit: Date | string | Ref, message?: string | function): Schema
- 정렬
  - array.of(type: Schema): this
  - array.json(): this
  - array.length(length: number | Ref, message?: string | function): this
  - array.min(limit: number | Ref, message?: string | function): this
  - array.max(limit: number | Ref, message?: string | function): this
  - array.ensure(): this
  - array.compact(rejector: (value) => boolean): Schema
- 튜플
- 물체
  - 객체 스키마 기본값
  - object.shape(fields: object, noSortEdges?: Array<[string, string]>): Schema
  - object.json(): this
  - object.concat(schemaB: ObjectSchema): ObjectSchema
  - object.pick(keys: string[]): Schema
  - object.omit(keys: string[]): Schema
  - object.from(fromKey: string, toKey: string, alias: boolean = false): this
  - object.noUnknown(onlyKnownKeys: boolean = true, message?: string | function): Schema
  - object.camelCase(): Schema
  - object.constantCase(): Schema

스키마 기본 사항

스키마 정의는 입력을 원하는 모양과 유형으로 조작하는 구문 분석 "변환"과 구문 분석된 데이터에 대해 어설션을 수행하는 "테스트"로 구성됩니다. 스키마는 또한 오류 메시지를 개선하고, 스키마를 동적으로 사용하는 도구를 구축하거나, 스키마를 다른 형식으로 직렬화하는 데 사용할 수 있는 "메타데이터", 즉 스키마 자체에 대한 세부 정보를 저장합니다.

최대한 유연하게 하기 위해 특정 요구 사항에 맞게 구문 분석과 어설션을 별도로 실행할 수 있습니다.

구문 분석: 변환

각 내장 유형은 JSON과 같은 직렬화된 데이터를 구문 분석할 때 유용한 기본 유형 구문 분석을 구현합니다. 또한 유형은 활성화할 수 있는 유형별 변환을 구현합니다.

 let num = number ( ) . cast ( '1' ) ; // 1

let obj = object ( {
  firstName : string ( ) . lowercase ( ) . trim ( ) ,
} )
  . json ( )
  . camelCase ( )
  . cast ( '{"first_name": "jAnE "}' ) ; // { firstName: 'jane' }

사용자 정의 변환을 추가할 수 있습니다.

 let reversedString = string ( )
  . transform ( ( currentValue ) => currentValue . split ( '' ) . reverse ( ) . join ( '' ) )
  . cast ( 'dlrow olleh' ) ; // "hello world"

변환은 이전 변환의 값이 다음 변환으로 파이프되는 "파이프라인"을 형성합니다. 입력 값이 undefined 경우 구성된 경우 스키마 기본값이 적용됩니다.

조심하세요! 변환 함수에서는 값이 유효한 유형이라고 보장되지 않습니다. 이전 변환이 실패했을 수 있습니다. 예를 들어 숫자 변환은 입력 값 NaN 또는 숫자를 수신할 수 있습니다.

검증: 테스트

예, 스키마는 입력 값에 대해 "테스트"를 실행합니다. 테스트에서는 입력이 일부 기준을 준수하는지 확인합니다. 테스트는 입력(또는 해당 유형)을 변경하거나 변경하지 않는다는 점에서 변환과 구별되며 일반적으로 정적 유형으로 표현하기 어려운 검사용으로 예약되어 있습니다.

 string ( )
  . min ( 3 , 'must be at least 3 characters long' )
  . email ( 'must be a valid email' )
  . validate ( 'no' ) ; // ValidationError

변환과 마찬가지로 테스트도 즉시 맞춤설정할 수 있습니다.

 let jamesSchema = string ( ) . test (
  'is-james' ,
  ( d ) => ` ${ d . path } is not James` ,
  ( value ) => value == null || value === 'James' ,
) ;

jamesSchema . validateSync ( 'James' ) ; // "James"

jamesSchema . validateSync ( 'Jane' ) ; // ValidationError "this is not James"

주의 사항: 변환과 달리 맞춤 테스트의 value 올바른 유형(이 경우 선택적 문자열)이 보장됩니다. 이러한 경우에는 스키마에 따라 여전히 undefined null 일 수 있습니다. 변환이 존재 관련 어설션을 만들지 않는 한 값이 없는 경우 true 를 반환할 수 있습니다. 테스트 옵션 skipAbsent 설정된 경우 이 작업을 수행합니다.

오류 맞춤설정

가장 간단한 경우 테스트 함수는 검사 통과 여부에 따라 true 또는 false 반환합니다. 테스트가 실패한 경우 해당 테스트에 대한 사용자(또는 기본) 메시지와 함께 ValidationError 발생합니다. ValidationErrors에는 이름, 호출된 인수(있는 경우), 중첩된 유효성 검사의 경우 실패한 필드에 대한 경로 등 테스트에 대한 다른 메타데이터도 포함되어 있습니다.

스키마가 실패하는 방식을 사용자 정의하기 위해 오류 메시지를 즉석에서 구성할 수도 있습니다.

 let order = object ( {
  no : number ( ) . required ( ) ,
  sku : string ( ) . test ( {
    name : 'is-sku' ,
    skipAbsent : true ,
    test ( value , ctx ) {
      if ( ! value . startsWith ( 's-' ) ) {
        return ctx . createError ( { message : 'SKU missing correct prefix' } )
      }
      if ( ! value . endsWith ( '-42a' ) ) {
        return ctx . createError ( { message : 'SKU missing correct suffix' } )
      }
      if ( value . length < 10 ) {
        return ctx . createError ( { message : 'SKU is not the right length' } )
      }
      return true
    }
  } )
} )

order . validate ( { no : 1234 , sku : 's-1a45-14a' } )

구성 및 재사용

스키마는 변경할 수 없으며 각 메서드 호출은 새 스키마 개체를 반환합니다. 다른 인스턴스가 변경될 염려 없이 재사용하고 전달하세요.

 let optionalString = string ( ) . optional ( ) ;

let definedString = optionalString . defined ( ) ;

let value = undefined ;
optionalString . isValid ( value ) ; // true
definedString . isValid ( value ) ; // false

타입스크립트 통합

예, 스키마는 정적 TypeScript 인터페이스를 생성합니다. InferType 사용하여 해당 인터페이스를 추출합니다.

 import * as yup from 'yup' ;

let personSchema = yup . object ( {
  firstName : yup . string ( ) . defined ( ) ,
  nickName : yup . string ( ) . default ( '' ) . nullable ( ) ,
  sex : yup
    . mixed ( )
    . oneOf ( [ 'male' , 'female' , 'other' ] as const )
    . defined ( ) ,
  email : yup . string ( ) . nullable ( ) . email ( ) ,
  birthDate : yup . date ( ) . nullable ( ) . min ( new Date ( 1900 , 0 , 1 ) ) ,
} ) ;

interface Person extends yup . InferType < typeof personSchema > {
  // using interface instead of type generally gives nicer editor feedback
}

스키마 기본값

캐스팅이 undefined 출력 값을 생성할 때 스키마의 기본값이 사용됩니다. 이 때문에 기본값을 설정하면 스키마의 출력 유형에 영향을 미치며 기본적으로 "정의된()"으로 표시됩니다.

 import { string } from 'yup' ;

let value : string = string ( ) . default ( 'hi' ) . validate ( undefined ) ;

// vs

let value : string | undefined = string ( ) . validate ( undefined ) ;

스키마가 기존 유형과 일치하는지 확인

TypeScript 유형이 이미 존재하고 스키마가 호환 가능한 유형을 생성하는지 확인하려는 경우도 있습니다.

 import { object , number , string , ObjectSchema } from 'yup' ;

interface Person {
  name : string ;
  age ?: number ;
  sex : 'male' | 'female' | 'other' | null ;
}

// will raise a compile-time type error if the schema does not produce a valid Person
let schema : ObjectSchema < Person > = object ( {
  name : string ( ) . defined ( ) ,
  age : number ( ) . optional ( ) ,
  sex : string < 'male' | 'female' | 'other' > ( ) . nullable ( ) . defined ( ) ,
} ) ;

//  errors:
// "Type 'number | undefined' is not assignable to type 'string'."
let badSchema : ObjectSchema < Person > = object ( {
  name : number ( ) ,
} ) ;

새로운 방법으로 내장 스키마 확장

필요한 경우 TypeScript의 인터페이스 병합 동작을 사용하여 스키마 유형을 확장할 수 있습니다. 유형 확장은 globals.d.ts 와 같은 "주변" 유형 정의 파일에 들어가야 합니다. 실제로 애플리케이션 코드에서 yup 유형을 확장하는 것을 기억하세요!

조심하세요! 병합은 제네릭을 포함하여 유형 정의가 정확히 동일한 경우에만 작동합니다. 각 유형에 대한 소스 코드를 참조하여 올바르게 정의했는지 확인하세요.

 // globals.d.ts
declare module 'yup' {
  interface StringSchema < TType , TContext , TDefault , TFlags > {
    append ( appendStr : string ) : this ;
  }
}

// app.ts
import { addMethod , string } from 'yup' ;

addMethod ( string , 'append' , function append ( appendStr : string ) {
  return this . transform ( ( value ) => ` ${ value } ${ appendStr } ` ) ;
} ) ;

string ( ) . append ( '~~~~' ) . cast ( 'hi' ) ; // 'hi~~~~'

타입스크립트 구성

유형 추론이 작동하려면 strictNullChecks 컴파일러 옵션이 활성화되어 있어야 합니다 .

또한 기능적으로 더 나은 유형을 위해 strictFunctionTypes false 로 설정하는 것이 좋습니다. 예, 이는 전반적인 건전성을 감소시키지만 TypeScript는 이미 메소드 및 생성자에 대해 이 검사를 비활성화합니다(TS 문서 참고).

이 기능을 개발하는 동안 우리는 DOM의 일부를 포함하여 본질적으로 안전하지 않은 클래스 계층 구조가 많이 발견되었습니다. 이로 인해 설정은 함수 구문으로 작성된 함수에만 적용되고 메서드 구문에는 적용되지 않습니다.

귀하의 마일리지는 다양하지만 이 검사는 많은 실제 버그를 예방하지 못하고 앱에서 번거로운 명시적 유형 캐스팅의 양을 증가시키는 것으로 나타났습니다.

오류 메시지 사용자 정의

유효성 검사 테스트에서 메시지가 제공되지 않는 경우 기본 오류 메시지를 사용자 정의할 수 있습니다. 사용자 정의 사전에 메시지가 누락된 경우 오류 메시지는 기본적으로 Yup의 메시지로 표시됩니다.

 import { setLocale } from 'yup' ;

setLocale ( {
  mixed : {
    default : 'Não é válido' ,
  } ,
  number : {
    min : 'Deve ser maior que ${min}' ,
  } ,
} ) ;

// now use Yup schemas AFTER you defined your custom dictionary
let schema = yup . object ( ) . shape ( {
  name : yup . string ( ) ,
  age : yup . number ( ) . min ( 18 ) ,
} ) ;

try {
  await schema . validate ( { name : 'jimmy' , age : 11 } ) ;
} catch ( err ) {
  err . name ; // => 'ValidationError'
  err . errors ; // => ['Deve ser maior que 18']
}

현지화 및 i18n

다국어 지원이 필요한 경우, 응, 도와드리겠습니다. setLocale 함수는 번역 키와 값을 사용하여 오류 개체를 생성하는 데 사용할 수 있는 함수를 허용합니다. 이것들은 당신이 즐겨찾는 i18n 라이브러리에 공급될 수 있습니다.

 import { setLocale } from 'yup' ;

setLocale ( {
  // use constant translation keys for messages without values
  mixed : {
    default : 'field_invalid' ,
  } ,
  // use functions to generate an error object that includes the value from the schema
  number : {
    min : ( { min } ) => ( { key : 'field_too_short' , values : { min } } ) ,
    max : ( { max } ) => ( { key : 'field_too_big' , values : { max } } ) ,
  } ,
} ) ;

// ...

let schema = yup . object ( ) . shape ( {
  name : yup . string ( ) ,
  age : yup . number ( ) . min ( 18 ) ,
} ) ;

try {
  await schema . validate ( { name : 'jimmy' , age : 11 } ) ;
} catch ( err ) {
  messages = err . errors . map ( ( err ) => i18next . t ( err . key ) ) ;
}

API

`yup`

모듈 내보내기.

 // core schema
import {
  mixed ,
  string ,
  number ,
  boolean ,
  bool ,
  date ,
  object ,
  array ,
  ref ,
  lazy ,
} from 'yup' ;

// Classes
import {
  Schema ,
  MixedSchema ,
  StringSchema ,
  NumberSchema ,
  BooleanSchema ,
  DateSchema ,
  ArraySchema ,
  ObjectSchema ,
} from 'yup' ;

// Types
import type { InferType , ISchema , AnySchema , AnyObjectSchema } from 'yup' ;

`reach(schema: Schema, path: string, value?: object, context?: object): Schema`

중첩된 스키마의 경우 reach 제공된 경로를 기반으로 내부 스키마를 검색합니다.

동적으로 해결해야 하는 중첩된 스키마의 경우 value 제공하고 선택적으로 context 개체를 제공할 수 있습니다.

 import { reach } from 'yup' ;

let schema = object ( {
  nested : object ( {
    arr : array ( object ( { num : number ( ) . max ( 4 ) } ) ) ,
  } ) ,
} ) ;

reach ( schema , 'nested.arr.num' ) ;
reach ( schema , 'nested.arr[].num' ) ;
reach ( schema , 'nested.arr[1].num' ) ;
reach ( schema , 'nested["arr"][1].num' ) ;

`addMethod(schemaType: Schema, name: string, method: ()=> Schema): void`

핵심 스키마 유형에 새로운 방법을 추가합니다. schemaType.prototype[name] = method 에 대한 보다 친숙한 편의 메서드입니다.

 import { addMethod , date } from 'yup' ;

addMethod ( date , 'format' , function format ( formats , parseStrict ) {
  return this . transform ( ( value , originalValue , ctx ) => {
    if ( ctx . isType ( value ) ) return value ;

    value = Moment ( originalValue , formats , parseStrict ) ;

    return value . isValid ( ) ? value . toDate ( ) : new Date ( '' ) ;
  } ) ;
} ) ;

모든 스키마 유형에 메서드를 추가하려면 추상 기본 클래스인 Schema 확장하세요.

 import { addMethod , Schema } from 'yup' ;

addMethod ( Schema , 'myMethod' , ... )

`ref(path: string, options: { contextPrefix: string }): Ref`

다른 형제 또는 형제 하위 필드에 대한 참조를 만듭니다. 참조는 유효성 검사/캐스트 시간 에 확인되며 지정된 경우 지원됩니다. Ref는 ref를 사용하는 필드보다 먼저 ref 값이 확인되도록 적절한 순서로 평가됩니다(순환 종속성에 주의하세요!).

 import { ref , object , string } from 'yup' ;

let schema = object ( {
  baz : ref ( 'foo.bar' ) ,
  foo : object ( {
    bar : string ( ) ,
  } ) ,
  x : ref ( '$x' ) ,
} ) ;

schema . cast ( { foo : { bar : 'boom' } } , { context : { x : 5 } } ) ;
// => { baz: 'boom',  x: 5, foo: { bar: 'boom' } }

`lazy((value: any) => Schema): Lazy`

유효성 검사/캐스트 시 평가되는 스키마를 만듭니다. 다형성 필드 및 배열에 대해 트리와 같은 재귀 스키마를 생성하는 데 유용합니다.

주의! 부모-자식 재귀 개체 스키마를 정의할 때 자식에서 default() null 로 재설정하려고 합니다. 그렇지 않으면 개체를 캐스팅할 때 개체가 무한히 중첩됩니다!

 let node = object ( {
  id : number ( ) ,
  child : yup . lazy ( ( ) => node . default ( undefined ) ) ,
} ) ;

let renderable = yup . lazy ( ( value ) => {
  switch ( typeof value ) {
    case 'number' :
      return number ( ) ;
    case 'string' :
      return string ( ) ;
    default :
      return mixed ( ) ;
  }
} ) ;

let renderables = array ( ) . of ( renderable ) ;

`ValidationError(errors: string | Array<string>, value: any, path: string)`

다음 속성을 사용하여 검증 실패 시 발생합니다.

name : "ValidationError"
type : 실패한 특정 테스트 유형 또는 테스트 "이름"입니다.
value : 테스트된 필드 값입니다.
params ?: 최대값, 정규식 등과 같은 테스트 입력입니다.
path : 오류가 발생한 위치를 나타내는 문자열입니다. path 루트 수준에서 비어 있습니다.
errors : 오류 메시지 배열
inner : 집계 오류의 경우 inner는 유효성 검사 체인에서 더 일찍 발생하는 ValidationErrors 배열입니다. abortEarly 옵션이 false 인 경우 여기에서 발생한 각 오류를 검사할 수 있습니다. 또는 errors 각 내부 오류의 모든 메시지가 포함됩니다.

`Schema`

Schema 모든 스키마 유형이 상속되는 추상 기본 클래스입니다. 다른 모든 스키마 유형에 다양한 기본 메서드와 속성을 제공합니다.

참고: 사용자 정의 스키마 유형을 생성하지 않는 한 스키마를 직접 사용해서는 안 됩니다. 알 수 없거나 모든 유형의 경우 mixed() 사용하세요.

`Schema.clone(): Schema`

스키마의 전체 복사본을 생성합니다. 복제는 스키마 상태가 변경될 때마다 새 스키마를 반환하기 위해 내부적으로 사용됩니다.

`Schema.label(label: string): Schema`

오류 메시지에 사용되는 키 이름을 재정의합니다.

`Schema.meta(metadata: SchemaMetadata): Schema`

캐스트 개체 자체에 속하지 않는 스키마와 함께 데이터를 저장하는 데 유용한 메타데이터 개체에 추가합니다.

CustomSchemaMetadata 인터페이스와의 병합을 통해 사용자 정의 SchemaMetadata 인터페이스를 정의할 수 있습니다. 패키지에 yup.d.ts 파일을 만들고 원하는 CustomSchemaMetadata 인터페이스를 만드는 것부터 시작하세요.

 // yup.d.ts
import 'yup' ;

declare module 'yup' {
  // Define your desired `SchemaMetadata` interface by merging the
  // `CustomSchemaMetadata` interface.
  export interface CustomSchemaMetadata {
    placeholderText ?: string ;
    tooltipText ?: string ;
    // …
  }
}

`Schema.describe(options?: ResolveOptions): SchemaDescription`

스키마 세부정보(예: 메타, 레이블, 활성 테스트)를 직렬화 가능한 설명 개체로 수집합니다.

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

let description = schema . describe ( ) ;

동적 구성 요소(참조, 지연 또는 조건)가 있는 스키마의 경우 설명이 스키마 설명을 정확하게 반환하려면 더 많은 컨텍스트가 필요합니다. 이러한 경우 options 제공하십시오.

 import { ref , object , string , boolean } from 'yup' ;

let schema = object ( {
  isBig : boolean ( ) ,
  count : number ( ) . when ( 'isBig' , {
    is : true ,
    then : ( schema ) => schema . min ( 5 ) ,
    otherwise : ( schema ) => schema . min ( 0 ) ,
  } ) ,
} ) ;

schema . describe ( { value : { isBig : true } } ) ;

그리고 아래에는 설명 유형이 있는데, 스키마 유형에 따라 조금씩 다릅니다.

 interface SchemaDescription {
  type : string ;
  label ?: string ;
  meta : object | undefined ;
  oneOf : unknown [ ] ;
  notOneOf : unknown [ ] ;
  default ?: unknown ;
  nullable : boolean ;
  optional : boolean ;
  tests : Array < { name ?: string ; params : ExtraParams | undefined } > ;

  // Present on object schema descriptions
  fields : Record < string , SchemaFieldDescription > ;

  // Present on array schema descriptions
  innerType ?: SchemaFieldDescription ;
}

type SchemaFieldDescription =
  | SchemaDescription
  | SchemaRefDescription
  | SchemaLazyDescription ;

interface SchemaRefDescription {
  type : 'ref' ;
  key : string ;
}

interface SchemaLazyDescription {
  type : string ;
  label ?: string ;
  meta : object | undefined ;
}

`Schema.concat(schema: Schema): Schema`

두 개의 스키마를 결합하여 스키마의 새 인스턴스를 만듭니다. 동일한 유형의 스키마만 연결할 수 있습니다. concat 제공된 스키마의 모든 설정이 유형, 존재 및 null 허용 여부를 포함하여 기본 설정을 재정의한다는 점에서 "병합" 기능이 아닙니다.

 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>`

구문 분석을 반환하고 입력 값의 유효성을 검사하여 구문 분석된 값을 반환하거나 오류를 발생시킵니다. 이 메소드는 비동기식 이며 값으로 이행되거나 ValidationError 로 거부되는 Promise 객체를 반환합니다.

 value = await schema . validate ( { name : 'jimmy' , age : 24 } ) ;

validate 의 동작을 보다 구체적으로 제어할 수 있는 options 제공하십시오.

 interface Options {
  // when true, parsing is skipped and the input is validated "as-is"
  strict: boolean = false ;
  // Throw on the first error or collect and return all
  abortEarly: boolean = true ;
  // Remove unspecified keys from objects
  stripUnknown: boolean = false ;
  // when `false` validations will be performed shallowly
  recursive: boolean = true ;
  // External values that can be provided to validations and conditionals
  context ?: object ;
}

`Schema.validateSync(value: any, options?: object): InferType<Schema>`

가능한 경우 유효성 검사를 동기적으로 실행하고 결과 값을 반환하거나 ValidationError를 발생시킵니다. validate 와 동일한 옵션을 모두 허용합니다.

동기식 검증은 구성된 비동기 테스트(예: Promise를 반환하는 테스트)가 없는 경우에만 작동합니다. 예를 들어 다음과 같이 작동합니다.

 let schema = number ( ) . test (
  'is-42' ,
  "this isn't the number i want" ,
  ( value ) => value != 42 ,
) ;

schema . validateSync ( 23 ) ; // throws ValidationError

그러나 다음은 그렇지 않습니다.

 let schema = number ( ) . test ( 'is-42' , "this isn't the number i want" , ( value ) =>
  Promise . resolve ( value != 42 ) ,
) ;

schema . validateSync ( 42 ) ; // throws Error

`Schema.validateAt(path: string, value: any, options?: object): Promise<InferType<Schema>, ValidationError>`

스키마 내에서 깊이 중첩된 경로의 유효성을 검사합니다. reach 작동 방식과 유사하지만 결과 스키마를 검증 대상으로 사용합니다.

메모! 여기의 value 중첩 경로의 값이 아니라 시작 스키마를 기준으로 한 루트 값입니다.

 let schema = object ( {
  foo : array ( ) . of (
    object ( {
      loose : boolean ( ) ,
      bar : string ( ) . when ( 'loose' , {
        is : true ,
        otherwise : ( schema ) => schema . strict ( ) ,
      } ) ,
    } ) ,
  ) ,
} ) ;

let rootValue = {
  foo : [ { bar : 1 } , { bar : 1 , loose : true } ] ,
} ;

await schema . validateAt ( 'foo[0].bar' , rootValue ) ; // => ValidationError: must be a string

await schema . validateAt ( 'foo[1].bar' , rootValue ) ; // => '1'

`Schema.validateSyncAt(path: string, value: any, options?: object): InferType<Schema>`

validateAt 와 동일하지만 동기적입니다.

`Schema.isValid(value: any, options?: object): Promise<boolean>`

전달된 값이 스키마와 일치하면 true 반환합니다. isValid 비동기식 이며 Promise 객체를 반환합니다.

validate() 와 동일한 옵션을 사용합니다.

`Schema.isValidSync(value: any, options?: object): boolean`

전달된 값이 스키마와 일치하면 동기적으로 true 반환합니다.

validateSync() 와 동일한 옵션을 사용하며 비동기 테스트와 관련하여 동일한 주의사항이 있습니다.

`Schema.cast(value: any, options = {}): InferType<Schema>`

전달된 값을 스키마와 일치하는 값으로 강제 변환하려고 시도합니다. 예를 들어, number() 유형을 사용할 때 '5' 5 로 변환됩니다. 실패한 캐스트는 일반적으로 null 반환하지만 NaN 및 예상치 못한 문자열과 같은 결과를 반환할 수도 있습니다.

validate 의 동작을 보다 구체적으로 제어할 수 있는 options 제공하십시오.

 interface CastOptions < TContext extends { } > {
  // Remove undefined properties from objects
  stripUnknown : boolean = false ;

  // Throws a TypeError if casting doesn't produce a valid type
  // note that the TS return type is inaccurate when this is `false`, use with caution
  assert ?: boolean = true ;

  // External values that used to resolve conditions and references
  context ?: TContext ;
}

`Schema.isType(value: any): value is InferType<Schema>`

전달된 value 에 대해 유형 검사를 실행합니다. 일치하면 true를 반환하고 값을 캐스팅하지 않습니다. nullable() 이 설정되면 null 해당 유형의 유효한 값으로 간주됩니다. 모든 스키마 유형 확인에는 isType 사용해야 합니다.

`Schema.strict(enabled: boolean = false): Schema`

strict 옵션을 true 로 설정합니다. 엄격한 스키마는 강제 및 변환 시도를 건너뛰고 "있는 그대로" 값을 검증합니다.

`Schema.strip(enabled: boolean = true): Schema`

출력 개체에서 제거할 스키마를 표시합니다. 중첩된 스키마로만 작동합니다.

 let schema = object ( {
  useThis : number ( ) ,
  notThis : string ( ) . strip ( ) ,
} ) ;

schema . cast ( { notThis : 'foo' , useThis : 4 } ) ; // => { useThis: 4 }

strip 활성화된 스키마에는 never 유추된 유형이 있으므로 전체 유형에서 제거할 수 있습니다.

 let schema = object ( {
  useThis : number ( ) ,
  notThis : string ( ) . strip ( ) ,
} ) ;

InferType < typeof schema > ; /*
{
   useThis?: number | undefined
}
*/

`Schema.withMutation(builder: (current: Schema) => void): void`

먼저 법적으로 요구되는 Rich Hickey의 말은 다음과 같습니다.

숲속에 나무가 쓰러지면 소리가 나나요?
순수 함수가 불변의 반환 값을 생성하기 위해 일부 로컬 데이터를 변경한다면 괜찮을까요?

withMutation 사용하면 각 변경 전에 복제되는 기본 동작 대신 스키마를 현재 위치에서 변경할 수 있습니다. 일반적으로 스키마 변경의 대부분은 초기 선언 중에 발생하고 스키마 수명 동안 한 번만 발생하므로 성능은 문제가 되지 않으므로 이는 필요하지 않습니다. 그러나 특정 변형은 캐스팅/검증 시(예: when() ) 을 사용하는 조건부 스키마) 또는 스키마 객체를 인스턴스화할 때 발생 합니다 .

 object ( )
  . shape ( { key : string ( ) } )
  . withMutation ( ( schema ) => {
    return arrayOfObjectTests . forEach ( ( test ) => {
      schema . test ( test ) ;
    } ) ;
  } ) ;

`Schema.default(value: any): Schema`

값이 undefined 경우 사용할 기본값을 설정합니다. 안전한 기본값이 지정되었는지 확인하기 위해 변환이 실행된 후 검증 전에 기본값이 생성됩니다. 기본값은 사용할 때마다 복제되므로 개체 및 배열에 대한 성능 저하가 발생할 수 있습니다. 이러한 오버헤드를 피하기 위해 새로운 기본값을 반환하는 함수를 전달할 수도 있습니다. null 은 비어 있지 않은 별도의 값으로 간주됩니다.

 yup . string . default ( 'nothing' ) ;

yup . object . default ( { number : 5 } ) ; // object will be cloned every time a default is needed

yup . object . default ( ( ) => ( { number : 5 } ) ) ; // this is cheaper

yup . date . default ( ( ) => new Date ( ) ) ; // also helpful for defaults that change over time

`Schema.getDefault(options?: object): Any`

이전에 설정된 기본값을 검색합니다. getDefault 기본값을 변경할 수 있는 모든 조건을 해결합니다. 선택적으로 context 와 함께 options 전달합니다( context 에 대한 자세한 내용은 Schema.validate 참조).

`Schema.nullable(message?: string | function): Schema`

null 이 스키마에 유효한 값임을 나타냅니다. nullable() 없으면 null 다른 유형으로 처리되며 Schema.isType() 검사에 실패합니다.

 let schema = number ( ) . nullable ( ) ;

schema . cast ( null ) ; // null

InferType < typeof schema > ; // number | null

`Schema.nonNullable(message?: string | function): Schema`

nullable 과 반대로 스키마의 유효한 유형 값에서 null 제거합니다. 스키마는 기본적으로 null을 허용하지 않습니다 .

 let schema = number ( ) . nonNullable ( ) ;

schema . cast ( null ) ; // TypeError

InferType < typeof schema > ; // number

`Schema.defined(): Schema`

스키마 값이 필요합니다. undefined 필드 값을 제외한 모든 필드 값은 이 요구 사항을 충족합니다.

 let schema = string ( ) . defined ( ) ;

schema . cast ( undefined ) ; // TypeError

InferType < typeof schema > ; // string

`Schema.optional(): Schema`

defined() 의 반대는 주어진 유형에 대해 undefined 값을 허용합니다.

 let schema = string ( ) . optional ( ) ;

schema . cast ( undefined ) ; // undefined

InferType < typeof schema > ; // string | undefined

`Schema.required(message?: string | function): Schema`

스키마를 필수로 표시하십시오. 그러면 undefined 또는 null 값으로 허용되지 않습니다. required optional() 및 nullable() 호출의 효과를 무효화합니다.

조심하세요! string().required )는 약간 다르게 작동하며 필요한 경우 빈 문자열 값( '' )을 추가로 방지합니다.

`Schema.notRequired(): Schema`

스키마를 필요하지 않은 것으로 표시합니다. 이것은 schema.nullable().optional() 의 단축어입니다.

`Schema.typeError(message: string): Schema`

실패한 유형 검사에 대한 오류 메시지를 정의합니다. ${value} 및 ${type} 보간은 message 인수에 사용될 수 있습니다.

`Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema` 별칭: `equals`

값 집합의 값만 허용합니다. 추가된 값은 notOneOf 값(있는 경우)에서 제거됩니다. ${values} 보간은 message 인수에 사용될 수 있습니다. ref가 제공되면 메시지 인수에 ${resolved} 보간을 사용하여 유효성 검사 시 확인된 확인된 값을 가져올 수 있습니다.

undefined arrayOfValues 에 포함되지 않은 경우에도 undefined 이 유효성 검사기에 실패하지 않습니다. undefined 이 유효한 값이 되는 것을 원하지 않으면 Schema.required 사용할 수 있습니다.

 let schema = yup . mixed ( ) . oneOf ( [ 'jimmy' , 42 ] ) ;

await schema . isValid ( 42 ) ; // => true
await schema . isValid ( 'jimmy' ) ; // => true
await schema . isValid ( new Date ( ) ) ; // => false

`Schema.notOneOf(arrayOfValues: Array<any>, message?: string | function)`

값 집합의 값을 허용하지 않습니다. 추가된 값은 oneOf 값(있는 경우)에서 제거됩니다. ${values} 보간은 message 인수에 사용될 수 있습니다. ref가 제공되면 메시지 인수에 ${resolved} 보간을 사용하여 유효성 검사 시 확인된 확인된 값을 가져올 수 있습니다.

 let schema = yup . mixed ( ) . notOneOf ( [ 'jimmy' , 42 ] ) ;

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

`Schema.when(keys: string | string[], builder: object | (values: any[], schema) => Schema): Schema`

형제 또는 형제 하위 필드를 기반으로 스키마를 조정합니다. 키 is 값이거나 일치자 함수인 객체 리터럴을 제공한 then 실패 조건에 대한 실제 스키마 및/또는 otherwise 을 제공할 수 있습니다.

is 조건은 엄격하게 비교됩니다( === ). 다른 형태의 동등성을 사용하려는 경우 is: (value) => value == true 와 같은 함수를 제공할 수 있습니다.

또한 속성 앞에 $ 붙여서 입력 값 대신 validate() 또는 cast 통해 전달된 context 에 종속되는 속성을 지정할 수도 있습니다.

조건이 추가되는 when .

then 및 otherwise 에는 지정된 함수 (schema: Schema) => Schema 입니다.

 let schema = object ( {
  isBig : boolean ( ) ,
  count : number ( )
    . when ( 'isBig' , {
      is : true , // alternatively: (val) => val == true
      then : ( schema ) => schema . min ( 5 ) ,
      otherwise : ( schema ) => schema . min ( 0 ) ,
    } )
    . when ( '$other' , ( [ other ] , schema ) =>
      other === 4 ? schema . max ( 6 ) : schema ,
    ) ,
} ) ;

await schema . validate ( value , { context : { other : 4 } } ) ;

또한 하나 이상의 종속 키를 지정할 수도 있습니다. 이 경우 각 값은 인수로 확산됩니다.

 let schema = object ( {
  isSpecial : boolean ( ) ,
  isBig : boolean ( ) ,
  count : number ( ) . when ( [ 'isBig' , 'isSpecial' ] , {
    is : true , // alternatively: (isBig, isSpecial) => isBig && isSpecial
    then : ( schema ) => schema . min ( 5 ) ,
    otherwise : ( schema ) => schema . min ( 0 ) ,
  } ) ,
} ) ;

await schema . validate ( {
  isBig : true ,
  isSpecial : true ,
  count : 10 ,
} ) ;

또는 현재 스키마에 제공된 각 키에 대한 값 배열을 사용하여 호출되는 스키마를 반환하는 함수를 제공할 수 있습니다.

 let schema = yup . object ( {
  isBig : yup . boolean ( ) ,
  count : yup . number ( ) . when ( 'isBig' , ( [ isBig ] , schema ) => {
    return isBig ? schema . min ( 5 ) : schema . min ( 0 ) ;
  } ) ,
} ) ;

await schema . validate ( { isBig : false , count : 4 } ) ;

`Schema.test(name: string, message: string | function | any, test: function): Schema`

검증 체인에 테스트 기능을 추가합니다. 테스트는 객체가 캐스팅된 후에 실행됩니다. 많은 유형에는 몇 가지 테스트가 내장되어 있지만 사용자 정의 테스트를 쉽게 만들 수 있습니다. 비동기식 사용자 정의 유효성 검사를 허용하기 위해 모든 테스트가 비동기식으로 실행됩니다. 그 결과 테스트 실행 순서를 보장할 수 없습니다.

모든 테스트는 name , 오류 message 및 현재 value 유효할 때 true 반환하고 그렇지 않으면 false 또는 ValidationError 반환해야 하는 유효성 검사 함수를 제공해야 합니다. 테스트를 비동기로 만들려면 true 또는 false 해결하는 Promise 또는 ValidationError 반환하세요.

message 인수의 경우 ${param} 구문을 사용하여 지정된 경우 특정 값을 보간하는 문자열을 제공할 수 있습니다. 기본적으로 모든 테스트 메시지에는 중첩 스키마에 중요한 path 값이 전달됩니다.

test 함수는 현재 value 으로 호출됩니다. 고급 검증을 위해 대체 서명을 사용하여 더 많은 옵션을 제공할 수 있습니다(아래 참조).

 let jimmySchema = string ( ) . test (
  'is-jimmy' ,
  '${path} is not Jimmy' ,
  ( value , context ) => value === 'jimmy' ,
) ;

// or make it async by returning a promise
let asyncJimmySchema = string ( )
  . label ( 'First name' )
  . test (
    'is-jimmy' ,
    ( { label } ) => ` ${ label } is not Jimmy` , // a message can also be a function
    async ( value , testContext ) =>
      ( await fetch ( '/is-jimmy/' + value ) ) . responseText === 'true' ,
  ) ;

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

테스트 함수는 몇 가지 유용한 메타데이터와 함수를 노출하는 두 번째 인수로 특수 컨텍스트 값을 사용하여 호출됩니다. 화살표가 아닌 함수의 경우 테스트 컨텍스트도 this 함수로 설정됩니다. this 통해 액세스하면 화살표 기능이 작동하지 않으므로 주의하세요.

testContext.path : 현재 유효성 검사의 문자열 경로
testContext.schema : 테스트가 실행 중인 확인된 스키마 개체입니다.
testContext.options : verify() 또는 isValid()가 호출된 options 객체
testContext.parent : 중첩된 스키마의 경우 상위 객체의 값입니다.
testContext.originalValue : 테스트 중인 원래 값
testContext.createError(Object: { path: String, message: String, params: Object }) : 유효성 검사 오류를 생성하고 반환합니다. path , params 또는 오류 message 동적으로 설정하는 데 유용합니다. 두 옵션 중 하나를 생략하면 현재 경로나 기본 메시지가 사용됩니다.

`Schema.test(options: object): Schema`

대체 test(..) 서명. options 다음 옵션 중 일부를 포함하는 객체입니다:

 Options = {
  // unique name identifying the test
  name : string ;
  // test function, determines schema validity
  test: ( value : any ) => boolean ;
  // the validation error message
  message: string ;
  // values passed to message for interpolation
  params: ? object ;
  // mark the test as exclusive, meaning only one test of the same name can be active at once
  exclusive: boolean = false ;
}

배타적 테스트와 비배타적 테스트를 혼합하는 경우 다음 논리가 사용됩니다. 동일한 이름의 독점 테스트가 있는 스키마에 비독점 테스트가 추가되면 독점 테스트가 제거되고 동일한 이름의 추가 테스트가 스택됩니다.

동일한 이름의 비독점 테스트가 있는 스키마에 단독 테스트가 추가되면 이전 테스트가 제거되고 동일한 이름의 추가 테스트가 서로 대체됩니다.

 let max = 64 ;
let schema = yup . string ( ) . test ( {
  name : 'max' ,
  exclusive : true ,
  params : { max } ,
  message : '${path} must be less than ${max} characters' ,
  test : ( value ) => value == null || value . length <= max ,
} ) ;

`Schema.transform((currentValue: any, originalValue: any) => any): Schema`

변환 체인에 변환을 추가합니다. 변환은 캐스팅 프로세스의 핵심이며, 각 유형의 기본 변환은 값을 특정 유형으로 강제 변환합니다( isType() 으로 확인됨). 변환은 유효성 검사 전에 실행되며 스키마가 strict (기본값)으로 표시되지 않은 경우에만 적용됩니다. 일부 유형에는 변환이 내장되어 있습니다.

변환은 개체가 캐스팅되는 방식을 임의로 변경하는 데 유용 하지만 전달된 값을 변경하지 않도록 주의해야 합니다. 변환은 순차적으로 실행되므로 각 value 캐스트의 현재 상태를 나타냅니다. 원시 초기 값에 대해 작업해야 하는 경우 originalValue 매개변수를 사용할 수 있습니다.

 let schema = string ( ) . transform ( ( value , originalValue ) => {
  return this . isType ( value ) && value !== null ? value . toUpperCase ( ) : value ;
} ) ;

schema . cast ( 'jimmy' ) ; // => 'JIMMY'

각 유형은 적절한 유형에 대한 기본 값 강제 변환을 처리하지만 경우에 따라 기본 동작을 조정하거나 개선하고 싶을 수도 있습니다. 예를 들어 기본 날짜 구문 분석 전략이 아닌 다른 날짜 구문 분석 전략을 사용하려는 경우 변환을 통해 이를 수행할 수 있습니다.

 module . exports = function ( formats = 'MMM dd, yyyy' ) {
  return date ( ) . transform ( ( value , originalValue , context ) => {
    // check to see if the previous transform already parsed the date
    if ( context . isType ( value ) ) return value ;

    // the default coercion failed so let's try it with Moment.js instead
    value = Moment ( originalValue , formats ) ;

    // if it's valid return the date object, otherwise return an `InvalidDate`
    return value . isValid ( ) ? value . toDate ( ) : new Date ( '' ) ;
  } ) ;
} ;

혼합된

모든 유형과 일치하거나 구성한 유형과 일치하는 스키마를 생성합니다. Schema 에서 상속됩니다. 혼합 유형은 기본적으로 any 또는 unknown 대신 {} 확장합니다. 이는 TypeScript에서 {} null 이 아니거나 undefined 항목 중 명확하게 처리되는 항목을 의미하기 때문입니다.

 import { mixed , InferType } from 'yup' ;

let schema = mixed ( ) . nullable ( ) ;

schema . validateSync ( 'string' ) ; // 'string';

schema . validateSync ( 1 ) ; // 1;

schema . validateSync ( new Date ( ) ) ; // Date;

InferType < typeof schema > ; // {} | undefined

InferType < typeof schema . nullable ( ) . defined ( ) > ; // {} | null

유형 check 기능을 전달하여 사용자 정의 유형을 구현할 수 있습니다. 또한 스키마에 대한 TypeScript 유형의 범위가 좁아집니다.

 import { mixed , InferType } from 'yup' ;

let objectIdSchema = yup
  . mixed ( ( input ) : input is ObjectId => input instanceof ObjectId )
  . transform ( ( value : any , input , ctx ) => {
    if ( ctx . isType ( value ) ) return value ;
    return new ObjectId ( value ) ;
  } ) ;

await objectIdSchema . validate ( ObjectId ( '507f1f77bcf86cd799439011' ) ) ; // ObjectId("507f1f77bcf86cd799439011")

await objectIdSchema . validate ( '507f1f77bcf86cd799439011' ) ; // ObjectId("507f1f77bcf86cd799439011")

InferType < typeof objectIdSchema > ; // ObjectId

끈

문자열 스키마를 정의합니다. Schema 에서 상속됩니다.

 let schema = yup . string ( ) ;

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

기본적으로 string 의 cast 논리는 값이 존재하는 경우 toString 호출하는 것입니다.

빈 값은 강제되지 않습니다. 빈 값을 빈 문자열로 강제하려면 ensure() 사용하세요.

실패한 캐스트는 입력 값을 반환합니다.

`string.required(message?: string | function): Schema`

빈 문자열도 '누락' 값으로 간주된다는 점을 제외하면 필수 mixed() 스키마와 동일합니다.

`string.length(limit: number | Ref, message?: string | function): Schema`

문자열 값에 필요한 길이를 설정합니다. ${length} 보간은 message 인수에 사용될 수 있습니다.

`string.min(limit: number | Ref, message?: string | function): Schema`

문자열 값의 최소 길이 제한을 설정합니다. ${min} 보간은 message 인수에 사용될 수 있습니다.

`string.max(limit: number | Ref, message?: string | function): Schema`

문자열 값의 최대 길이 제한을 설정합니다. ${max} 보간은 message 인수에 사용될 수 있습니다.

`string.matches(regex: Regex, message?: string | function): Schema`

값과 일치시킬 임의의 regex 제공하십시오.

 let schema = string ( ) . matches ( / (hi|bye) / ) ;

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

`string.matches(regex: Regex, options: { message: string, excludeEmptyString: bool }): Schema`

옵션 개체와 string.matches 에 대한 대체 서명입니다. excludeEmptyString 은 true인 경우 값이 빈 문자열일 때 정규식 테스트를 단락시켜 정규식을 복잡하게 하지 않고 아무 것도 일치하지 않는 것을 더 쉽게 방지할 수 있습니다.

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

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

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

HTML 사양에 정의된 것과 동일한 정규식을 사용하여 값을 이메일 주소로 검증합니다.

주의: 이메일 주소의 유효성을 검사하는 것은 코드만으로는 거의 불가능합니다. 서로 다른 클라이언트와 서버는 서로 다른 것을 받아들이며 "유효한" 이메일을 정의하는 다양한 사양에서 많은 부분이 다릅니다. 이메일 주소를 검증하는 유일한 실제 방법은 해당 주소로 확인 이메일을 보내고 사용자가 이를 받았는지 확인하는 것입니다. 이를 염두에 두고 yup은 모든 경우를 포괄하지는 않지만 HTML 양식이 yup의 일반적인 사용 사례이므로 브라우저 입력 유효성 검사 동작과 일치하는 비교적 간단한 정규식을 선택합니다.

보다 구체적인 요구사항이 있는 경우 이메일 방법을 자신만의 논리 또는 정규식으로 재정의하세요.

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

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

정규식을 통해 값이 유효한 URL인지 확인합니다.

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

정규 표현식을 통해 값이 유효한 UUID인지 확인합니다.

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

정규식을 통해 값을 ISO 날짜/시간으로 확인합니다. 기본값은 UTC 검증입니다. 시간대 오프셋은 허용되지 않습니다( options.allowOffset 참조).

.date() 와 달리 datetime 문자열을 Date 객체로 변환하지 않습니다. 또한 datetime date 보다 날짜/시간 문자열의 필수 형식에 대해 더 많은 사용자 정의 기능을 제공합니다.

options.allowOffset : 시간대 오프셋을 허용합니다. False에는 UTC 'Z' 시간대가 필요합니다. (기본값: false) options.precision : 날짜에 특정 1초 미만의 정밀도가 필요합니다. (기본값: null -- 초 미만의 정밀도가 있거나 없음)

`string.datetime(message?: string | function)`

message 이외의 옵션을 전달할 필요가 없을 때 사용할 수 있는 string.datetime 에 대한 대체 서명입니다.

`string.ensure(): Schema`

default 을 빈 문자열로 설정하는 것과 함께 undefined 값과 null 값을 빈 문자열로 변환합니다.

`string.trim(message?: string | function): Schema`

선행 및 후행 공백을 제거하여 문자열 값을 변환합니다. strict() 설정되면 값이 잘렸는지 확인만 합니다.

`string.lowercase(message?: string | function): Schema`

문자열 값을 소문자로 변환합니다. strict() 설정되면 값이 소문자인지만 검증합니다.

`string.uppercase(message?: string | function): Schema`

문자열 값을 대문자로 변환합니다. strict() 설정되면 값이 대문자인지만 검증합니다.

숫자

숫자 스키마를 정의합니다. Schema 에서 상속됩니다.

 let schema = yup . number ( ) ;

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

number 의 기본 cast 논리는 다음과 같습니다 parseFloat .

실패한 캐스트는 NaN 반환합니다.

`number.min(limit: number | Ref, message?: string | function): Schema`

허용되는 최소값을 설정합니다. ${min} 보간은 message 인수에 사용될 수 있습니다.

`number.max(limit: number | Ref, message?: string | function): Schema`

허용되는 최대값을 설정합니다. message 인수에 ${max} 보간을 사용할 수 있습니다.

`number.lessThan(max: number | Ref, message?: string | function): Schema`

값은 max 보다 작아야 합니다. ${less} 보간은 message 인수에 사용될 수 있습니다.

`number.moreThan(min: number | Ref, message?: string | function): Schema`

값은 min 보다 엄격하게 커야 합니다. ${more} 보간은 message 인수에 사용될 수 있습니다.

`number.positive(message?: string | function): Schema`

값은 양수여야 합니다.

`number.negative(message?: string | function): Schema`

값은 음수여야 합니다.

`number.integer(message?: string | function): Schema`

숫자가 정수인지 확인합니다.

`number.truncate(): Schema`

소수점 오른쪽의 숫자를 제거하여 값을 정수로 강제 변환하는 변환입니다.

`number.round(type: 'floor' | 'ceil' | 'trunc' | 'round' = 'round'): Schema`

지정된 Math 방법을 통해 값을 조정합니다(기본값은 'round').

부울

부울 스키마를 정의합니다. Schema 에서 상속됩니다.

 let schema = yup . boolean ( ) ;

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

날짜

날짜 스키마를 정의합니다. 기본적으로 ISO 날짜 문자열은 올바르게 구문 분석됩니다. 보다 강력한 구문 분석 옵션을 보려면 추가 정보 끝에 있는 확장 스키마 유형을 참조하세요. Schema 에서 상속됩니다.

 let schema = yup . date ( ) ;

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

date 의 기본 cast 논리는 값을 Date 생성자에 전달하는 것입니다. 실패하면 날짜를 ISO 날짜 문자열로 구문 분석하려고 시도합니다.

ISO 문자열을 Date 객체로 변환하지 않으려면 대신 .datetime() 사용하세요.

실패한 캐스트는 잘못된 날짜를 반환합니다.

`date.min(limit: Date | string | Ref, message?: string | function): Schema`

허용되는 최소 날짜를 설정하세요. 문자열이 제공되면 먼저 날짜로 변환을 시도하고 결과를 제한으로 사용합니다.

`date.max(limit: Date | string | Ref, message?: string | function): Schema`

허용되는 최대 날짜를 설정하십시오. 문자열이 제공되면 먼저 날짜로 변환을 시도하고 결과를 제한으로 사용합니다.

정렬

배열 스키마를 정의합니다. 배열은 유형을 지정할 수도 있고 그렇지 않을 수도 있습니다. 요소 유형을 지정할 때 cast 및 isValid 요소에도 적용됩니다. isValid 에 전달된 옵션은 하위 스키마에도 전달됩니다.

Schema 에서 상속됩니다.

 let schema = yup . array ( ) . of ( yup . number ( ) . min ( 2 ) ) ;

await schema . isValid ( [ 2 , 3 ] ) ; // => true
await schema . isValid ( [ 1 , - 24 ] ) ; // => false

schema . cast ( [ '2' , '3' ] ) ; // => [2, 3]

편의상 하위 유형 스키마를 배열 생성자에 전달할 수도 있습니다.

 array ( ) . of ( yup . number ( ) ) ;
// or
array ( yup . number ( ) ) ;

배열에는 기본 캐스팅 동작이 없습니다.

`array.of(type: Schema): this`

배열 요소의 스키마를 지정합니다. of() 는 선택 사항이며 생략하면 배열 스키마가 해당 내용의 유효성을 검사하지 않습니다.

`array.json(): this`

JSON.parse 사용하여 입력 문자열 값을 JSON으로 구문 분석해 보세요.

`array.length(length: number | Ref, message?: string | function): this`

배열에 대한 특정 길이 요구 사항을 설정합니다. ${length} 보간은 message 인수에 사용될 수 있습니다.

`array.min(limit: number | Ref, message?: string | function): this`

배열의 최소 길이 제한을 설정합니다. ${min} 보간은 message 인수에 사용될 수 있습니다.

`array.max(limit: number | Ref, message?: string | function): this`

배열의 최대 길이 제한을 설정합니다. message 인수에 ${max} 보간을 사용할 수 있습니다.

`array.ensure(): this`

기본값을 [] 로 설정하고 null 및 undefined 값도 빈 배열로 변환하여 값이 배열인지 확인합니다. 비어 있지 않고 배열이 아닌 값은 배열로 래핑됩니다.

 array ( ) . ensure ( ) . cast ( null ) ; // => []
array ( ) . ensure ( ) . cast ( 1 ) ; // => [1]
array ( ) . ensure ( ) . cast ( [ 1 ] ) ; // => [1]

`array.compact(rejector: (value) => boolean): Schema`

배열에서 잘못된 값을 제거합니다. 거부 기능을 제공하면 거부 기준을 직접 지정할 수 있습니다.

 array ( ) . compact ( ) . cast ( [ '' , 1 , 0 , 4 , false , null ] ) ; // => [1, 4]

array ( )
  . compact ( function ( v ) {
    return v == null ;
  } )
  . cast ( [ '' , 1 , 0 , 4 , false , null ] ) ; // => ['', 1, 0, 4, false]

튜플

튜플은 각 항목이 고유한 유형을 갖는 고정 길이 배열입니다.

Schema 에서 상속됩니다.

 import { tuple , string , number , InferType } from 'yup' ;

let schema = tuple ( [
  string ( ) . label ( 'name' ) ,
  number ( ) . label ( 'age' ) . positive ( ) . integer ( ) ,
] ) ;

await schema . validate ( [ 'James' , 3 ] ) ; // ['James', 3]

await schema . validate ( [ 'James' , - 24 ] ) ; // => ValidationError: age must be a positive number

InferType < typeof schema > // [string, number] | undefined

튜플에는 기본 캐스팅 동작이 없습니다.

물체

개체 스키마를 정의합니다. isValid 에 전달된 옵션은 하위 스키마에도 전달됩니다. Schema 에서 상속됩니다.

 yup . object ( {
  name : string ( ) . required ( ) ,
  age : number ( ) . required ( ) . positive ( ) . integer ( ) ,
  email : string ( ) . email ( ) ,
  website : string ( ) . url ( ) ,
} ) ;

개체 스키마에는 기본 변환이 적용되지 않습니다.

객체 스키마 기본값

객체 스키마에는 객체 형태를 "구축"하는 기본값이 이미 설정되어 있으며 필드에 대한 기본값을 설정합니다.

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

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

이는 다소 놀랄 수 있지만 대규모 중첩 스키마를 사용하여 루트 개체뿐만 아니라 전체 모양을 채우는 기본값을 생성할 수 있으므로 일반적으로 도움이 됩니다. 한 가지 문제가 있습니다! 그렇지만. 선택 사항이지만 선택 사항이 아닌 필드를 포함하는 중첩 개체 스키마의 경우 예기치 않은 방식으로 실패할 수 있습니다.

 let schema = object ( {
  id : string ( ) . required ( ) ,
  names : object ( {
    first : string ( ) . required ( ) ,
  } ) ,
} ) ;

schema . isValid ( { id : 1 } ) ; // false! names.first is required

이는 유효성 검사를 실행하기 전에 입력 개체를 캐스팅하여 다음을 생성하기 때문입니다.

{ id: '1', names: { first: undefined }}

유효성 검사 단계 동안 names 존재하고 유효성이 검사되어 names.first 누락되었습니다. 이 동작을 방지하려면 다음 중 하나를 수행하십시오.

중첩된 기본값을 정의되지 않음으로 설정: names.default(undefined)
nullable로 표시하고 기본값은 null로 설정합니다: names.nullable().default(null)

`object.shape(fields: object, noSortEdges?: Array<[string, string]>): Schema`

객체의 키와 해당 키에 대한 스키마를 정의합니다.

Object.assign 처럼 작동하는 shape 메서드를 연결할 수 있습니다.

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

다음과 정확히 동일합니다.

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

`object.json(): this`

JSON.parse 사용하여 입력 문자열 값을 JSON으로 구문 분석해 보세요.

`object.concat(schemaB: ObjectSchema): ObjectSchema`

schemaB 의 모든 설정과 필드를 기본에 적용하여 개체 스키마를 생성하고 새 스키마를 생성합니다. 객체 형태는 기본 필드보다 우선적으로 schemaB 의 공통 필드와 얕게 병합됩니다.

`object.pick(keys: string[]): Schema`

원본 필드의 하위 집합에서 새 스키마를 만듭니다.

 let person = object ( {
  age : number ( ) . default ( 30 ) . required ( ) ,
  name : string ( ) . default ( 'pat' ) . required ( ) ,
  color : string ( ) . default ( 'red' ) . required ( ) ,
} ) ;

let nameAndAge = person . pick ( [ 'name' , 'age' ] ) ;
nameAndAge . getDefault ( ) ; // => { age: 30, name: 'pat'}

`object.omit(keys: string[]): Schema`

필드가 생략된 새 스키마를 만듭니다.

 let person = object ( {
  age : number ( ) . default ( 30 ) . required ( ) ,
  name : string ( ) . default ( 'pat' ) . required ( ) ,
  color : string ( ) . default ( 'red' ) . required ( ) ,
} ) ;

let nameAndAge = person . omit ( [ 'color' ] ) ;
nameAndAge . getDefault ( ) ; // => { age: 30, name: 'pat'}

`object.from(fromKey: string, toKey: string, alias: boolean = false): this`

지정된 키를 새 키로 변환합니다. alias true 이면 이전 키가 남습니다.

 let schema = object ( {
  myProp : mixed ( ) ,
  Other : mixed ( ) ,
} )
  . from ( 'prop' , 'myProp' )
  . from ( 'other' , 'Other' , true ) ;

schema . cast ( { prop : 5 , other : 6 } ) ; // => { myProp: 5, other: 6, Other: 6 }

`object.noUnknown(onlyKnownKeys: boolean = true, message?: string | function): Schema`

객체 값에 shape 에 지정된 키만 포함되어 있는지 확인하고, 확인을 비활성화하려면 첫 번째 인수로 false 전달합니다. 키를 알려진 것으로 제한하면 엄격 모드가 아닌 경우에도 stripUnknown 옵션이 활성화됩니다.

`object.camelCase(): Schema`

모든 객체 키를 camelCase로 변환합니다.

`object.constantCase(): Schema`

모든 객체 키를 CONSTANT_CASE로 변환합니다.

확장하다

yup

예

시작하기

목차

스키마 기본 사항

구문 분석: 변환

검증: 테스트

오류 맞춤설정

구성 및 재사용

타입스크립트 통합

스키마 기본값

스키마가 기존 유형과 일치하는지 확인

새로운 방법으로 내장 스키마 확장

타입스크립트 구성

오류 메시지 사용자 정의

현지화 및 i18n

API

yup

reach(schema: Schema, path: string, value?: object, context?: object): Schema

addMethod(schemaType: Schema, name: string, method: ()=> Schema): void

ref(path: string, options: { contextPrefix: string }): Ref

lazy((value: any) => Schema): Lazy

ValidationError(errors: string | Array<string>, value: any, path: string)

Schema

Schema.clone(): Schema

Schema.label(label: string): Schema

Schema.meta(metadata: SchemaMetadata): Schema

Schema.describe(options?: ResolveOptions): SchemaDescription

Schema.concat(schema: Schema): Schema

Schema.validate(value: any, options?: object): Promise<InferType<Schema>, ValidationError>

Schema.validateSync(value: any, options?: object): InferType<Schema>

Schema.validateAt(path: string, value: any, options?: object): Promise<InferType<Schema>, ValidationError>

Schema.validateSyncAt(path: string, value: any, options?: object): InferType<Schema>

Schema.isValid(value: any, options?: object): Promise<boolean>

Schema.isValidSync(value: any, options?: object): boolean

Schema.cast(value: any, options = {}): InferType<Schema>

Schema.isType(value: any): value is InferType<Schema>

Schema.strict(enabled: boolean = false): Schema

Schema.strip(enabled: boolean = true): Schema

Schema.withMutation(builder: (current: Schema) => void): void

Schema.default(value: any): Schema

Schema.getDefault(options?: object): Any

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

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

Schema.defined(): Schema

Schema.optional(): Schema

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

Schema.notRequired(): Schema

Schema.typeError(message: string): Schema

Schema.oneOf(arrayOfValues: Array<any>, message?: string | function): Schema 별칭: equals

Schema.notOneOf(arrayOfValues: Array<any>, message?: string | function)

Schema.when(keys: string | string[], builder: object | (values: any[], schema) => Schema): Schema

Schema.test(name: string, message: string | function | any, test: function): Schema

Schema.test(options: object): Schema

Schema.transform((currentValue: any, originalValue: any) => any): Schema

혼합된

끈

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

string.length(limit: number | Ref, message?: string | function): Schema

string.min(limit: number | Ref, message?: string | function): Schema

string.max(limit: number | Ref, message?: string | function): Schema

string.matches(regex: Regex, message?: string | function): Schema

string.matches(regex: Regex, options: { message: string, excludeEmptyString: bool }): Schema

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

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

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

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

string.datetime(message?: string | function)

string.ensure(): Schema

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

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

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

숫자

number.min(limit: number | Ref, message?: string | function): Schema

number.max(limit: number | Ref, message?: string | function): Schema

number.lessThan(max: number | Ref, message?: string | function): Schema

number.moreThan(min: number | Ref, message?: string | function): Schema

number.positive(message?: string | function): Schema

number.negative(message?: string | function): Schema

number.integer(message?: string | function): Schema