首页>PHP源码>其他类别
下载

mighty

您将需要的最后一个验证库！


目录

安装
关于mighty
快速入门
毫速度
示例
约束条件
验证
文档
规格
变更日志


如果您喜欢这个项目并愿意支持它的发展，请给予它一个，我们将不胜感激！


主要特点

  1. 零依赖。
  2. 与框架无关，可以集成到任何代码库中。
  3. 富有表现力、直观且易于使用，拥有超过250 条内置验证规则。

<跨度类=强大的演示" style="max-width: 100%;">

安装

composer require marwanalsoltany/ mighty

关于mighty

验证是任何 Web 应用程序中的常见任务。通过表单传递到应用程序的数据（或任何类型的输入）必须始终根据一组规则进行验证。 mighty可以以简单且富有表现力的方式处理。

mighty是快速、强大、健壮且易于使用的验证库，使用起来很有趣，它使验证任何数据变得轻而易举。得益于mighty验证表达式语言 (mVEL)的强大功能，它与您以前见过的任何东西都不一样。凭借其验证方法和超过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有验证表达式的概念。最简单形式的验证表达式只是一个字符串，描述了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断言输入为空。
  3. 最终结果是对使用按位运算符将每个规则的结果粘合在一起而产生的表达式进行求值的结果。

required&string&between:2,255|null表达式表示输入必须存在；字符串类型的AND ； AND长度在 2 到 255 之间；或空。因此，它是一个可以为 null 的字符串，当不为 null 时，长度必须在 2 到 255 个字符之间。

假设输入是" 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等...

与其他验证实现不同，使用按位运算符的布尔代数概念提供了构建可读且紧凑的复杂验证的可能性，同时将规则数量保持在最低限度，以相反或复合的方式重用现有逻辑，并最终保持代码库尽可能干燥。其好处可概括为以下几点：

  1. 可以对规则进行NOT编辑（使用~ ）以执行与其通常执行的操作完全相反的操作。
  2. 复杂规则可以是两个或多个简单规则AND ing（使用& ）、 OR ing（使用| ）或XOR ing（使用^ ）的结果。
  3. 规则可以组合在一起和/或通过使用括号赋予更高的优先级，即OPEN （使用( ) 和CLOSE （使用) ）。
  4. 验证表达式还可以具有行为，该行为是验证表达式字符串的前缀字符，将影响所有规则。可用的行为有：
    1. NORMAL ：执行所有规则，默认行为（无前缀）。
    2. OPTIMISTIC ：第一次成功后停止执行规则（ ?前缀）。
    3. 悲观：在第一次失败（ !前缀）后停止执行规则。
  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		断言输入为空。属性：
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		断言输入表示十六进制数字。属性：
Xdigit::class
方法：
Validation::xdigit()
027名称： booleanLike
用法： booleanLike		断言输入是一个可以解析为布尔值的值（TRUE：true、“true”、“1”、“on”、“yes”；FALSE：false、“false”、“0”、“off” 、“否”、“”、空）。属性：
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		断言输入是一个可以解析为指定范围内的整数并且可以采用八进制表示法的值。属性：
IntegerLikeAllowOctal::class
方法：
Validation::integerLikeAllowOctal(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
030名称： integerLike.allowHex
用法： integerLike.allowHex:0,100		断言输入是一个可以解析为指定范围内的整数的值，并且可以采用十六进制表示法。属性：
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		断言输入是电子邮件地址（允许使用 unicode）。属性：
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		断言输入是一个文件，并且其目录名等于给定的目录名。属性：
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		断言输入被禁止（为空或不存在）。属性：
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		断言输入是关闭位（等于：假、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		断言输入计数等于给定值。适用于所有数据类型（空：0；布尔值：0 或 1；浮点/整数：数值；字符串：字符计数；数组/可计数：元素计数；对象：可访问属性计数）。属性：
Count::class
方法：
Validation::count(int $count)
094姓名： min
使用： min:3		断言输入计数大于或等于给定值。适用于所有数据类型（空：0；布尔值：0 或 1；浮点/整数：数值；字符串：字符计数；数组/可计数：元素计数；对象：可访问属性计数）。属性：
Min::class
方法：
Validation::min(int|float $count)
095名称： max
使用次数： max:3		断言输入计数小于或等于给定值。适用于所有数据类型（空：0；布尔值：0 或 1；浮点/整数：数值；字符串：字符计数；数组/可计数：元素计数；对象：可访问属性计数）。属性：
Max::class
方法：
Validation::max(int|float $count)
096名称： between
用法： between:3,7		断言输入计数在给定值之间。适用于所有数据类型（空：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		断言输入数组包含唯一值。仅适用于一维数组。属性：
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		断言输入看起来像镜头或长格式（“Jan”或“January”）的日历月。属性：
CalenderMonth::class
方法：
Validation::calenderMonth()
152姓名： username
用途： username		断言输入是有效的用户名（4-32 个字符之间，由任何大小写的字母组成，可选数字，可选以下字符之一“-_.”（不连续），并且必须始终以字母开头并结尾带有字母或数字）。属性：
Username::class
方法：
Validation::username()
153名称： password
用途： password		断言输入的是有效密码（至少 8 个字符，至少由 1 个小写字母和 1 个大写字母、至少 1 个数字、至少 1 个特殊字符以及可选的空格组成）。属性：
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。属性：
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		断言输入是格式有效的美元金额，其中小数点和千位分隔符是可选的。属性：
AmountDollar::class
方法：
Validation::amountDollar()
168名称： amount.euro
用途： amount.euro		断言输入是有效格式的欧元金额，其中小数点和千位分隔符是可选的。属性：
AmountEuro::class
方法：
Validation::amountEuro()
169名称： color
用途: color		断言输入是有效的 CSS 颜色（关键字“loose”、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（国际移动站设备标识和软件版本编号）。属性：
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”; numeric：“ 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		断言该输入是有效的美国运通信用卡号，允许平衡空间和/或破折号。属性：
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		断言该投入是有效的中国联合赛信用卡号，允许平衡的空间和/或破折号。属性：
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验证器和Laravel验证器的性能。测试是使用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验证器快的速度约为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验证表达语言规范，以了解有关mighty背后理论的更多信息，并了解语言的工作原理。
  3. 请参阅mighty API文档，以了解有关PHP API的更多信息。 API有充分的文献记录，那里不应该有任何内容。
  4. mighty当前是一个纯粹的验证库，它对数据没有任何形式的转换。发动机和当前的设计足够灵活，可以用来轻松地在其顶部实现消毒剂，目前没有计划进行此操作，但这可能是未来的里程碑。

执照

mighty是根据MIT许可证许可的开源项目。
版权（C）2022 Marwan al-Soltany。版权所有。

展开
附加信息
相关应用
为您推荐
相关资讯 全部