Главная страница>Исходный код PHP>Другие категории
Скачать

mighty

Последняя библиотека проверки, которая вам когда-либо понадобится!


Оглавление

Установка
О mighty
Быстрый старт
мВЭЛ
Примеры
Ограничения
Валидации
Документация
Спецификация
Журнал изменений


Если вам нравится этот проект и вы хотите поддержать его развитие, мы будем признательны, если вы поставите ему лайк!


Ключевые особенности

  1. Ноль зависимостей.
  2. Независимость от фреймворка, может быть интегрирована в любую кодовую базу.
  3. Выразительный, интуитивно понятный и простой в использовании, с более чем 250 встроенными правилами проверки.

<класс диапазона= могучая демонстрация" style="max-width: 100%;">

Установка 

composer require marwanalsoltany/ mighty

О mighty

Проверка — обычная задача в любом веб-приложении. Данные, передаваемые в приложение через формы (или любой тип ввода, если уж на то пошло), всегда должны проверяться на соответствие набору правил. 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 означает, что входные данные должны присутствовать; И типа строка; И от 2 до 255 в длину; ИЛИ ноль. Таким образом, это строка, допускающая значение 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. Правило НЕ может быть изменено (с использованием ~ ), чтобы оно делало прямо противоположное тому, что оно обычно делает.
  2. Сложное правило может быть результатом операций AND (с использованием & ), OR (с использованием | ) или XOR (с использованием ^ ), двух или более простых правил.
  3. Правила могут быть сгруппированы вместе и/или им присвоен более высокий приоритет с помощью круглых скобок, а именно OPEN (с использованием ( ) и CLOSE (с использованием ) ).
  4. Выражение проверки также может иметь поведение, которое представляет собой символ, предшествующий строке выражения проверки, которая будет влиять на все правила. Доступные варианты поведения:
    1. НОРМАЛЬНЫЙ : выполнять все правила, поведение по умолчанию (без префикса).
    2. ОПТИМИСТИЧНО : прекратить выполнение правил после первого успеха (префикс ? ).
    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) ' ,
        ],
    ],
];

■ Подсказка: ознакомьтесь с rules , aliases и macros Validator по умолчанию, чтобы увидеть больше примеров.

Ограничения

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		 Утверждает, что входные данные представляют собой шестнадцатеричные цифры. Атрибут:
Xdigit::class
Метод:
Validation::xdigit()
027 Имя: booleanLike
Использование: booleanLike		 Утверждает, что входные данные представляют собой значение, которое можно проанализировать как логическое значение (ИСТИНА: правда, «истина», «1», «включено», «да»; ЛОЖЬ: ложь, «ложь», «0», «выключено»). , «нет», «», ноль). Атрибут:
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		 Утверждает, что входные данные представляют собой адрес электронной почты (разрешен Юникод). Атрибут:
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		 Утверждает, что ввод пуст, используя языковую конструкцию пустой() (пустой, т. е. пустая строка, пустой массив, ложь, ноль или 0). Атрибут:
EmptyConstraint::class
Метод:
Validation::empty()
082 Имя: required
Использование: required		 Утверждает, что ввод является обязательным (не пустым, т. е. не пустой строкой и не нулевым). Атрибут:
Required::class
Метод:
Validation::required()
083 Имя: allowed
Использование: allowed		 Утверждает, что ввод разрешен (может быть пустым или иметь любое значение, ноль и пустая строка считаются допустимыми значениями). Атрибут:
Allowed::class
Метод:
Validation::allowed()
084 Название: forbidden
Использование: forbidden		 Утверждает, что ввод запрещен (имеет значение NULL или отсутствует). Атрибут:
Forbidden::class
Метод:
Validation::forbidden()
085 Имя: accepted
Использование: accepted		 Утверждает, что ввод принят (равен: «вкл», «да», «да», «да», «йо», «ок», «окей», «да», 1 или «1», «истина» или « true") обратите внимание, что строки обрабатываются без учета регистра. Атрибут:
Accepted::class
Метод:
Validation::accepted()
086 Имя: declined
Использование: declined		 Утверждает, что ввод отклонен (равен: «выключено», «нет», «нет», «нет», «не», «нет», 0 или «0», «ложь» или «ложь»). Обратите внимание, что строки обрабатываются. без учета регистра. Атрибут:
Declined::class
Метод:
Validation::declined()
087 Название: bit
Использование: bit		 Утверждает, что ввод является битовым (равен: 1 или «1», истина; 0 или «0», ложь). Атрибут:
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 альфа-2], регистр не учитывается, ввод канонизируется перед проверкой (дефисы для подчеркивания, без точек и кодировки); строгий: [ISO 639-1] или [ISO 639-1]_[ISO 3166-1]. альфа-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 альфа-2»; длинный: «ISO 3166-1 альфа-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		 Утверждает, что входные данные представляют собой строку/объект даты и времени, у которого сегодня день рождения. Ввод предпочтительно должен быть в формате «ГГГГ-ММ-ДД». Атрибут:
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		 Утверждает, что входные данные выглядят как календарный месяц в дробном или длинном формате («январь» или «январь»). Атрибут:
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		 Утверждает, что входные данные представляют собой достоверно отформатированное количество долларов США, где десятичная точка и разделитель тысяч разделителей являются необязательными. Атрибут:
AmountDollar::class
Метод:
Validation::amountDollar()
168 Имя: amount.euro
Использование: amount.euro		 Утверждает, что входные данные представляют собой достоверно отформатированную сумму евро, где десятичная точка и разделитель тысяч не являются обязательными. Атрибут:
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 Color. Атрибут:
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 chars). Атрибут:
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		 Утверждает, что вход является действительным цветом RGB CSS4. Атрибут:
ColorRgbNew::class
Метод:
Validation::colorRgbNew()
177 Имя: color.hsl
Использование: color.hsl		 Утверждает, что вход является действительным CSS HSL Color. Атрибут:
ColorHsl::class
Метод:
Validation::colorHsl()
178 Имя: color.hsla
Использование: color.hsla		 Утверждает, что вход является действительным цветом CSS HSLA. Атрибут:
ColorHsla::class
Метод:
Validation::colorHsla()
179 Имя: color.hsl.new
Использование: color.hsl.new		 Утверждает, что вход является действительным цветом HSL CSS4. Атрибут:
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 (UK National Number). Атрибут:
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 NUMERIC»). Атрибут:
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		 Утверждает, что входные данные представляют собой действительный номер кредитной карты 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		 Утверждает, что входные данные представляют собой действительный номер кредитной карты Club Diners, сбалансированные пространства и/или тире. Атрибут:
CreditcardDinersClub::class
Метод:
Validation::creditcardDinersClub()
200 Имя: creditcard.jcb
Использование: creditcard.jcb		 Утверждает, что входные данные представляют собой действительный номер кредитной карты JCB, сбалансированные пространства и/или тире. Атрибут:
CreditcardJcb::class
Метод:
Validation::creditcardJcb()
201 Имя: creditcard.maestro
Использование: creditcard.maestro		 Утверждает, что входные данные представляют собой действительный номер кредитной карты Maestro, сбалансированные пространства и/или тире. Атрибут:
CreditcardMaestro::class
Метод:
Validation::creditcardMaestro()
202 Имя: creditcard.chinaUnionPay
Использование: creditcard.chinaUnionPay		 Утверждает, что входные данные представляют собой действительный номер кредитной карты China Unionpay, сбалансированные пространства и/или тире. Атрибут:
CreditcardChinaUnionPay::class
Метод:
Validation::creditcardChinaUnionPay()
203 Имя: creditcard.instaPayment
Использование: creditcard.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 действительно быстрый и оптимизирован, чтобы обеспечить наилучшую производительность. Вот некоторые тесты производительности валидатора:

Не так научный эталон

Производительность mighty Validator и Laravel Validator в приложении 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 примерно в 12,5 раза быстрее, чем валидатор Laravel с отключенным XDebug и примерно в 4 раза быстрее с включенным XDebug.

Научный эталон

Конфликт выполняется с использованием 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, который будет обновляться с каждым push/pr в Upsteam.

Примечания

  1. mighty генерирует действительно дружественные сообщения об ошибках по умолчанию (в настоящее время только на английском языке). Эти сообщения могут быть легко перезаписаны на основаниях валидатора/ограничений. Возможно, вы захотите иметь эти сообщения на разных языках, для этого можно использовать метод MAKS mighty Rule::setMessageTranslator() . Этот метод является удобным способом установить глобальный переводчик сообщений, он требует закрытия, которое получает необработанное сообщение (с заполнителями) в качестве аргумента и должен вернуть переведенную версию этого сообщения.
  2. Обратитесь к спецификации языка выражения mighty валидации, чтобы узнать больше о теории, лежащей в основе mighty и понять, как работает язык.
  3. Обратитесь к документации mighty API, чтобы узнать больше о PHP API. API хорошо документирован, и там не должно быть ничего, что там не было.
  4. mighty в настоящее время является чистой библиотекой проверки, она не делает никаких преобразования данных. Двигатель и текущий дизайн достаточно гибкий и могут быть использованы для легкого реализации дезинфицирующего средства, в настоящее время нет плана сделать это в настоящее время, но это может быть будущей вехой.

Лицензия

mighty -это проект с открытым исходным кодом, лицензированный по лицензии MIT .
Авторские права (C) 2022 Marwan Al-Soltany. Все права защищены.

Расширять
Дополнительная информация
Связанные приложения
Рекомендуем вам
Связанные новости Все