홈페이지>PHP 소스 코드>기타 카테고리
다운로드

mighty

당신에게 필요한 마지막 검증 라이브러리!


목차

설치
mighty 에 대하여
빠른 시작
mVEL
예
제약
검증
선적 서류 비치
사양
변경 내역


이 프로젝트가 마음에 들고 개발을 지원하고 싶다면 추천해 주시면 감사하겠습니다!


주요 특징

  1. 종속성이 없습니다.
  2. 프레임워크에 구애받지 않고 모든 코드베이스에 통합될 수 있습니다.
  3. 표현력이 풍부하고 직관적이며 250 개 이상의 기본 제공 유효성 검사 규칙을 사용하기 쉽습니다.

<스팬 클래스= 강력한 데모" style="max-width: 100%;">

설치 

composer require marwanalsoltany/ mighty

mighty 에 대하여

유효성 검사는 모든 웹 애플리케이션에서 일반적인 작업입니다. 양식 또는 해당 문제에 대한 모든 유형의 입력을 통해 애플리케이션에 전달된 데이터는 항상 일련의 규칙에 따라 유효성을 검사해야 합니다. mighty 쉽고 표현력이 풍부한 방식으로 처리할 수 있습니다.

mighty 는 빠르고 강력하며 강력하고 사용하기 쉬운 검증 라이브러리로 작업하기 재미있고 모든 데이터의 검증을 쉽게 만들어줍니다. mighty mVEL(Validation Expression Language) 의 강력한 기능 덕분에 이전에 본 것과는 전혀 다릅니다. 유효성 검사 접근 방식과 250개 이상의 기본 제공 규칙을 사용하면 매우 표현력이 풍부하고 간결한 방식으로 유효성을 검사할 수 없는 것이 거의 없습니다. 간단히 말해서 mighty 는 스테로이드에 대한 검증입니다! 이는 실제로 여러분에게 필요할 마지막 검증 라이브러리입니다.

mighty 데이터 유효성을 검사하는 여러 가지 접근 방식을 제공합니다. 가장 일반적인 사용 사례는 HTTP 요청을 통해 들어오는 데이터의 유효성을 검사하는 것이지만 물론 이에 국한되지는 않습니다. mighty 모델 및/또는 모든 종류의 객체를 쉽게 검증할 수 있도록 제약 조건 형태의 속성도 제공합니다.

mighty 에는 단일 규칙으로 적용하거나 연산자를 사용하여 서로 결합하여 더욱 복잡한 유효성 검사를 구축할 수 있는 다양하고 편리한 유효성 검사 규칙이 포함되어 있습니다.

빠른 시작

mighty 의 강력한 유효성 검사 기능에 대해 알아보려면 바로 요점을 살펴보고 몇 가지 예를 살펴보겠습니다.

일반 데이터 검증

Validator::class 사용하여 양식 데이터 유효성 검사:

mightyValidator; $validator = new Validator(); $validator ->setData([ 'name' => 'John Doe', 'username' => 'john.doe', 'password' => 'Super@Secret#123', 'email' => '[email protected]', 'hobbies' => ['coding', 'design', 'sports'], ]) ->setValidations([ // required&string&between:3,255 'name' => $validator->validation()->required()->string()->between(3, 255), // required&string&matches:/[a-z0-9._-]/i 'username' => $validator->validation()->required()->string()->matches('/[a-z0-9._-]/i'), // required&string&min:8 'password' => $validator->validation()->required()->string()->min(8), // required&email 'email' => $validator->validation()->required()->email(), // null^(required&array&max:5) 'hobbies' => $validator ->validation() ->null() ->xor() ->group(fn ($validation) => $validation ->array() ->max(5) ), // null|(if:${hobbies.validations.array}&(string&min:3)) // hobby can be null or a string with at least 3 characters if hobbies is an array 'hobbies.*' => $validator ->validation() ->null() ->or() ->group(fn ($validation) => $validation ->if('${hobbies.validations.array}') ->open() ->string() ->min(3) ->close() ), ]) ->validate(); $result = $validator->isOK(); // boolean result of the overall validation result $errors = $validator->getErrors(); // an array of results of validations that failed $results = $validator->getResults(); // an array of results of all validations $validator->check(); // void or throws an exception with a nicely formatted message of what exactly went wrong ">
 use MAKS  mighty  Validator ;

$ validator = new Validator ();

$ validator
    -> setData ([
        ' name '     => ' John Doe ' ,
        ' username ' => ' john.doe ' ,
        ' password ' => ' Super@Secret#123 ' ,
        ' email '    => ' [email protected] ' ,
        ' hobbies '  => [ ' coding ' , ' design ' , ' sports ' ],
    ])
    -> setValidations ([
        // required&string&between:3,255
        ' name '      => $ validator -> validation ()-> required ()-> string ()-> between ( 3 , 255 ),
        // required&string&matches:/[a-z0-9._-]/i
        ' username '  => $ validator -> validation ()-> required ()-> string ()-> matches ( ' /[a-z0-9._-]/i ' ),
        // required&string&min:8
        ' password '  => $ validator -> validation ()-> required ()-> string ()-> min ( 8 ),
        // required&email
        ' email '     => $ validator -> validation ()-> required ()-> email (),
        // null^(required&array&max:5)
        ' hobbies '   => $ validator
            -> validation ()
            -> null ()
            -> xor ()
            -> group ( fn ( $ validation ) => $ validation
                -> array ()
                -> max ( 5 )
            ),
        // null|(if:${hobbies.validations.array}&(string&min:3))
        // hobby can be null or a string with at least 3 characters if hobbies is an array
        ' hobbies.* ' => $ validator
            -> validation ()
            -> null ()
            -> or ()
            -> group ( fn ( $ validation ) => $ validation
                -> if ( ' ${hobbies.validations.array} ' )
                -> open ()
                -> string ()
                -> min ( 3 )
                -> close ()
            ),
    ])
    -> validate ();

$ result = $ validator -> isOK (); // boolean result of the overall validation result

$ errors = $ validator -> getErrors (); // an array of results of validations that failed

$ results = $ validator -> getResults (); // an array of results of all validations

$ validator -> check (); // void or throws an exception with a nicely formatted message of what exactly went wrong

객체 검증

Constraint::class 속성을 사용하여 객체 상태 검증:

mightyValidationStrategy; use MAKS mighty ValidationBehavior; use MAKS mighty ValidationOperator; use MAKS mighty ValidationConstraint; use MAKS mighty ValidationConstraint as Assert; use MAKS mighty ValidationConstraintValidatableObjectInterface; use MAKS mighty ValidationConstraintValidatableObjectTrait; class ValidatableObject implements ValidatableObjectInterface { use ValidatableObjectTrait; #[AssertRuleEquals('CONST')] public const CONST = 'CONST'; #[AssertRuleIn(['STATIC', 'VAR'])] public static $static = 'VAR'; #[AssertRuleStringConstraint] #[AssertRuleStringCharset('UTF-8')] #[AssertRuleBetween(3, 99)] public $default = 'DEFAULT'; #[AssertRuleStringConstraint] #[AssertRuleStringContains('<element>')] #[AssertRuleXml] public $xml = '<?xml version="1.0"?><element></element>'; #[AssertRuleArrayConstraint] #[AssertShape([ 'string' => new AssertRuleStr, 'array' => new AssertRuleArr, ])] public $array = [ 'string' => 'value', 'array' => [], ]; #[AssertRuleObjectConstraint] #[AssertRuleObjectIsInstanceOf(ValidatableObjectInterface::class)] #[AssertValid(message: 'Not valid')] public $object; #[AssertCallback('is_scalar', 'Data is not scalar')] #[Constraint('string&min:3', strategy: Strategy::FailLazy, messages: [ 'string' => 'Must be string.', 'min' => 'Must be longer than ${@arguments.0}.', ])] public function getDefault() { return $this->default; } #[AssertCompound([ new AssertRuleStr, new AssertCompound([ new AssertRuleArr, new AssertCompound([ new AssertRuleBlank, ], Operator::Not), ], Operator::And), ], Operator::Xor, Behavior::Pessimistic, Strategy::FailLazy)] public static function getStaticProperty() { return static::$static; } } $object = new ValidatableObject(); $result = $object->isValid(); // boolean result of the overall validation result $results = $object->validate(); // an array of results of all validations $object->check(); // void or throws an exception with a nicely formatted message of what exactly went wrong ">
 use MAKS  mighty  Validation  Strategy ;
use MAKS  mighty  Validation  Behavior ;
use MAKS  mighty  Validation  Operator ;
use MAKS  mighty  Validation  Constraint ;
use MAKS  mighty  Validation  Constraint as Assert ;
use MAKS  mighty  Validation  Constraint  ValidatableObjectInterface ;
use MAKS  mighty  Validation  Constraint  ValidatableObjectTrait ;


class ValidatableObject implements ValidatableObjectInterface
{
    use ValidatableObjectTrait;


    #[ Assert  Rule Equals( ' CONST ' )]
    public const CONST = ' CONST ' ;

    #[ Assert  Rule In([ ' STATIC ' , ' VAR ' ])]
    public static $ static = ' VAR ' ;

    #[ Assert  Rule StringConstraint]
    #[ Assert  Rule StringCharset( ' UTF-8 ' )]
    #[ Assert  Rule Between( 3 , 99 )]
    public $ default = ' DEFAULT ' ;

    #[ Assert  Rule StringConstraint]
    #[ Assert  Rule StringContains( ' <element> ' )]
    #[ Assert  Rule Xml]
    public $ xml = ' <?xml version="1.0"?><element></element> ' ;

    #[ Assert  Rule ArrayConstraint]
    #[ Assert Shape([
        ' string ' => new Assert  Rule  Str ,
        ' array '  => new Assert  Rule  Arr ,
    ])]
    public $ array = [
        ' string ' => ' value ' ,
        ' array '  => [],
    ];

    #[ Assert  Rule ObjectConstraint]
    #[ Assert  Rule ObjectIsInstanceOf(ValidatableObjectInterface::class)]
    #[ Assert Valid(message: ' Not valid ' )]
    public $ object ;

    #[ Assert Callback( ' is_scalar ' , ' Data is not scalar ' )]
    #[Constraint( ' string&min:3 ' , strategy: Strategy::FailLazy, messages: [
        ' string ' => ' Must be string. ' ,
        ' min '    => ' Must be longer than ${@arguments.0}. ' ,
    ])]
    public function getDefault ()
    {
        return $ this -> default ;
    }

    #[ Assert Compound([
        new Assert  Rule  Str ,
        new Assert  Compound ([
            new Assert  Rule  Arr ,
            new Assert  Compound ([
                new Assert  Rule  Blank ,
            ], Operator::Not),
        ], Operator::And),
    ], Operator::Xor, Behavior::Pessimistic, Strategy::FailLazy)]
    public static function getStaticProperty ()
    {
        return static :: $ static ;
    }
}

$ object = new ValidatableObject ();

$ result = $ object -> isValid (); // boolean result of the overall validation result

$ results = $ object -> validate (); // an array of results of all validations

$ object -> check (); // void or throws an exception with a nicely formatted message of what exactly went wrong

유효성 검증 가능한 객체의 유효성을 검사하는 출력의 예는 다음과 같습니다. 

 // check out the previous snippet see the used constraints

$ object = new ValidatableObject ();
$ object -> object = new class implements ValidatableObjectInterface {
    use ValidatableObjectTrait;
    // some properties and their validation constraints ...
};
$ object -> default = null ; // this must be a string

$ object -> check ();

// ValidationFailedException::class
// Data failed to pass the validation.
// (01) The value (null) of the "ValidatableObject->default" property failed to pass the validation [string]. Problem: Value must be a string.
// (02) The value (null) of the "ValidatableObject->default" property failed to pass the validation [string.charset:"UTF-8"]. Problem: Value must be encoded in one of the following charsets: ["UTF-8"].
// (03) The value (null) of the "ValidatableObject->default" property failed to pass the validation [between:3,99]. Problem: Value must be between 3 and 99 or have a value/count/length that is between 3 and 99.
// (04) The return value (null) of the "ValidatableObject->getDefault()" method failed to pass the validation [callback]. Problem: Data is not scalar.
// (05) The return value (null) of the "ValidatableObject->getDefault()" method failed to pass the validation [string&min:3]. Problems: Must be string; Must be longer than 3.

ValidatableObject 및 ValidatableObjectChild 도 확인하세요.

■ 힌트: 예제 섹션에서 더 많은 예제를 찾을 수 있습니다.

mighty 검증 표현 언어

mighty 에는 Validation Expression이라는 개념이 있습니다. 가장 간단한 형태의 검증 표현식은 주어진 데이터를 얼마나 mighty 검증해야 하는지 설명하는 문자열일 뿐입니다. 이러한 문자열은 mighty mVEL(유효성 검사 표현 언어 사양)을 기반으로 합니다. mVEL은 매우 간단하고 사람이 읽을 수 있으며 대처하기 쉽습니다. 부울 대수, 비트 연산자, JSON 및 CSV와 같이 잘 확립된 개념 및/또는 사양의 조합입니다.

따라서 유효성 검사 표현식은 부울 대수 논리를 사용하여 평가할 때 유효성 검사의 최종 결과를 가져오는 표현식을 작성하는 비트 연산자 로 구분된 일부 규칙을 포함하는 문자열로 정의될 수 있습니다. 규칙에는 인수가 있을 수 있으며, 이러한 인수의 유형은 동일한 JSON 유형 규칙을 사용하여 표시될 수 있습니다. 규칙에는 여러 인수가 있을 수도 있으며 인수는 쉼표( CSV )로 구분됩니다.

예를 들어, required&string&between:2,255|null 유효한 유효성 검사 표현식입니다. 이 표현식은 다음과 같이 이해될 수 있습니다.

  1. 표현식에는 네 가지 규칙이 있습니다.
  2. 표현식에는 다음 규칙이 포함됩니다.
    1. required 입력이 존재하는지 확인합니다.
    2. string 입력이 문자열인지 확인합니다.
    3. between:2,255 입력이 2에서 255 사이의 길이를 가진 문자열인지 확인합니다.
    4. null 입력이 null임을 확인합니다.
  3. 최종 결과는 비트 연산자를 사용하여 결합된 각 규칙의 결과로 생성된 표현식을 평가한 결과입니다.

required&string&between:2,255|null 표현식은 입력이 있어야 함을 의미합니다. AND 유형의 문자열입니다. 그리고 길이는 2에서 255 사이입니다. 또는 null입니다. 따라서 null이 아닌 경우 길이는 2~255자 사이여야 하는 null 허용 문자열입니다.

입력이 " mighty is Awesome!" 이라고 가정해 보겠습니다. , 해당 입력에 대한 required&string&between:2,255|null 표현식의 결과는 1&1&1|0 이 되며 결과는 1 true , 입력이 null 이면 결과는 0&0&0|1 = 1 이 되고, 입력이 X 이면 결과가 됩니다. 0&0&0|0 = 0 등이 될 것입니다 ...

다른 유효성 검사 구현과 달리 비트 연산자를 사용하는 부울 대수 개념은 규칙을 최소한으로 유지하고 기존 논리를 역방향 또는 복합 방식으로 재사용하고 최종적으로 유지하면서 매우 읽기 쉽고 컴팩트한 복잡한 유효성 검사를 구축할 수 있는 가능성을 제공합니다. 코드 베이스를 DRY로 만들 수 있습니다. 이점은 다음과 같이 요약될 수 있습니다.

  1. 일반적으로 수행하는 작업과 정반대의 작업을 수행하기 위해 규칙을 적용 하지 않을 수 있습니다( ~ 사용).
  2. 복잡한 규칙은 두 개 이상의 간단한 규칙인 AND ing( & 사용), OR ing( | 사용) 또는 XOR ing( ^ 사용)의 결과일 수 있습니다.
  3. 규칙은 괄호, 즉 OPEN ( ( ) 및 CLOSE ( ) 사용)을 사용하여 함께 그룹화하거나 더 높은 우선 순위를 부여할 수 있습니다.
  4. 유효성 검사 표현식에는 모든 규칙에 영향을 주는 유효성 검사 표현식 문자열 앞에 붙는 문자인 동작도 있을 수 있습니다. 사용 가능한 동작은 다음과 같습니다.
    1. NORMAL : 모든 규칙을 실행합니다. 기본 동작입니다(접두사 없음).
    2. OPTIMISTIC : 첫 번째 성공 후 규칙 실행을 중지합니다( ? 접두사).
    3. PESSIMISTIC : 첫 번째 실패 후 규칙 실행을 중지합니다( ! 접두사).
  5. 일부 규칙에 별칭을 지정하거나 규칙 세트를 매크로로 추가하고 [macro] 구문을 사용하여 실행하면 가독성을 높일 수 있습니다.

또한 JSON 의 개념은 인수 데이터 유형의 안전성을 보장하고, CSV 의 개념은 인수 목록에 명확한 구문 분석 규칙이 있는지 확인합니다.

가장 좋은 점은 모든 규칙이나 유효성 검사 표현 언어 구문을 외울 필요가 없다는 것입니다. Validation 클래스는 유효성 검사 표현식을 작성하는 데 사용할 수 있는 유연한 인터페이스입니다. 사용 가능한 모든 mighty 규칙을 알고 있으며 최대한 쉽게 만들 수 있도록 완전한 IDE-Intellisense 지원을 제공합니다. 예를 들어:

mightyValidation; // the validation expression: `required&string&between:2,255|null` // can be constructed using the Validation::class as follows: $validation = (new Validation())->required()->string()->between(2, 255)->or()->null(); // AND is the default operator // or statically: $validation = Validation::required()->string()->between(2, 255)->or()->null(); ">
 use MAKS  mighty  Validation ;

// the validation expression: `required&string&between:2,255|null`
// can be constructed using the Validation::class as follows:
$ validation = ( new Validation ())-> required ()-> string ()-> between ( 2 , 255 )-> or ()-> null (); // AND is the default operator
// or statically:
$ validation = Validation:: required ()-> string ()-> between ( 2 , 255 )-> or ()-> null ();

■ 사실: 일반적으로 검증 표현식 자체보다 검증 표현식의 기능을 설명하는 데 더 많은 단어가 필요합니다!

예

다음은 실제 시나리오의 몇 가지 예입니다.

단일 값 검증

mightyValidator; $result = ($validator = new Validator()) ->validateOne( '123', $validator ->validation() // can be an integer or float or a string that is numeric // this example is only for demonstration only, // the same result can be achieved using numeric() only ->integer()->or()->float()->or()->group( fn ($validation) => $validation->string()->and()->numeric() ) ) ->toArray(); // $result would look something like this: [ 'value' => '123', 'result' => true, 'validations' => [ 'integer' => false, 'float' => false, 'string' => true, 'numeric' => true, ], 'errors' => [], 'metadata' => [ 'basis' => 'integer|float|(string&numeric)', 'rules' => 'integer|float|(string&numeric)', 'expression' => '0|0|(1&1)', ], ]; // you can also simply use the static helper Validator::validateData($data, $validation);">
 use MAKS  mighty  Validator ;

$ result = ( $ validator = new Validator ())
    -> validateOne (
        ' 123 ' ,
        $ validator
            -> validation ()
            // can be an integer or float or a string that is numeric
            // this example is only for demonstration only,
            // the same result can be achieved using numeric() only
            -> integer ()-> or ()-> float ()-> or ()-> group (
                fn ( $ validation ) => $ validation -> string ()-> and ()-> numeric ()
            )
    )
    -> toArray ();

// $result would look something like this:
[
    ' value ' => ' 123 ' ,
    ' result ' => true ,
    ' validations ' => [
        ' integer ' => false ,
        ' float ' => false ,
        ' string ' => true ,
        ' numeric ' => true ,
    ],
    ' errors ' => [],
    ' metadata ' => [
        ' basis ' => ' integer|float|(string&numeric) ' ,
        ' rules ' => ' integer|float|(string&numeric) ' ,
        ' expression ' => ' 0|0|(1&1) ' ,
    ],
];

// you can also simply use the static helper Validator::validateData($data, $validation);

구조화된 데이터 검증

mightyValidator; use AppServiceHaveIBeenPwnedService as PasswordService; $validator = new Validator(); $data = [ 'name' => 'John Doe', 'age' => 32, 'email' => '[email protected]', 'username' => 'john.doe', 'password' => 'Secret@123', 'image' => '/path/to/image.png', 'submission' => 'now', 'consent' => 'yes', 'data' => [ 'nickname' => 'JOE', 'number' => 7, 'hobbies' => [ 'coding', 'cooking', 'reading', ] ], ]; $validations = [ 'name' => $validator->validation()->required()->string()->stringCharset(['UTF-8', 'ASCII'])->pessimistic(), // or using mVEL => required&string&string.charset:'["UTF-8","ASCII"]' 'age' => $validator->validation()->required()->integer()->min(18), // or using mVEL => required&integer&min:18 'email' => $validator->validation()->required()->email()->macro('gmail'), // or using mVEL => required&email&[gmail] 'username' => $validator->validation()->required()->username(), // or using mVEL => required&username 'password' => $validator->validation()->required()->password()->callback(fn ($input) => !PasswordService::isPwned($input)), // or using mVEL => required&password (NOTE: callback ist not possible, it requires a Validation::class instance that is bound to the Validator::class instance) 'image' => $validator->validation()->null()->xor()->group(fn () => $this->image()->imageDimensions(1920, 1080, '<=')), // or using mVEL => null^(image&image.dimensions:1920,1080,"<=") 'submission' => $validator->validation()->required()->datetime()->datetimeLt('2022-12-07'), // or using mVEL => required&datetime&datetime.lt:"2022-12-07" 'consent' => $validator->validation()->assert('${age.value}', 18, '>=')->or()->accepted()->or()->assertEquals('${this}', 'granted')->optimistic(), // or using mVEL => ?assert:${age.value},18,">="|accepted|assert.equals:${this},"granted" 'data' => $validator->validation()->required()->array()->arrayHasKey('nickname'), // or using mVEL => required&array&array.hasKey:"nickname" 'data.*' => $validator->validation()->scalar()->or()->array()->optimistic(), // or using mVEL => ?scalar|array 'data.nickname' => $validator->validation()->string()->min(2)->max(32), // or using mVEL => string&min:2&max:32 'data.hobbies.*' => $validator->validation()->ifEq('${data.hobbies.validations.array}', false)->or()->group(fn () => $this->string()->min(3)), // or using mVEL => if.eq:${data.hobbies.validations.array},false|(string&min:3) ]; $labels = [ 'name' => 'Name', 'age' => 'Age', 'email' => 'E-Mail', 'password' => 'Password', 'image' => 'Image', 'data' => 'Data', 'data.*' => 'Value of data', 'consent' => 'Consent', ]; $messages = [ '*' => [ // this will be expanded for all fields 'required' => '${@label} is a required field.', ], 'age' => [ 'min' => '${@label} must be at least ${@arguments.0}.', ], 'username' => [ 'matches' => '${@label} must contain letters, numbers, and the following characters ".-_" only.', ], 'consent' => [ 'assert' => 'You must be at least ${@arguments.1} years old to submit this form.', ] ]; $validator ->setData($data) ->setValidations($validations) ->setMessages($messages) ->setLabels($labels) ->validate(); $results = $validator->getResults(); // $result should look something like this: [ // this will actually be a Result object // array syntax is used here for demonstration purposes 'name' => [ 'key' => 'name', 'value' => 'John Doe', 'result' => true, 'validations' => [ 'required' => true, 'string' => true, 'string.charset' => true, ], 'errors' => [], 'metadata' => [ 'basis' => '!required&string&string.charset:["UTF-8","ASCII"]', 'rules' => 'required&string&string.charset:["UTF-8","ASCII"]', 'expression' => '1&1&1', ], ], // other validations ... ]; // you can also simply use the static helper Validator::validateData($data, $validations);">
 use MAKS  mighty  Validator ;
use App  Service  HaveIBeenPwnedService as PasswordService ;

$ validator = new Validator ();

$ data = [
    ' name '       => ' John Doe ' ,
    ' age '        => 32 ,
    ' email '      => ' [email protected] ' ,
    ' username '   => ' john.doe ' ,
    ' password '   => ' Secret@123 ' ,
    ' image '      => ' /path/to/image.png ' ,
    ' submission ' => ' now ' ,
    ' consent '    => ' yes ' ,
    ' data '       => [
        ' nickname ' => ' JOE ' ,
        ' number '   => 7 ,
        ' hobbies '  => [
            ' coding ' ,
            ' cooking ' ,
            ' reading ' ,
        ]
    ],
];

$ validations = [
    ' name '           => $ validator -> validation ()-> required ()-> string ()-> stringCharset ([ ' UTF-8 ' , ' ASCII ' ])-> pessimistic (),
    // or using mVEL => required&string&string.charset:'["UTF-8","ASCII"]'
    ' age '            => $ validator -> validation ()-> required ()-> integer ()-> min ( 18 ),
    // or using mVEL => required&integer&min:18
    ' email '          => $ validator -> validation ()-> required ()-> email ()-> macro ( ' gmail ' ),
    // or using mVEL => required&email&[gmail]
    ' username '       => $ validator -> validation ()-> required ()-> username (),
    // or using mVEL => required&username
    ' password '       => $ validator -> validation ()-> required ()-> password ()-> callback ( fn ( $ input ) => !PasswordService:: isPwned ( $ input )),
    // or using mVEL => required&password (NOTE: callback ist not possible, it requires a Validation::class instance that is bound to the Validator::class instance)
    ' image '          => $ validator -> validation ()-> null ()-> xor ()-> group ( fn () => $ this -> image ()-> imageDimensions ( 1920 , 1080 , ' <= ' )),
    // or using mVEL => null^(image&image.dimensions:1920,1080,"<=")
    ' submission '     => $ validator -> validation ()-> required ()-> datetime ()-> datetimeLt ( ' 2022-12-07 ' ),
    // or using mVEL => required&datetime&datetime.lt:"2022-12-07"
    ' consent '        => $ validator -> validation ()-> assert ( ' ${age.value} ' , 18 , ' >= ' )-> or ()-> accepted ()-> or ()-> assertEquals ( ' ${this} ' , ' granted ' )-> optimistic (),
    // or using mVEL => ?assert:${age.value},18,">="|accepted|assert.equals:${this},"granted"
    ' data '           => $ validator -> validation ()-> required ()-> array ()-> arrayHasKey ( ' nickname ' ),
    // or using mVEL => required&array&array.hasKey:"nickname"
    ' data.* '         => $ validator -> validation ()-> scalar ()-> or ()-> array ()-> optimistic (),
    // or using mVEL => ?scalar|array
    ' data.nickname '  => $ validator -> validation ()-> string ()-> min ( 2 )-> max ( 32 ),
    // or using mVEL => string&min:2&max:32
    ' data.hobbies.* ' => $ validator -> validation ()-> ifEq ( ' ${data.hobbies.validations.array} ' , false )-> or ()-> group ( fn () => $ this -> string ()-> min ( 3 )),
    // or using mVEL => if.eq:${data.hobbies.validations.array},false|(string&min:3)
];

$ labels = [
    ' name '     => ' Name ' ,
    ' age '      => ' Age ' ,
    ' email '    => ' E-Mail ' ,
    ' password ' => ' Password ' ,
    ' image '    => ' Image ' ,
    ' data '     => ' Data ' ,
    ' data.* '   => ' Value of data ' ,
    ' consent '  => ' Consent ' ,
];

$ messages = [
    ' * ' => [ // this will be expanded for all fields
        ' required ' => ' ${@label} is a required field. ' ,
    ],
    ' age ' => [
        ' min ' => ' ${@label} must be at least ${@arguments.0}. ' ,
    ],
    ' username ' => [
        ' matches ' => ' ${@label} must contain letters, numbers, and the following characters ".-_" only. ' ,
    ],
    ' consent ' => [
        ' assert ' => ' You must be at least ${@arguments.1} years old to submit this form. ' ,
    ]
];

$ validator
    -> setData ( $ data )
    -> setValidations ( $ validations )
    -> setMessages ( $ messages )
    -> setLabels ( $ labels )
    -> validate ();

$ results = $ validator -> getResults ();

// $result should look something like this:
[
    // this will actually be a Result object
    // array syntax is used here for demonstration purposes
    ' name ' => [
        ' key ' => ' name ' ,
        ' value ' => ' John Doe ' ,
        ' result ' => true ,
        ' validations ' => [
            ' required ' => true ,
            ' string ' => true ,
            ' string.charset ' => true ,
        ],
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' !required&string&string.charset:["UTF-8","ASCII"] ' ,
            ' rules ' => ' required&string&string.charset:["UTF-8","ASCII"] ' ,
            ' expression ' => ' 1&1&1 ' ,
        ],
    ],
    // other validations ...
];

// you can also simply use the static helper Validator::validateData($data, $validations);

■ 힌트: Validator::class 에 메시지 재정의를 제공할 때 RuleValidation::class 사용하여 배열 키를 설정하는 것이 좋습니다. 이 클래스에는 모든 mighty 내장 규칙 이름이 클래스 상수로 포함되어 있습니다.

유효성 검사기 확장

유효성 검사기는 세 가지 방법으로 확장될 수 있습니다.

  • 규칙을 추가합니다.
  • 별칭을 추가합니다.
  • 매크로를 추가하면 됩니다.
mightyValidator; use MAKS mighty Rule; $validator = new Validator(); // adding a new rule $validator->addRule( (new Rule()) ->name('equals') ->arguments(['string']) ->callback(fn (string $input, mixed $expected): bool => $input == $expected) ->parameters(['@input', '@arguments.0']) ->comparison(['@output', '===', true]) ->example('equals:value') ->description('Asserts that the input is equal to the given value.') ); // adding a new rule alias $validator->addRuleAlias('eq', 'equals'); // adding a new rules macro $validator->addRuleMacro('gmail', 'string&email&matches:"/@gmail.com$/i"'); $results = $validator->validateAll( [ 'name' => 'John', 'email' => '[email protected]', ], [ 'name' => 'eq:John', 'email' => 'required&[gmail]', ] ); // $results should look like this: [ // items will actually be a Result object // array syntax is used here for demonstration purposes 'name' => [ 'key' => 'name', 'value' => 'John', 'result' => true, 'validations' => [ 'eq' => true, ], 'errors' => [], 'metadata' => [ 'basis' => 'eq:John', 'rules' => 'eq:John', 'expression' => '1', ], ], 'email' => [ 'key' => 'email', 'value' => '[email protected]', 'result' => false, 'validations' => [ 'required' => true, 'string' => true, 'email' => true, 'matches' => false, ],, 'errors' => [], 'metadata' => [ 'basis' => 'required&[gmail]', 'rules' => 'required&(string&email&matches:"/@gmail.com$/i")', 'expression' => '1&(1&1&0)', ], ], ];">
 use MAKS  mighty  Validator ;
use MAKS  mighty  Rule ;

$ validator = new Validator ();

// adding a new rule
$ validator -> addRule (
    ( new Rule ())
        -> name ( ' equals ' )
        -> arguments ([ ' string ' ])
        -> callback ( fn ( string $ input , mixed $ expected ): bool => $ input == $ expected )
        -> parameters ([ ' @input ' , ' @arguments.0 ' ])
        -> comparison ([ ' @output ' , ' === ' , true ])
        -> example ( ' equals:value ' )
        -> description ( ' Asserts that the input is equal to the given value. ' )
);

// adding a new rule alias
$ validator -> addRuleAlias ( ' eq ' , ' equals ' );

// adding a new rules macro
$ validator -> addRuleMacro ( ' gmail ' , ' string&email&matches:"/@gmail.com$/i" ' );

$ results = $ validator -> validateAll (
    [
        ' name '  => ' John ' ,
        ' email ' => ' [email protected] ' ,
    ],
    [
        ' name '  => ' eq:John ' ,
        ' email ' => ' required&[gmail] ' ,
    ]
);

// $results should look like this:
[
    // items will actually be a Result object
    // array syntax is used here for demonstration purposes
    ' name ' => [
        ' key ' => ' name ' ,
        ' value ' => ' John ' ,
        ' result ' => true ,
        ' validations ' => [
            ' eq ' => true ,
        ],
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' eq:John ' ,
            ' rules ' => ' eq:John ' ,
            ' expression ' => ' 1 ' ,
        ],
    ],
    ' email ' => [
        ' key ' => ' email ' ,
        ' value ' => ' [email protected] ' ,
        ' result ' => false ,
        ' validations ' => [
            ' required ' => true ,
            ' string ' => true ,
            ' email ' => true ,
            ' matches ' => false ,
        ],,
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' required&[gmail] ' ,
            ' rules ' => ' required&(string&email&matches:"/@gmail.com$/i") ' ,
            ' expression ' => ' 1&(1&1&0) ' ,
        ],
    ],
];

■ 힌트: 더 많은 예를 보려면 Validator 의 기본 rules , aliases 및 macros 확인하세요.

제약

mighty 모든 데이터 또는 클래스 값, 클래스 상수, 속성 및 메서드의 유효성을 검사하는 데 사용할 수 있는 250개 이상의 규칙/속성으로 구성됩니다.

속성은 세 가지 주요 그룹으로 나뉩니다.

  1. 일반 제약 속성
  2. 특수 제약 속성
  3. 규칙 제약 조건 속성

일반 제약 속성 그룹

일반 제약 조건 특성은 MAKS mighty Validation 네임스페이스 아래에 있습니다.

이 그룹은 현재 하나의 속성으로만 구성됩니다. 이것이 Constraint 속성입니다. 이 속성은 적용되는 데이터의 유효성을 검사하기 위해 유효성 검사 표현식을 사용합니다. 이는 다른 모든 속성의 기본 클래스이기도 합니다.

특수 제약 속성 그룹

특수 제약 조건 특성은 MAKS mighty ValidationConstraint 네임스페이스 아래에 있습니다.

이 그룹에는 속성 컨텍스트에서만 사용할 수 있는 특정 작업을 수행하는 속성이 포함되어 있습니다. 이는 다음 속성으로 구성됩니다.

  • Rule : 이 속성은 단일 유효성 검사 규칙을 사용하여 모든 데이터의 유효성을 검사하는 데 사용됩니다. 또한 규칙 제약 조건 속성 그룹의 모든 속성에 대한 기본 클래스이기도 합니다.
  • Callback : 이 속성은 콜백 함수를 사용하여 모든 데이터의 유효성을 검사하는 데 사용됩니다.
  • Valid : 이 속성은 검증 가능한 객체의 유효성을 검증하는 데 사용됩니다.
  • Shape : 이 속성은 배열이나 객체의 모양을 확인하는 데 사용됩니다. 이는 단일 값이 아닌 값 집합(구조화된 데이터)의 유효성을 검사하는 유일한 속성입니다.
  • Compound : 이 속성은 검증 표현식을 작성하기 위해 제약 조건 세트를 결합하는 데 사용됩니다. 제약 조건은 모든 연산자를 사용하여 결합할 수 있으며 동작을 가질 수도 있습니다. 유효성 검사 표현식을 작성하는 객체 지향 방법으로 사용됩니다.

■ 참고: Shape::class 및 Compound::class 속성과 함께 사용할 수 있는 제약 조건은 Constraint::class , Rule::class 또는 Compound::class 의 실제 인스턴스여야 합니다. 특수 제약 조건 속성 그룹 의 Callback::class , Valid::class 또는 Shape::class 허용되지 않습니다. 이 기능이 필요한 경우 문제를 공개하면 구현에 대해 논의하겠습니다.

규칙 제약 조건 속성 그룹

규칙 제약 조건 특성은 MAKS mighty ValidationConstraintRule 네임스페이스 아래에 있습니다.

이 그룹에는 단일 유효성 검사 규칙을 기반으로 하는 속성이 포함되어 있습니다. 이는 mighty 제공하는 대부분의 속성으로 구성됩니다. 전체 목록은 유효성 검사 섹션을 참조하세요.

사용자 정의 제약 조건 추가

mighty 에는 수많은 내장 제약 조건 목록이 있으므로 mighty 제공하는 것 외에 다른 것이 필요한 경우는 거의 없습니다. 그럼에도 불구하고 때로는 사용자 지정 제약 조건이 필요한 경우가 있는데, 이를 달성하는 방법은 다음과 같습니다.

mightyRule; use MAKS mighty Result; use MAKS mighty ValidationStrategy; use MAKS mighty ValidationConstraint; use MAKS mighty ValidationConstraintValidatesOne; // use the ValidatesMany interface if your Constraint returns a collection of Result objects use MAKS mighty ValidationConstraintValidatesMany; #[Attribute( Attribute::TARGET_PROPERTY | Attribute::TARGET_METHOD )] class MyCustomConstraint extends Constraint implements ValidatesOne { public function __construct( ?string $message = null, Strategy $strategy = Strategy::FailFast, ) { parent::__construct( validation: 'app.myCustomConstraint', messages: ['app.myCustomConstraint' => $message], strategy: $strategy ); } public function validate(mixed $value = null): Result { // it is really up to you, how you handle this // you will just work with a normal mighty Validator // here we're just preparing the data to pass to the Validator $name = ''; $data = [$name => $value]; $validations = [$name => $this->validation]; $messages = [$name => [$this->validation => $this->messages[$this->validation] ?? null]]; $labels = [$name => static::class]; // you can reuse the built-in rules or // add you own Rule that handles your custom logic $result = $this ->getValidator() ->addRule( // see MAKS mighty Rule for more info (new Rule()) ->setName('app.myCustomConstraint') ->setCallback(static fn ($input) => $input /* here comes your logic */) ->setParameters(['@input']) // rule callback dependencies ->setMessage('${@label} must follow my custom constraint validation.') // this is the default message ) ->setData($data) ->setValidations($validations) ->setMessages($messages) ->setLabels($labels) ->validate(); return $result[$name]; // if you implement ValidatesMany, you will just return $result } }">
 <?php

declare (strict_types= 1 );

namespace App  Validation  Constraint ;

use Attribute ;
use MAKS  mighty  Rule ;
use MAKS  mighty  Result ;
use MAKS  mighty  Validation  Strategy ;
use MAKS  mighty  Validation  Constraint ;
use MAKS  mighty  Validation  Constraint  ValidatesOne ;
// use the ValidatesMany interface if your Constraint returns a collection of Result objects
use MAKS  mighty  Validation  Constraint  ValidatesMany ;

#[Attribute(
    Attribute:: TARGET_PROPERTY |
    Attribute:: TARGET_METHOD
)]
class MyCustomConstraint extends Constraint implements ValidatesOne
{
    public function __construct (
        ? string $ message = null ,
        Strategy $ strategy = Strategy::FailFast,
    ) {
        parent :: __construct (
            validation: ' app.myCustomConstraint ' ,
            messages: [ ' app.myCustomConstraint ' => $ message ],
            strategy: $ strategy
        );
    }


    public function validate ( mixed $ value = null ): Result
    {
        // it is really up to you, how you handle this
        // you will just work with a normal mighty Validator
        // here we're just preparing the data to pass to the Validator
        $ name        = '' ;
        $ data        = [ $ name => $ value ];
        $ validations = [ $ name => $ this -> validation ];
        $ messages    = [ $ name => [ $ this -> validation => $ this -> messages [ $ this -> validation ] ?? null ]];
        $ labels      = [ $ name => static ::class];

        // you can reuse the built-in rules or
        // add you own Rule that handles your custom logic
        $ result = $ this
            -> getValidator ()
            -> addRule (
                // see MAKS mighty Rule for more info
                ( new Rule ())
                    -> setName ( ' app.myCustomConstraint ' )
                    -> setCallback ( static fn ( $ input ) => $ input /* here comes your logic */ )
                    -> setParameters ([ ' @input ' ]) // rule callback dependencies
                    -> setMessage ( ' ${@label} must follow my custom constraint validation. ' ) // this is the default message
            )
            -> setData ( $ data )
            -> setValidations ( $ validations )
            -> setMessages ( $ messages )
            -> setLabels ( $ labels )
            -> validate ();

        return $ result [ $ name ]; // if you implement ValidatesMany, you will just return $result
    }
}

■ 참고: 사용자 정의 제약 조건은 특수 제약 조건 속성 그룹 의 일부로 간주됩니다(즉 Shape::class 및 Compound::class 제약 조건과 함께/내부에서 사용이 허용되지 않음)

검증

다음 표에는 상응하는 속성 및 메서드를 포함하여 사용 가능한 모든 규칙이 나열되어 있습니다.

규칙 및 별칭

  • Validation::class
  • Constraint::class 및 Constraint/Rule/*
아니요. 규칙 설명 속성/방법
001 이름: null
사용법: null		 입력이 null이라고 어설션합니다. 기인하다:
NullConstraint::class
방법:
Validation::null()
002 이름: boolean
사용법: boolean		 입력이 부울인지 확인합니다. 기인하다:
Boolean::class
방법:
Validation::boolean()
003 이름: integer
사용법: integer		 입력이 정수인지 확인합니다. 기인하다:
Integer::class
방법:
Validation::integer()
004 이름: float
사용법: float		 입력이 부동 소수점임을 확인합니다. 기인하다:
FloatConstraint::class
방법:
Validation::float()
005 이름: numeric
사용법: numeric		 입력이 숫자인지 확인합니다. 기인하다:
NumericConstraint::class
방법:
Validation::numeric()
006 이름: string
사용법: string		 입력이 문자열임을 확인합니다. 기인하다:
StringConstraint::class
방법:
Validation::string()
007 이름: scalar
사용법: scalar		 입력이 스칼라인지 확인합니다. 기인하다:
Scalar::class
방법:
Validation::scalar()
008 이름: array
사용법: array		 입력이 배열임을 확인합니다. 기인하다:
ArrayConstraint::class
방법:
Validation::array()
009 이름: object
용법: object		 입력이 객체임을 어설션합니다. 기인하다:
ObjectConstraint::class
방법:
Validation::object()
010 이름: callable
사용법: callable		 입력이 호출 가능함을 어설션합니다. 기인하다:
CallableConstraint::class
방법:
Validation::callable()
011 이름: iterable
사용법: iterable		 입력이 반복 가능하다고 어설션합니다. 기인하다:
IterableConstraint::class
방법:
Validation::iterable()
012 이름: countable
용법: countable		 입력이 셀 수 있음을 확인합니다. 기인하다:
Countable::class
방법:
Validation::countable()
013 이름: resource
용법: resource		 입력이 리소스임을 확인합니다. 기인하다:
ResourceConstraint::class
방법:
Validation::resource()
014 이름: type
사용법: type:'["int","float"]'		 입력이 지정된 유형 중 하나인지 확인합니다. 기인하다:
Type::class
방법:
Validation::type(string|array $type)
015 이름: type.debug
사용법: type.debug:string		 get_debug_type()을 사용하여 입력이 주어진 유형인지 확인합니다. 기인하다:
TypeDebug::class
방법:
Validation::typeDebug(string $type)
016 이름: alpha
사용법: alpha		 입력이 알파벳 문자로만 구성되어 있는지 확인합니다. 기인하다:
Alpha::class
방법:
Validation::alpha()
017 이름: alnum
용법: alnum		 입력이 영숫자 문자로만 구성되어 있는지 확인합니다. 기인하다:
Alnum::class
방법:
Validation::alnum()
018 이름: lower
사용법: lower		 입력이 소문자로만 구성되어 있는지 확인합니다. 기인하다:
Lower::class
방법:
Validation::lower()
019 이름: upper
용법: upper		 입력이 대문자로만 구성되어 있는지 확인합니다. 기인하다:
Upper::class
방법:
Validation::upper()
020 이름: cntrl
사용법: cntrl		 입력이 제어 문자로만 구성되어 있는지 확인합니다. 기인하다:
Cntrl::class
방법:
Validation::cntrl()
021 이름: space
용법: space		 입력이 공백 문자로만 구성되어 있는지 확인합니다. 기인하다:
Space::class
방법:
Validation::space()
022 이름: punct
용법: punct		 입력이 구두점 문자로만 구성되어 있는지 확인합니다. 기인하다:
Punct::class
방법:
Validation::punct()
023 이름: graph
용법: graph		 입력이 그래픽 문자(보이는 출력을 생성하는 문자)로만 구성되어 있는지 확인합니다. 기인하다:
Graph::class
방법:
Validation::graph()
024 이름: print
사용법: print		 입력이 인쇄 가능한 문자로만 구성되어 있는지 확인합니다. 기인하다:
PrintConstraint::class
방법:
Validation::print()
025 이름: digit
사용법: digit		 입력이 숫자(숫자 문자)로만 구성되어 있는지 확인합니다. 기인하다:
Digit::class
방법:
Validation::digit()
026 이름: xdigit
사용법: xdigit		 입력이 16진수를 나타내는지 확인합니다. 기인하다:
Xdigit::class
방법:
Validation::xdigit()
027 이름: booleanLike
사용법: booleanLike		 입력이 부울로 구문 분석될 수 있는 값인지 확인합니다(TRUE: true, "true", "1", "on", "yes"; FALSE: false, "false", "0", "off" , "아니요", "", null). 기인하다:
BooleanLike::class
방법:
Validation::booleanLike()
028 이름: integerLike
사용법: integerLike:0,100		 입력이 지정된 범위 내에서 정수로 구문 분석될 수 있는 값인지 확인합니다. 기인하다:
IntegerLike::class
방법:
Validation::integerLike(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
029 이름: integerLike.allowOctal
사용법: integerLike.allowOctal:0,100		 입력이 지정된 범위 내에서 정수로 구문 분석될 수 있고 8진수 표기법일 수 있는 값인지 확인합니다. 기인하다:
IntegerLikeAllowOctal::class
방법:
Validation::integerLikeAllowOctal(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
030 이름: integerLike.allowHex
사용법: integerLike.allowHex:0,100		 입력이 지정된 범위 내에서 정수로 구문 분석될 수 있고 16진수 표기법일 수 있는 값임을 어설션합니다. 기인하다:
IntegerLikeAllowHex::class
방법:
Validation::integerLikeAllowHex(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
031 이름: floatLike
사용법: floatLike:1.0,100.0		 입력이 지정된 범위 내에서 부동 소수점으로 구문 분석될 수 있는 값인지 확인합니다. 기인하다:
FloatLike::class
방법:
Validation::floatLike(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
032 이름: floatLike.allowThousands
사용법: floatLike.allowThousands:1.0,100.0		 입력이 지정된 범위 내에서 부동 소수점으로 구문 분석될 수 있는 값인지 확인합니다. 기인하다:
FloatLikeAllowThousands::class
방법:
Validation::floatLikeAllowThousands(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
033 이름: regexp
사용법: regexp:"/[az]/i"		 입력이 Perl 호환 정규식과 일치하는지 확인합니다. 기인하다:
Regexp::class
방법:
Validation::regexp(string $pattern)
034 이름: ip
사용법: ip		 입력이 IP 주소인지 확인합니다. 기인하다:
Ip::class
방법:
Validation::ip()
035 이름: ip.v4
사용법: ip.v4		 입력이 IPv4 주소인지 확인합니다. 기인하다:
IpV4::class
방법:
Validation::ipV4()
036 이름: ip.v6
사용법: ip.v6		 입력이 IPv6 주소인지 확인합니다. 기인하다:
IpV6::class
방법:
Validation::ipV6()
037 이름: ip.notReserved
사용법: ip.notReserved		 입력이 예약된 IP 범위에 속하지 않는 IP 주소인지 확인합니다. 기인하다:
IpNotReserved::class
방법:
Validation::ipNotReserved()
038 이름: ip.notPrivate
사용법: ip.notPrivate		 입력이 개인 IP 범위에 속하지 않는 IP 주소인지 확인합니다. 기인하다:
IpNotPrivate::class
방법:
Validation::ipNotPrivate()
039 이름: mac
사용법: mac		 입력이 MAC 주소인지 확인합니다. 기인하다:
Mac::class
방법:
Validation::mac()
040 이름: url
사용법: url		 입력이 URL임을 확인합니다. 기인하다:
Url::class
방법:
Validation::url()
041 이름: url.withPath
사용법: url.withPath		 입력이 경로를 포함하는 URL인지 확인합니다. 기인하다:
UrlWithPath::class
방법:
Validation::urlWithPath()
042 이름: url.withQuery
사용법: url.withQuery		 입력이 쿼리를 포함하는 URL인지 확인합니다. 기인하다:
UrlWithQuery::class
방법:
Validation::urlWithQuery()
043 이름: email
사용법: email		 입력이 이메일 주소인지 확인합니다. 기인하다:
Email::class
방법:
Validation::email()
044 이름: email.withUnicode
사용법: email.withUnicode		 입력이 이메일 주소인지 확인합니다(유니코드 허용). 기인하다:
EmailWithUnicode::class
방법:
Validation::emailWithUnicode()
045 이름: domain
사용법: domain		 입력이 도메인임을 확인합니다. 기인하다:
Domain::class
방법:
Validation::domain()
046 이름: domain.isActive
사용법: domain.isActive		 입력이 활성 도메인임을 확인합니다. 도메인 및 이메일과 함께 작동합니다. 기인하다:
DomainIsActive::class
방법:
Validation::domainIsActive()
047 이름: file
사용법: file		 입력이 파일(파일, 링크 또는 디렉터리일 수 있음)인지 확인합니다. 기인하다:
File::class
방법:
Validation::file()
048 이름: file.isFile
사용법: file.isFile		 입력이 파일인지 확인합니다. 기인하다:
FileIsFile::class
방법:
Validation::fileIsFile()
049 이름: file.isLink
사용법: file.isLink		 입력이 링크임을 확인합니다. 기인하다:
FileIsLink::class
방법:
Validation::fileIsLink()
050 이름: file.isDirectory
사용법: file.isDirectory		 입력이 디렉터리임을 확인합니다. 기인하다:
FileIsDirectory::class
방법:
Validation::fileIsDirectory()
051 이름: file.isExecutable
사용법: file.isExecutable		 입력이 파일이고 실행 가능함을 확인합니다. 기인하다:
FileIsExecutable::class
방법:
Validation::fileIsExecutable()
052 이름: file.isWritable
사용법: file.isWritable		 입력이 파일이고 쓰기 가능하다는 것을 확인합니다. 기인하다:
FileIsWritable::class
방법:
Validation::fileIsWritable()
053 이름: file.isReadable
사용법: file.isReadable		 입력이 파일이고 읽을 수 있음을 확인합니다. 기인하다:
FileIsReadable::class
방법:
Validation::fileIsReadable()
054 이름: file.isUploaded
사용법: file.isUploaded		 입력이 HTTP POST를 통해 업로드된 파일인지 확인합니다. 기인하다:
FileIsUploaded::class
방법:
Validation::fileIsUploaded()
055 이름: file.size
사용법: file.size:1024		 입력이 파일이고 크기가 주어진 크기(바이트)와 같다고 확인합니다. 기인하다:
FileSize::class
방법:
Validation::fileSize(int $sizeInBytes)
056 이름: file.size.lte
사용법: file.size.lte:1024		 입력이 파일이고 크기가 지정된 크기(바이트)보다 작거나 같다고 확인합니다. 기인하다:
FileSizeLte::class
방법:
Validation::fileSizeLte(int $sizeInBytes)
057 이름: file.size.gte
사용법: file.size.gte:1024		 입력이 파일이고 크기가 지정된 크기(바이트)보다 크거나 같다고 확인합니다. 기인하다:
FileSizeGte::class
방법:
Validation::fileSizeGte(int $sizeInBytes)
058 이름: file.dirname
사용법: file.dirname:/path/to/dir		 입력이 파일이고 해당 dirname이 지정된 dirname과 동일하다고 확인합니다. 기인하다:
FileDirname::class
방법:
Validation::fileDirname(string $dirname)
059 이름: file.basename
사용법: file.basename:file.ext		 입력이 파일이고 해당 기본 이름이 주어진 기본 이름과 동일하다고 확인합니다. 기인하다:
FileBasename::class
방법:
Validation::fileBasename(string $basename)
060 이름: file.filename
사용법: file.filename:file		 입력이 파일이고 해당 파일 이름이 주어진 파일 이름과 같다고 확인합니다. 기인하다:
FileFilename::class
방법:
Validation::fileFilename(string $filename)
061 이름: file.extension
사용법: file.extension:ext		 입력이 파일이고 해당 확장자가 지정된 확장자와 동일하다고 확인합니다. 기인하다:
FileExtension::class
방법:
Validation::fileExtension(string $extension)
062 이름: file.mime
사용법: file.mime:text/plain		 입력이 파일이고 해당 MIME 유형이 지정된 MIME 유형 중 하나인지 확인합니다. 기인하다:
FileMime::class
방법:
Validation::fileMime(string|array $mine)
063 이름: image
사용법: image		 입력이 이미지 파일(jpg, jpeg, png, gif, bmp, svg 또는 webp)인지 확인합니다. 기인하다:
Image::class
방법:
Validation::image()
064 이름: image.width
사용법: image.width:1920		 입력이 이미지이고 너비가 주어진 픽셀 너비와 같다고 가정합니다. 기인하다:
ImageWidth::class
방법:
Validation::imageWidth(int $width)
065 이름: image.width.lte
사용법: image.width.lte:1920		 입력이 이미지이고 너비가 지정된 너비(픽셀)보다 작거나 같다고 확인합니다. 기인하다:
ImageWidthLte::class
방법:
Validation::imageWidthLte(int $width)
066 이름: image.width.gte
사용법: image.width.gte:1920		 입력이 이미지이고 너비가 지정된 너비(픽셀)보다 크거나 같다고 확인합니다. 기인하다:
ImageWidthGte::class
방법:
Validation::imageWidthGte(int $width)
067 이름: image.height
사용법: image.height:1080		 입력이 이미지이고 높이가 주어진 픽셀 높이와 같다고 가정합니다. 기인하다:
ImageHeight::class
방법:
Validation::imageHeight(int $height)
068 이름: image.height.lte
사용법: image.height.lte:1080		 입력이 이미지이고 높이가 지정된 높이(픽셀)보다 작거나 같다고 확인합니다. 기인하다:
ImageHeightLte::class
방법:
Validation::imageHeightLte(int $height)
069 이름: image.height.gte
사용법: image.height.gte:1080		 입력이 이미지이고 높이가 주어진 픽셀 높이보다 크거나 같다고 확인합니다. 기인하다:
ImageHeightGte::class
방법:
Validation::imageHeightGte(int $height)
070 이름: image.dimensions
사용법: image.dimensions:1920,1080,==		 입력이 이미지이고 크기가 주어진 너비와 높이(픽셀)보다 작거나 같거나 크다고 가정합니다. 기인하다:
ImageDimensions::class
방법:
Validation::imageDimensions(int $width, int $height, string $operator = '==')
071 이름: image.ratio
사용법: image.ratio:16:9		 입력이 이미지이고 종횡비가 주어진 비율과 같다고 가정합니다(비율은 "16/9"와 같이 분수로 지정되어야 함). 기인하다:
ImageRatio::class
방법:
Validation::imageRatio(string $ratio)
072 이름: if
사용법: if:7,7,==		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인하며, 조건 연산자를 세 번째 인수로 지정할 수도 있습니다. 기인하다:
IfConstraint::class
방법:
Validation::if(mixed $actual, mixed $expected = true, string $operator = '==')
073 이름: if.eq
사용법: if.eq:3,3		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 "=="입니다. 기인하다:
IfEq::class
방법:
Validation::ifEq(mixed $actual, mixed $expected)
074 이름: if.neq
사용법: if.neq:1,2		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 "!="입니다. 기인하다:
IfNeq::class
방법:
Validation::ifNeq(mixed $actual, mixed $expected)
075 이름: if.id
사용법: if.id:3,3		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 "==="입니다. 기인하다:
IfId::class
방법:
Validation::ifId(mixed $actual, mixed $expected)
076 이름: if.nid
사용법: if.nid:1,2		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 "!=="입니다. 기인하다:
IfNid::class
방법:
Validation::ifNid(mixed $actual, mixed $expected)
077 이름: if.gt
사용법: if.gt:2,1		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 ">"입니다. 기인하다:
IfGt::class
방법:
Validation::ifGt(mixed $actual, mixed $expected)
078 이름: if.gte
사용법: if.gte:2,2		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 ">="입니다. 기인하다:
IfGte::class
방법:
Validation::ifGte(mixed $actual, mixed $expected)
079 이름: if.lt
사용법: if.lt:1,2		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 "<"입니다. 기인하다:
IfLt::class
방법:
Validation::ifLt(mixed $actual, mixed $expected)
080 이름: if.lte
사용법: if.lte:1,2		 첫 번째 인수와 두 번째 인수 사이의 조건을 확인합니다. 조건 연산자는 "<="입니다. 기인하다:
IfLte::class
방법:
Validation::ifLte(mixed $actual, mixed $expected)
081 이름: empty
사용법: empty		 empty() 언어 구성을 사용하여 입력이 비어 있음을 확인합니다(비어 있음, 즉 빈 문자열, 빈 배열, false, null 또는 0). 기인하다:
EmptyConstraint::class
방법:
Validation::empty()
082 이름: required
사용법: required		 입력이 필수임을 확인합니다(공백이 아님, 즉 빈 문자열 또는 null이 아님). 기인하다:
Required::class
방법:
Validation::required()
083 이름: allowed
사용법: allowed		 입력이 허용됨을 확인합니다(비어 있거나 임의의 값을 가질 수 있으며, null 및 빈 문자열은 유효한 값으로 간주됩니다). 기인하다:
Allowed::class
방법:
Validation::allowed()
084 이름: forbidden
사용법: forbidden		 입력이 금지되어 있음(null이거나 존재하지 않음)을 확인합니다. 기인하다:
Forbidden::class
방법:
Validation::forbidden()
085 이름: accepted
사용법: accepted		 입력이 승인되었는지 확인합니다(동일: "on", "yes", "yeah", "yep", "yo", "ok", "okay", "aye", 1 또는 "1", true 또는 " true") 문자열은 대소문자를 구분하지 않고 처리됩니다. 기인하다:
Accepted::class
방법:
Validation::accepted()
086 이름: declined
사용법: declined		 입력이 거부되었음을 확인합니다(동일: "off", "no", "not", "nope", "neh", "nay", 0 또는 "0", false 또는 "false"). 문자열이 처리된다는 점에 유의하세요. 대소문자를 구분하지 않습니다. 기인하다:
Declined::class
방법:
Validation::declined()
087 이름: bit
용법: bit		 입력이 비트인지 확인합니다(동일: 1 또는 "1", true, 0 또는 "0", false). 기인하다:
Bit::class
방법:
Validation::bit()
088 이름: bit.isOn
사용법: bit.isOn		 입력이 켜진 비트인지 확인합니다(동일: true, 1 또는 "1"). 기인하다:
BitIsOn::class
방법:
Validation::bitIsOn()
089 이름: bit.isOff
사용법: bit.isOff		 입력이 꺼진 비트인지 확인합니다(동일: false, 0 또는 "0"). 기인하다:
BitIsOff::class
방법:
Validation::bitIsOff()
090 이름: equals
사용법: equals:value		 입력이 주어진 값과 같다고 주장합니다. 스칼라 유형 및 null과 함께 작동합니다. 비교 연산자는 "=="입니다. 기인하다:
Equals::class
방법:
Validation::equals(string|int|float|bool|null $value)
091 이름: matches
사용법: matches:'"/^[a-zA-Z0-9]+$/"'		 입력이 주어진 패턴과 일치하는지 확인합니다. 문자열에서만 작동합니다. 기인하다:
Matches::class
방법:
Validation::matches(string $pattern)
092 이름: in
사용법: in:val1,val2,...		 입력이 주어진 값에 있는지 확인합니다. 스칼라 유형 및 null과 함께 작동합니다. 기인하다:
In::class
방법:
Validation::in(string|int|float|bool|null ...$values)
093 이름: count
사용법: count:3		 입력 개수가 주어진 값과 같은지 확인합니다. 모든 데이터 유형에서 작동합니다(null: 0; 부울: 0 또는 1; 부동 소수점/정수: 숫자 값; 문자열: 문자 수; 배열/가산 가능: 요소 수; 객체: 액세스 가능한 속성 수). 기인하다:
Count::class
방법:
Validation::count(int $count)
094 이름: min
사용량: min:3		 입력 개수가 주어진 값보다 크거나 같다고 확인합니다. 모든 데이터 유형에서 작동합니다(null: 0; 부울: 0 또는 1; 부동 소수점/정수: 숫자 값; 문자열: 문자 수; 배열/가산 가능: 요소 수; 객체: 액세스 가능한 속성 수). 기인하다:
Min::class
방법:
Validation::min(int|float $count)
095 이름: max
사용법: max:3		 입력 개수가 주어진 값보다 작거나 같다고 확인합니다. 모든 데이터 유형에서 작동합니다(null: 0; 부울: 0 또는 1; 부동 소수점/정수: 숫자 값; 문자열: 문자 수; 배열/가산 가능: 요소 수; 객체: 액세스 가능한 속성 수). 기인하다:
Max::class
방법:
Validation::max(int|float $count)
096 이름: between
사용법: between:3,7		 입력 개수가 주어진 값 사이에 있는지 확인합니다. 모든 데이터 유형에서 작동합니다(null: 0; 부울: 0 또는 1; 부동 소수점/정수: 숫자 값; 문자열: 문자 수; 배열/가산 가능: 요소 수; 객체: 액세스 가능한 속성 수). 기인하다:
Between::class
방법:
Validation::between(int|float $min, int|float $max)
097 이름: number.isPositive
사용법: number.isPositive		 입력이 양수인지 확인합니다. 기인하다:
NumberIsPositive::class
방법:
Validation::numberIsPositive()
098 이름: number.isNegative
사용법: number.isNegative		 입력이 음수인지 확인합니다. 기인하다:
NumberIsNegative::class
방법:
Validation::numberIsNegative()
099 이름: number.isEven
사용법: number.isEven		 입력이 짝수인지 확인합니다. 기인하다:
NumberIsEven::class
방법:
Validation::numberIsEven()
100 이름: number.isOdd
사용법: number.isOdd		 입력이 홀수인지 확인합니다. 기인하다:
NumberIsOdd::class
방법:
Validation::numberIsOdd()
101 이름: number.isMultipleOf
사용법: number.isMultipleOf:3		 입력이 주어진 숫자의 배수인지 확인합니다. 기인하다:
NumberIsMultipleOf::class
방법:
Validation::numberIsMultipleOf(float $number)
102 이름: number.isFinite
사용법: number.isFinite		 입력이 유한수임을 확인합니다. 기인하다:
NumberIsFinite::class
방법:
Validation::numberIsFinite()
103 이름: number.isInfinite
사용법: number.isInfinite		 입력이 무한한 숫자임을 확인합니다. 기인하다:
NumberIsInfinite::class
방법:
Validation::numberIsInfinite()
104 이름: number.isNan
사용법: number.isNan		 입력이 숫자가 아니라고 어설션합니다. 기인하다:
NumberIsNan::class
방법:
Validation::numberIsNan()
105 이름: string.charset
사용법: string.charset:UTF-8		 입력이 주어진 문자 세트(별칭 포함) 중 하나로 인코딩되어 있는지 확인합니다. 확인은 대소문자를 구분하여 수행됩니다. 기인하다:
StringCharset::class
방법:
Validation::stringCharset(string|array $charset)
106 이름: string.contains
사용법: string.contains:substring		 입력에 주어진 하위 문자열이 포함되어 있는지 확인합니다. 두 번째 부울 인수를 지정하여 엄격 모드(대소문자 구분)를 활성화할 수 있습니다. 기인하다:
StringContains::class
방법:
Validation::stringContains(string $substring, bool $strict = false)
107 이름: string.startsWith
사용법: string.startsWith:substring,1		 입력이 주어진 하위 문자열로 시작하는지 확인합니다. 두 번째 부울 인수를 지정하여 엄격 모드(대소문자 구분)를 활성화할 수 있습니다. 기인하다:
StringStartsWith::class
방법:
Validation::stringStartsWith(string $substring, bool $strict = false)
108 이름: string.endsWith
사용법: string.endsWith:substring,0		 입력이 주어진 하위 문자열로 끝나는 것을 확인합니다. 두 번째 부울 인수를 지정하여 엄격 모드(대소문자 구분)를 활성화할 수 있습니다. 기인하다:
StringEndsWith::class
방법:
Validation::stringEndsWith(string $substring, bool $strict = false)
109 이름: string.length
사용법: string.length:3		 입력이 주어진 길이와 정확히 일치하는 문자열인지 확인합니다. 기인하다:
StringLength::class
방법:
Validation::stringLength(int $length)
110 이름: string.wordsCount
사용법: string.wordsCount:3		 입력이 주어진 단어 수를 정확히 포함하는 문자열인지 확인합니다. 기인하다:
StringWordsCount::class
방법:
Validation::stringWordsCount(int $count)
111 이름: array.hasKey
사용법: array.hasKey:key		 입력 배열에 지정된 키가 있는지 확인합니다. 기인하다:
ArrayHasKey::class
방법:
Validation::arrayHasKey(string|int $key)
112 이름: array.hasValue
사용법: array.hasValue:value		 입력 배열에 주어진 값이 포함되어 있는지 확인합니다. 스칼라 유형과 함께 작동합니다. 기인하다:
ArrayHasValue::class
방법:
Validation::arrayHasValue(mixed $value)
113 이름: array.hasDistinct
사용법: array.hasDistinct:key		 입력이 주어진 키의 고유한 값을 포함하는 다차원 배열인지 확인합니다. 기인하다:
ArrayHasDistinct::class
방법:
Validation::arrayHasDistinct(string|int $key)
114 이름: array.isAssociative
사용법: array.isAssociative		 입력이 연관 배열임을 확인합니다. 기인하다:
ArrayIsAssociative::class
방법:
Validation::arrayIsAssociative()
115 이름: array.isSequential
사용법: array.isSequential		 입력이 순차 배열임을 확인합니다. 기인하다:
ArrayIsSequential::class
방법:
Validation::arrayIsSequential()
116 이름: array.isUnique
사용법: array.isUnique		 입력 배열에 고유한 값이 포함되어 있는지 확인합니다. 1차원 배열에서만 작동합니다. 기인하다:
ArrayIsUnique::class
방법:
Validation::arrayIsUnique()
117 이름: array.subset
사용법: array.subset:'{"a":1,"b":2}'		 입력이 주어진 하위 집합을 포함하는 배열인지 확인합니다. 이 검사는 배열의 첫 번째 차원에만 적용됩니다. 기인하다:
ArraySubset::class
방법:
Validation::arraySubset(array $subset)
118 이름: object.hasProperty
사용법: object.hasProperty:property		 입력에 지정된 속성이 있는지 확인합니다. 기인하다:
ObjectHasProperty::class
방법:
Validation::objectHasProperty(string $property)
119 이름: object.hasMethod
사용법: object.hasMethod:method		 입력에 지정된 메서드가 있는지 확인합니다. 기인하다:
ObjectHasMethod::class
방법:
Validation::objectHasMethod(string $method)
120 이름: object.isStringable
사용법: object.isStringable		 입력이 __toString() 메서드를 구현하는지 확인합니다. 기인하다:
ObjectIsStringable::class
방법:
Validation::objectIsStringable()
121 이름: object.isInstanceOf
사용법: object.isInstanceOf:NamespaceClass		 입력이 지정된 클래스의 인스턴스인지 확인합니다. 기인하다:
ObjectIsInstanceOf::class
방법:
Validation::objectIsInstanceOf(string $classFQN)
122 이름: object.isSubclassOf
사용법: object.isSubclassOf:NamespaceClass		 입력이 지정된 클래스의 하위 클래스인지 확인합니다. 기인하다:
ObjectIsSubclassOf::class
방법:
Validation::objectIsSubclassOf(string $classFQN)
123 이름: serialized
사용법: serialized		 입력이 유효한 PHP 직렬화 데이터인지 확인합니다. 기인하다:
Serialized::class
방법:
Validation::serialized()
124 이름: json
사용법: json		 입력이 유효한 JSON인지 확인합니다. 기인하다:
Json::class
방법:
Validation::json()
125 이름: base64
사용법: base64		 입력이 유효한 Base64 인코딩 문자열인지 확인합니다. 기인하다:
Base64::class
방법:
Validation::base64()
126 이름: xml
사용법: xml		 입력이 유효한 XML인지 확인합니다. 기인하다:
Xml::class
방법:
Validation::xml()
127 이름: locale
사용법: locale		 입력이 유효한 로케일 식별자인지 확인합니다(기본값: [ISO 639-1] 또는 [ISO 639-1]_[ISO 3166-1 alpha-2], 대소문자를 구분하지 않음, 입력은 확인하기 전에 정규화됩니다(밑줄로 대시, 점이나 문자 집합 없음), 엄격함: [ISO 639-1] 또는 [ISO 639-1]_[ISO 3166-1 alpha-2], 표준화 없이 대소문자를 구분합니다. 기인하다:
Locale::class
방법:
Validation::locale(bool $strict = false)
128 이름: language
용법: language		 입력이 유효한 언어 코드인지 확인합니다(기본값: "ISO 639-1", 긴: "ISO 639-2/T"). 기인하다:
Language::class
방법:
Validation::language(bool $long = false)
129 이름: country
용법: country		 입력이 유효한 국가 코드인지 확인합니다(기본값: "ISO 3166-1 alpha-2", 긴: "ISO 3166-1 alpha-3"). 기인하다:
Country::class
방법:
Validation::country(bool $long = false)
130 이름: timezone
사용법: timezone		 입력이 유효한 시간대 식별자인지 확인합니다(기본값: 대소문자 구분 안 함, 엄격함: 대소문자 구분). 기인하다:
Timezone::class
방법:
Validation::timezone(bool $strict = false)
131 이름: datetime
사용법: datetime		 입력이 유효한 날짜/시간 문자열/객체인지 확인합니다. 기인하다:
Datetime::class
방법:
Validation::datetime()
132 이름: datetime.eq
사용법: datetime.eq:"2015-01-01"		 입력이 주어진 날짜/시간 문자열과 동일한지 확인합니다. 기인하다:
DatetimeEq::class
방법:
Validation::datetimeEq(string $datetime)
133 이름: datetime.lt
사용법: datetime.lt:tomorrow :내일		 입력이 주어진 날짜/시간 문자열보다 작은(이전) 날짜/시간 문자열/객체인지 확인합니다. 기인하다:
DatetimeLt::class
방법:
Validation::datetimeLt(string $datetime)
134 이름: datetime.lte
사용법: datetime.lte:tomorrow		 입력이 주어진 날짜/시간 문자열보다 작거나(이전) 같은 날짜/시간 문자열/객체인지 확인합니다. 기인하다:
DatetimeLte::class
방법:
Validation::datetimeLte(string $datetime)
135 이름: datetime.gt
사용법: datetime.gt:today		 입력이 주어진 날짜/시간 문자열보다 큰(이후) 날짜/시간 문자열/객체인지 확인합니다. 기인하다:
DatetimeGt::class
방법:
Validation::datetimeGt(string $datetime)
136 이름: datetime.gte
사용법: datetime.gte:today		 입력이 주어진 날짜 시간 문자열보다 크거나 같은 날짜 시간 문자열/객체인지 확인합니다. 기인하다:
DatetimeGte::class
방법:
Validation::datetimeGte(string $datetime)
137 이름: datetime.birthday
사용법: datetime.birthday		 입력이 오늘 생일인 날짜/시간 문자열/객체인지 확인합니다. 입력은 "YYYY-MM-DD" 형식을 따르는 것이 좋습니다. 기인하다:
DatetimeBirthday::class
방법:
Validation::datetimeBirthday()
138 이름: datetime.format
사용법: datetime.format:"Ymd H:i:s"		 입력이 주어진 형식의 유효한 날짜/시간인지 확인합니다. 기인하다:
DatetimeFormat::class
방법:
Validation::datetimeFormat(string $format)
139 이름: datetime.format.global
사용법: datetime.format.global		 입력이 HTML5 사양에 정의된 유효한 전역 날짜/시간 문자열처럼 보이는지 확인합니다. 기인하다:
DatetimeFormatGlobal::class
방법:
Validation::datetimeFormatGlobal()
140 이름: datetime.format.local
사용법: datetime.format.local		 입력이 HTML5 사양에 정의된 유효한 로컬 날짜/시간 문자열처럼 보이는지 확인합니다. 기인하다:
DatetimeFormatLocal::class
방법:
Validation::datetimeFormatLocal()
141 이름: datestamp
사용법: datestamp		 입력이 점, 대시 또는 슬래시로 구분된 휴먼 날짜 스탬프, DMY 또는 MDY 형식처럼 보이는지 확인합니다. 기인하다:
Datestamp::class
방법:
Validation::datestamp()
142 이름: datestamp.ymd
사용법: datestamp.ymd		 입력이 점, 대시 또는 슬래시로 구분된 인간 YMD 형식의 날짜 스탬프처럼 보이는지 확인합니다. 기인하다:
DatestampYmd::class
방법:
Validation::datestampYmd()
143 이름: datestamp.dmy
사용법: datestamp.dmy		 입력이 점, 대시 또는 슬래시로 구분된 인간 DMY 형식의 날짜 스탬프처럼 보이는지 확인합니다. 기인하다:
DatestampDmy::class
방법:
Validation::datestampDmy()
144 이름: datestamp.mdy
사용법: datestamp.mdy		 입력이 점, 대시 또는 슬래시로 구분된 인간 MDY 형식의 날짜 스탬프처럼 보이는지 확인합니다. 기인하다:
DatestampMdy::class
방법:
Validation::datestampMdy()
145 이름: timestamp
사용법: timestamp		 입력이 초 유무에 관계없이 24시간 또는 12시간 형식의 인간 타임스탬프처럼 보이는지 확인합니다. 기인하다:
Timestamp::class
방법:
Validation::timestamp()
146 이름: timestamp.12
사용법: timestamp.12		 입력이 사람의 타임스탬프, 초 유무에 관계없이 12시간 형식 및 선택적 AM/PM처럼 보이는지 확인합니다. 기인하다:
Timestamp12::class
방법:
Validation::timestamp12()
147 이름: timestamp.hms
사용법: timestamp.hms		 입력이 초 단위의 24시간 또는 12시간 형식의 인간 타임스탬프처럼 보이는지 확인합니다. 기인하다:
TimestampHms::class
방법:
Validation::timestampHms()
148 이름: timestamp.hm
사용법: timestamp.hm		 입력이 초가 없는 24시간 또는 12시간 형식의 인간 타임스탬프처럼 보이는지 확인합니다. 기인하다:
TimestampHm::class
방법:
Validation::timestampHm()
149 이름: timestamp.ms
사용법: timestamp.ms		 입력이 분과 초만 포함하는 인간의 타임스탬프처럼 보이는지 확인합니다. 기인하다:
TimestampMs::class
방법:
Validation::timestampMs()
150 이름: calender.day
사용법: calender.day		 입력이 달력 날짜 또는 긴 형식("월" 또는 "월요일")처럼 보이는지 확인합니다. 기인하다:
CalenderDay::class
방법:
Validation::calenderDay()
151 이름: calender.month
사용법: calender.month		 입력이 샷 또는 긴 형식("1월" 또는 "1월")의 달력 월처럼 표시되는지 확인합니다. 기인하다:
CalenderMonth::class
방법:
Validation::calenderMonth()
152 이름: username
사용법: username		 입력이 유효한 사용자 이름(4-32자 사이, 문자로 구성, 선택적으로 숫자, 선택적으로 다음 문자 "-_." 중 하나)(연속 아님)인지 확인하고 항상 문자로 시작하고 끝나야 합니다. 문자나 숫자로). 기인하다:
Username::class
방법:
Validation::username()
153 이름: password
사용법: password		 입력이 유효한 비밀번호(최소 8자, 최소 하나의 소문자와 하나의 대문자, 최소 하나의 숫자, 최소 하나의 특수 문자 및 선택적으로 공백으로 구성됨)인지 확인합니다. 기인하다:
Password::class
방법:
Validation::password()
154 이름: uuid
사용법: uuid		 입력이 유효한 UUID인지 확인합니다. 버전(v1/v2/v3/v4/v5)을 지정하여 패턴을 좁힐 수 있습니다. 기인하다:
Uuid::class
방법:
Validation::uuid(string|int|null $version = null)
155 이름: ascii
사용법: ascii		 입력이 ASCII 문자만 포함하는 문자열(ASCII 호환 문자열)인지 확인합니다. 기인하다:
Ascii::class
방법:
Validation::ascii()
156 이름 : slug
용법: slug		 입력이 유효한 슬러그인지 확인합니다. 기인하다:
Slug::class
방법:
Validation::slug()
157 이름: meta
사용법: meta		 입력이 메타 문자(특수 문자)(예: "@, #, $, ...")만 포함하는 문자열인지 확인합니다. 기인하다:
Meta::class
방법:
Validation::meta()
158 이름: text
사용법: text		 입력이 모든 언어의 문자와 구두점을 포함하는 문자열인지 확인합니다. 기인하다:
Text::class
방법:
Validation::text()
159 이름: words
사용법: words		 입력이 다른 문자 없이 단어와 공백만 포함하는 문자열임을 확인합니다. 기인하다:
Words::class
방법:
Validation::words()
160 이름: spaceless
용법: spaceless		 입력이 공백 문자를 포함하지 않는 문자열인지 확인합니다. 기인하다:
Spaceless::class
방법:
Validation::spaceless()
161 이름: emoji
사용법: emoji		 입력에 이모티콘이 포함되어 있는지 확인합니다. 기인하다:
Emoji::class
방법:
Validation::emoji()
162 이름: roman
용법: roman		 입력이 유효한 로마 숫자인지 확인합니다. 기인하다:
Roman::class
방법:
Validation::roman()
163 이름: phone
사용법: phone		 입력이 유효한 전화번호인지 확인합니다(지원: 북미, 유럽, 대부분의 아시아 및 중동 국가). 기인하다:
Phone::class
방법:
Validation::phone()
164 이름: geolocation
용법: geolocation		 입력이 유효한 지리적 위치(위도 및 경도 좌표 조합)인지 확인합니다. 기인하다:
Geolocation::class
방법:
Validation::geolocation()
165 이름: version
사용법: version		 입력이 유효한 의미 버전 번호인지 확인합니다. 기인하다:
Version::class
방법:
Validation::version()
166 이름: amount
용법: amount		 입력에 숫자, 선택적 소수점(쉼표 또는 점) 및 선택적 빼기(예: 금액에 사용됨)만 포함되어 있는지 확인합니다. 기인하다:
Amount::class
방법:
Validation::amount()
167 이름: amount.dollar
사용법: amount.dollar		 입력이 유효한 형식의 USD 금액임을 확인합니다. 여기서 소수점 및 천 단위 구분 기호는 선택 사항입니다. 기인하다:
AmountDollar::class
방법:
Validation::amountDollar()
168 이름: amount.euro
사용법: amount.euro		 입력이 유효한 형식의 EUR 금액임을 확인합니다. 여기서 소수점 및 천 단위 구분 기호는 선택 사항입니다. 기인하다:
AmountEuro::class
방법:
Validation::amountEuro()
169 이름: color
용법: color		 입력이 유효한 CSS 색상(키워드 "느슨한", HEX, HEX-Alpha, RGB, RGBA, RGB "새 구문", HSL, HSLA, HSL "새 구문")인지 확인합니다. 기인하다:
Color::class
방법:
Validation::color()
170 이름: color.hex
사용법: color.hex		 입력이 유효한 CSS HEX 색상인지 확인합니다. 기인하다:
ColorHex::class
방법:
Validation::colorHex()
171 이름: color.hexShort
사용법: color.hexShort		 입력이 유효한 CSS 3-Char-HEX 색상인지 확인합니다. 기인하다:
ColorHexShort::class
방법:
Validation::colorHexShort()
172 이름: color.hexLong
사용법: color.hexLong		 입력이 유효한 CSS 6-Char-HEX 색상인지 확인합니다. 기인하다:
ColorHexLong::class
방법:
Validation::colorHexLong()
173 이름: color.hexAlpha
사용법: color.hexAlpha		 입력이 유효한 CSS HEX-Alpha(4자 또는 8자) 색상인지 확인합니다. 기인하다:
ColorHexAlpha::class
방법:
Validation::colorHexAlpha()
174 이름: color.rgb
사용법: color.rgb		 입력이 유효한 CSS RGB 색상인지 확인합니다. 기인하다:
ColorRgb::class
방법:
Validation::colorRgb()
175 이름: color.rgba
사용법: color.rgba		 입력이 유효한 CSS RGBA 색상인지 확인합니다. 기인하다:
ColorRgba::class
방법:
Validation::colorRgba()
176 이름: color.rgb.new
사용법: color.rgb.new		 입력이 유효한 CSS4 RGB 색상인지 확인합니다. 기인하다:
ColorRgbNew::class
방법:
Validation::colorRgbNew()
177 이름: color.hsl
사용법: color.hsl		 입력이 유효한 CSS HSL 색상인지 확인합니다. 기인하다:
ColorHsl::class
방법:
Validation::colorHsl()
178 이름: color.hsla
사용법: color.hsla		 입력이 유효한 CSS HSLA 색상인지 확인합니다. 기인하다:
ColorHsla::class
방법:
Validation::colorHsla()
179 이름: color.hsl.new
사용법: color.hsl.new		 입력이 유효한 CSS4 HSL 색상인지 확인합니다. 기인하다:
ColorHslNew::class
방법:
Validation::colorHslNew()
180 이름: color.keyword
사용법 : color.keyword		 입력이 유효한 CSS 키워드 색상이라고 주장합니다 (CSS 사양에서와 같이 엄격). 기인하다:
ColorKeyword::class
방법:
Validation::colorKeyword()
181 이름 : ssn
사용법 : ssn		 입력이 유효한 SSN (미국 사회 보장 번호)이라고 주장합니다. 기인하다:
Ssn::class
방법:
Validation::ssn()
182 이름 : sin
사용법 : sin		 입력이 유효한 죄 (CA 사회 보험 번호)라고 주장합니다. 기인하다:
Sin::class
방법:
Validation::sin()
183 이름 : nino
사용법 : nino		 입력이 유효한 NINO (영국 국민 보험 번호)라고 주장합니다. 기인하다:
Nino::class
방법:
Validation::nino()
184 이름 : vin
사용법 : vin		 입력이 유효한 Vin (차량 식별 번호)이라고 주장합니다. 기인하다:
Vin::class
방법:
Validation::vin()
185 이름 : issn
사용법 : issn		 입력이 유효한 ISSN (국제 표준 일련 번호)이라고 주장합니다. 기인하다:
Issn::class
방법:
Validation::issn()
186 이름 : isin
사용법 : isin		 입력이 유효한 ISIN (국제 증권 식별 번호)이라고 주장합니다. 기인하다:
Isin::class
방법:
Validation::isin()
187 이름 : isbn
사용법 : isbn		 입력이 유효한 ISBN (국제 표준 도서 번호)이라고 주장합니다. 패턴을 좁히기 위해 유형 (10/13)을 지정할 수 있습니다. 기인하다:
Isbn::class
방법:
Validation::isbn(string|int|null $type = null)
188 이름 : imei
사용법 : imei		 입력이 유효한 IMEI (국제 모바일 스테이션 장비 식별 번호)라고 주장합니다. 기인하다:
Imei::class
방법:
Validation::imei()
189 이름 : imei.sv
사용법 : imei.sv		 입력이 유효한 IMEI-SV (국제 모바일 스테이션 장비 ID 및 소프트웨어 버전 번호)라고 주장합니다. 기인하다:
ImeiSv::class
방법:
Validation::imeiSv()
190 이름 : meid
사용법 : meid		 입력이 유효한 Meid (모바일 장비 식별자)라고 주장합니다. 기인하다:
Meid::class
방법:
Validation::meid()
191 이름 : esn
사용법 : esn		 입력이 유효한 ESN (전자 일련 번호)이라고 주장합니다. 기인하다:
Esn::class
방법:
Validation::esn()
192 이름 : currency
사용법 : currency		 입력이 유효한 통화 코드라고 주장합니다 (기본값 : "ISO 4217 Alpha"; 숫자 : "ISO 4217 숫자"). 기인하다:
Currency::class
방법:
Validation::currency(bool $numeric = false)
193 이름 : currency.name
사용법 : currency.name		 입력이 유효한 통화 이름이라고 주장합니다 (ISO 4217에서와 같이). 기인하다:
CurrencyName::class
방법:
Validation::currencyName()
194 이름 : creditcard
사용법 : creditcard		 입력이 유효한 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
Creditcard::class
방법:
Validation::creditcard()
195 이름 : creditcard.visa
사용법 : creditcard.visa		 입력이 유효한 비자 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardVisa::class
방법:
Validation::creditcardVisa()
196 이름 : creditcard.mastercard
사용법 : creditcard.mastercard		 입력이 유효한 마스터 카드 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardMastercard::class
방법:
Validation::creditcardMastercard()
197 이름 : creditcard.discover
사용법 : creditcard.discover		 입력이 유효한 발견 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardDiscover::class
방법:
Validation::creditcardDiscover()
198 이름 : creditcard.americanExpress
사용법 : creditcard.americanExpress		 입력이 유효한 American Express 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardAmericanExpress::class
방법:
Validation::creditcardAmericanExpress()
199 이름 : creditcard.dinersClub
사용법 : creditcard.dinersClub		 입력이 유효한 식당 클럽 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardDinersClub::class
방법:
Validation::creditcardDinersClub()
200 이름 : creditcard.jcb
사용법 : creditcard.jcb		 입력이 유효한 JCB 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardJcb::class
방법:
Validation::creditcardJcb()
201 이름 : creditcard.maestro
사용법 : creditcard.maestro		 입력이 유효한 마에스트로 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardMaestro::class
방법:
Validation::creditcardMaestro()
202 이름 : creditcard.chinaUnionPay
사용법 : creditcard.chinaUnionPay		 입력이 유효한 China UnionPay 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardChinaUnionPay::class
방법:
Validation::creditcardChinaUnionPay()
203 이름 : creditcard.instaPayment
사용법 : creditcard.instaPayment		 입력이 유효한 Instapayment 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardInstaPayment::class
방법:
Validation::creditcardInstaPayment()
204 이름 : creditcard.laser
사용법 : creditcard.laser		 입력이 유효한 레이저 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardLaser::class
방법:
Validation::creditcardLaser()
205 이름 : creditcard.uatp
사용법 : creditcard.uatp		 입력이 유효한 UATP 신용 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardUatp::class
방법:
Validation::creditcardUatp()
206 이름 : creditcard.mir
사용법 : creditcard.mir		 입력이 유효한 miR 지불 시스템 카드 번호, 균형 공간 및/또는 대시가 허용된다고 주장합니다. 기인하다:
CreditcardMir::class
방법:
Validation::creditcardMir()
207 이름 : cvv
사용법 : cvv		 입력이 유효한 CVV (카드 보안 코드)라고 주장합니다. 기인하다:
Cvv::class
방법:
Validation::cvv()
208 이름 : bic
사용법 : bic		 입력이 유효한 BIC (은행 식별자 코드)라고 주장합니다. 기인하다:
Bic::class
방법:
Validation::bic()
209 이름 : iban
사용법 : iban:IQ		 입력이 유효한 IBAN (국제 은행 계좌 번호)이라고 주장합니다. "ISO 3166-1 Alpha-2"국가 코드는 패턴을 좁히기 위해 지정할 수 있습니다. 기인하다:
Iban::class
방법:
Validation::iban(?string $country = null)
210 이름 : luhn
사용법 : luhn		 입력이 Luhn 알고리즘 점검을 통과한다고 주장합니다. 이 규칙은 주로 주제의 유효성을 추가로 확인하기 위해 신용 카드 번호 및 식별자와 같은 다른 규칙과 함께 사용됩니다. 기인하다:
Luhn::class
방법:
Validation::luhn()
211 이름 : php.keyword
사용법 : php.keyword		 입력이 PHP 언어 키워드라고 주장합니다. 기인하다:
PhpKeyword::class
방법:
Validation::phpKeyword()
212 이름 : php.reserved
사용법 : php.reserved		 입력은 PHP 언어 예약 단어라고 주장합니다. 기인하다:
PhpReserved::class
방법:
Validation::phpReserved()
213 이름 : php.reserved.extra
사용법 : php.reserved.extra		 입력은 소프트 예약 단어를 포함한 PHP 언어 예약 단어라고 주장합니다. 기인하다:
PhpReservedExtra::class
방법:
Validation::phpReservedExtra()
214 이름 : regex
사용법 : regex		 입력이 유효한 정규식이라고 주장합니다. 기인하다:
Regex::class
방법:
Validation::regex()
215 이름 : bool
사용법 : boolean 참조		 별명, 전체 설명은 boolean 을 참조하십시오. 기인하다:
BoolConstraint::class
방법:
Validation::bool()
216 이름 : int
사용법 : integer 참조하십시오		 별명, 전체 설명은 integer 를 참조하십시오. 기인하다:
IntConstraint::class
방법:
Validation::int()
217 이름 : long
사용법 : integer 참조하십시오		 별명, 전체 설명은 integer 를 참조하십시오. 기인하다:
Long::class
방법:
Validation::long()
218 이름 : double
사용법 : float 참조하십시오		 별칭, 전체 설명은 float 를 참조하십시오. 기인하다:
Double::class
방법:
Validation::double()
219 이름 : real
사용법 : float 참조하십시오		 별칭, 전체 설명은 float 를 참조하십시오. 기인하다:
Real::class
방법:
Validation::real()
220 이름 : str
사용법 : string 참조하십시오		 별칭, 전체 설명은 string 을 참조하십시오. 기인하다:
Str::class
방법:
Validation::str()
221 이름 : arr
사용법 : array 참조하십시오		 별칭, 전체 설명은 array 을 참조하십시오. 기인하다:
Arr::class
방법:
Validation::arr()
222 이름 : obj
사용법 : object 참조하십시오		 별칭, 전체 설명은 object 를 참조하십시오. 기인하다:
Obj::class
방법:
Validation::obj()
223 이름 : stream
사용법 : resource 참조하십시오		 별명, 전체 설명은 resource 를 참조하십시오. 기인하다:
Stream::class
방법:
Validation::stream()
224 이름 : assert
if :		 별명, 전체 설명은 if 를 참조하십시오. 기인하다:
Assert::class
방법:
Validation::assert(mixed $actual, mixed $expected = true, string $operator = '==')
225 이름 : assert.equals
사용법 : if.eq 참조		 별칭, 전체 설명은 if.eq 를 참조하십시오. 기인하다:
AssertEquals::class
방법:
Validation::assertEquals(mixed $actual, mixed $expected)
226 이름 : assert.notEquals
사용법 : if.neq 참조하십시오		 별명, 전체 설명은 if.neq 를 참조하십시오. 기인하다:
AssertNotEquals::class
방법:
Validation::assertNotEquals(mixed $actual, mixed $expected)
227 이름 : assert.greaterThan
사용법 : if.gt 참조		 별명, 전체 설명은 if.gt 를 참조하십시오. 기인하다:
AssertGreaterThan::class
방법:
Validation::assertGreaterThan(mixed $actual, mixed $expected)
228 이름 : assert.greaterThanOrEquals
사용법 : if.gte 참조하십시오		 별명, 전체 설명은 if.gte 를 참조하십시오. 기인하다:
AssertGreaterThanOrEquals::class
방법:
Validation::assertGreaterThanOrEquals(mixed $actual, mixed $expected)
229 이름 : assert.lessThan
사용법 : if.lt 참조하십시오		 별명, 전체 설명은 if.lt 를 참조하십시오. 기인하다:
AssertLessThan::class
방법:
Validation::assertLessThan(mixed $actual, mixed $expected)
230 이름 : assert.lessThanOrEquals
사용법 : if.lte 참조하십시오		 별명, 전체 설명은 if.lte 를 참조하십시오. 기인하다:
AssertLessThanOrEquals::class
방법:
Validation::assertLessThanOrEquals(mixed $actual, mixed $expected)
231 이름 : blank
사용법 : empty 참조		 별명, 전체 설명은 empty 을 참조하십시오. 기인하다:
Blank::class
방법:
Validation::blank()
232 이름 : is
사용법 : equals 참조하십시오		 별칭은 전체 설명에 대해서도 equals 합니다. 기인하다:
Is::class
방법:
Validation::is(mixed $value)
233 이름 : same
사용법 : equals 참조하십시오		 별칭은 전체 설명에 대해서도 equals 합니다. 기인하다:
Same::class
방법:
Validation::same(mixed $value)
234 이름 : pattern
사용법 : matches 참조하십시오		 별칭은 전체 설명에 대해서는 matches 를 참조하십시오. 기인하다:
Pattern::class
방법:
Validation::pattern(string $pattern)
235 이름 : choice
사용법 : in		 별칭은 전체 설명 in 참조하십시오. 기인하다:
Choice::class
방법:
Validation::choice(string|int|float|bool|null ...$values)
236 이름 : size
사용법 : count 참조하십시오		 count 은 전체 설명을 참조하십시오. 기인하다:
Size::class
방법:
Validation::size(int $size)
237 이름 : length
사용법 : count 참조하십시오		 count 은 전체 설명을 참조하십시오. 기인하다:
Length::class
방법:
Validation::length(int $count)
238 이름 : range
사용법 : between 참조하십시오		 별명은 between 설명을 참조하십시오. 기인하다:
Range::class
방법:
Validation::range(int|float $min, int|float $max)
239 이름 : minmax
사용법 : between 참조하십시오		 별명은 between 설명을 참조하십시오. 기인하다:
Minmax::class
방법:
Validation::minmax(int|float $min, int|float $max)
240 이름 : filled
사용법 : required 참조		 별명, 전체 설명은 required 를 참조하십시오. 기인하다:
Filled::class
방법:
Validation::filled()
241 이름 : present
사용법 : required 참조		 별명, 전체 설명은 required 를 참조하십시오. 기인하다:
Present::class
방법:
Validation::present()
242 이름 : optional
사용법 : allowed 됩니다		 별명, 전체 설명을 allowed 합니다. 기인하다:
Optional::class
방법:
Validation::optional()
243 이름 : date
사용법 : datetime 참조하십시오		 별칭, 전체 설명은 datetime 을 참조하십시오. 기인하다:
Date::class
방법:
Validation::date()
244 이름 : date.equals
사용법 : datetime.eq 참조하십시오		 별명, 전체 설명은 datetime.eq 를 참조하십시오. 기인하다:
DateEquals::class
방법:
Validation::dateEquals(string $datetime)
245 이름 : date.before
사용법 : datetime.lt 참조하십시오		 별명, 전체 설명은 datetime.lt 를 참조하십시오. 기인하다:
DateBefore::class
방법:
Validation::dateBefore(string $datetime)
246 이름 : date.beforeOrEquals
사용법 : datetime.lte 참조하십시오		 별명, 전체 설명은 datetime.lte 를 참조하십시오. 기인하다:
DateBeforeOrEquals::class
방법:
Validation::dateBeforeOrEquals(string $datetime)
247 이름 : date.after
사용법 : datetime.gt 참조하십시오		 별명, 전체 설명은 datetime.gt 를 참조하십시오. 기인하다:
DateAfter::class
방법:
Validation::dateAfter(string $datetime)
248 이름 : date.afterOrEquals
사용법 : datetime.gte 참조하십시오		 별명, 전체 설명은 datetime.gte 를 참조하십시오. 기인하다:
DateAfterOrEquals::class
방법:
Validation::dateAfterOrEquals(string $datetime)
249 이름 : date.format
사용법 : datetime.format 참조하십시오		 별명, 전체 설명은 datetime.format 를 참조하십시오. 기인하다:
DateFormat::class
방법:
Validation::dateFormat(string $format)
250 이름 : cakeday
사용법 : datetime.birthday 참조하십시오		 별명, 전체 설명은 datetime.birthday 를 참조하십시오. 기인하다:
Cakeday::class
방법:
Validation::cakeday()

매크로

매크로 검증 표현
[nullable] null^~empty
[alnumDash] matches:"/[a-zA-Z0-9-_]+/"
[twitterHandle] matches:'"/^[a-zA-Z_]{1}[a-zA-Z0-9_]{0,14}$/"'
[gmail] email&string.contains:"@gmail."
[eduMail] email&string.endsWith:".edu"

벤치마크

지금까지는 mighty 너무 많은 일을하고 성능 문제가 발생하기 시작한 것처럼 보일 수 있습니다. 글쎄, 그것에 대해 걱정할 필요가 없습니다. mighty 는 정말 빠르며 최고의 성능을 제공하도록 최적화됩니다. 다음은 유효성있는 성능의 벤치 마크입니다.

과학적 벤치 마크가 아닙니다

Laravel 애플리케이션에서 mighty Validator 및 Laravel Validator의 성능. 테스트는 50000 요소의 배열을 사용하여 수행되었으며 그 중 절반은 정수이고 나머지 절반은 숫자 문자열입니다. 각 유효성 검사기를 10 회 (연속) 테스트 하고이 10의 평균 결과를 수집했습니다.

mighty Validator with XDebug disabled [ // required&integer 'preparationTime' => '1.32ms', // the time required to build the array 'validationTime' => '1107.29ms', // the time required to validate the array 'totalTime' => '1108.61ms', // the time required for the whole process ] // mighty Validator with XDebug enabled [ // required&integer 'preparationTime' => '9.09ms', 'validationTime' => '6085.04ms', 'totalTime' => '6094.13ms', ] // Laravel Validator with XDebug disabled [ // required|integer 'preparationTime' => '1.33ms', 'validationTime' => '13882.72ms', 'totalTime' => '13884.05ms', ] // Laravel Validator with XDebug enabled [ // required|integer 'preparationTime' => '9.33ms', 'validationTime' => '24010.60ms', 'totalTime' => '24019.93ms', ]">
 $ data = array_merge ( range ( 1 , 25000 ), array_map ( ' strval ' , range ( ' 25001 ' , ' 50000 ' )));
// mighty Validator with XDebug disabled
[ // required&integer
  ' preparationTime ' => ' 1.32ms ' ,    // the time required to build the array
  ' validationTime '  => ' 1107.29ms ' , // the time required to validate the array
  ' totalTime '       => ' 1108.61ms ' , // the time required for the whole process
]
// mighty Validator with XDebug enabled
 [ // required&integer
  ' preparationTime ' => ' 9.09ms ' ,
  ' validationTime '  => ' 6085.04ms ' ,
  ' totalTime '       => ' 6094.13ms ' ,
]
// Laravel Validator with XDebug disabled
[ // required|integer
  ' preparationTime ' => ' 1.33ms ' ,
  ' validationTime '  => ' 13882.72ms ' ,
  ' totalTime '       => ' 13884.05ms ' ,
]
// Laravel Validator with XDebug enabled
[ // required|integer
  ' preparationTime ' => ' 9.33ms ' ,
  ' validationTime '  => ' 24010.60ms ' ,
  ' totalTime '       => ' 24019.93ms ' ,
]

따라서 mighty 는 Xdebug가 비활성화 된 Laravel Validator보다 약 12.5 배 빠르고 Xdebug가 활성화 된 경우 약 4 배 빠릅니다.

과학적 벤치 마크

벤치 마크는 Phpbench를 사용하여 수행됩니다. 다음은 빠른 개요입니다.

mighty/phpbench.json.dist with PHP version 8.1.9, xdebug , opcache MAKS mighty BenchmarksConstraintBench benchAValidValidatableObject............I4 ✔ Mo305.595074ops/s (±0.75%) benchAnInvalidValidatableObject.........I4 ✔ Mo326.708522ops/s (±1.02%) MAKS mighty BenchmarksValidatorBench benchSingleValidationString.............I4 ✔ Mo0.02212ms (±1.59%) benchSingleValidationObject.............I4 ✔ Mo0.126929ms (±1.63%) benchBulkValidationObject...............I4 ✔ Mo9.345847ms (±0.62%) benchBulkValidationString...............I4 ✔ Mo6.734188ms (±0.40%) Subjects: 6, Assertions: 6, Failures: 0, Errors: 0">
 PHPBench (1.2.6) running benchmarks...
with configuration file: mighty /phpbench.json.dist
with PHP version 8.1.9, xdebug , opcache 

MAKS mighty BenchmarksConstraintBench

    benchAValidValidatableObject............I4 ✔ Mo305.595074ops/s (±0.75%)
    benchAnInvalidValidatableObject.........I4 ✔ Mo326.708522ops/s (±1.02%)

MAKS mighty BenchmarksValidatorBench

    benchSingleValidationString.............I4 ✔ Mo0.02212ms (±1.59%)
    benchSingleValidationObject.............I4 ✔ Mo0.126929ms (±1.63%)
    benchBulkValidationObject...............I4 ✔ Mo9.345847ms (±0.62%)
    benchBulkValidationString...............I4 ✔ Mo6.734188ms (±0.40%)

Subjects: 6, Assertions: 6, Failures: 0, Errors: 0

■ 사실 : 가장 최근의 벤치 마크 결과는 CI 파이프 라인에서도 찾을 수 있으며, 이는 위의 각 푸시/PR로 업데이트됩니다.

메모

  1. mighty 기본적으로 (현재 영어로만) 정말 친근한 오류 메시지를 생성합니다. 이러한 메시지는 유효성 검사기/제약 기반에서 쉽게 덮어 쓸 수 있습니다. 이 메시지를 다른 언어로 사용하고 싶을 수도 있습니다. 즉, MAKS mighty Rule::setMessageTranslator() 메소드를 사용할 수 있습니다. 이 방법은 글로벌 메시지 번역기를 설정하는 편리한 방법이며, 원시 메시지 (자리 표시 자와 함께)를 인수로 가져 오는 폐쇄가 필요하며 해당 메시지의 번역 된 버전을 반환해야합니다.
  2. mighty Validation Expression mighty
  3. PHP API에 대한 자세한 내용은 mighty API 문서를 참조하십시오. API는 잘 문서화되어 있으며 거기에 다루지 않은 것은 없어야합니다.
  4. mighty 는 현재 순수한 검증 라이브러리이며 데이터에 대해 어떠한 전환도하지 않습니다. 엔진과 현재 디자인은 유연하며 그 위에 소독제를 쉽게 구현하는 데 사용될 수 있습니다. 현재이를 만들 계획은 없지만 미래의 이정표 일 수 있습니다.

특허

mighty 는 MIT 라이센스에 따라 라이센스가 부여 된 오픈 소스 프로젝트입니다.
저작권 (C) 2022 Marwan al-Soltany. 모든 권리 보유.

확장하다
추가 정보
관련 애플리케이션
추천
관련 정보 전체