Página Inicial>Código fonte PHP>Outras categorias
Baixar

mighty

A última biblioteca de validação que você precisará!


Índice

Instalação
Sobre mighty
Início rápido
mVEL
Exemplos
Restrições
Validações
Documentação
Especificação
Registro de alterações


Se você gosta deste projeto e gostaria de apoiar seu desenvolvimento, agradeceríamos!


Principais recursos

  1. Dependências zero.
  2. Agnóstico de framework, pode ser integrado em qualquer base de código.
  3. Expressivo, intuitivo e fácil de usar, com mais de 250 regras de validação integradas.

<classe span= demonstração poderosa" style="max-width: 100%;">

Instalação 

composer require marwanalsoltany/ mighty

Sobre mighty

A validação é uma tarefa comum em qualquer aplicação web. Os dados passados ​​​​para o aplicativo por meio de formulários —ou qualquer tipo de entrada nesse sentido— devem sempre ser validados em relação a um conjunto de regras. mighty pode lidar de maneira fácil e expressiva.

mighty é uma biblioteca de validação rápida, poderosa, robusta e fácil de usar, divertida de trabalhar e que facilita a validação de qualquer dado. Graças ao poder da mighty Validation Expression Language (mVEL), não é diferente de tudo que você já viu antes. Com sua abordagem de validação e mais de 250 regras integradas, não há praticamente nada que você não possa validar com ela, de forma muito expressiva e compacta. Simplificando, mighty é a validação com esteróides! Na verdade, é a última biblioteca de validação de que você precisará.

mighty fornece várias abordagens diferentes para validar dados. O caso de uso mais comum é a validação de dados recebidos por meio de solicitações HTTP, mas é claro que não se limita a isso; mighty também fornece atributos na forma de restrições para validar facilmente modelos e/ou qualquer tipo de objeto.

mighty inclui uma ampla variedade de regras de validação convenientes que você pode aplicar como uma regra única ou combiná-las usando operadores para criar validações ainda mais complexas.

Início rápido

Para aprender sobre os poderosos recursos de validação do mighty , vamos direto ao ponto e dar uma olhada em alguns exemplos:

Validação Geral de Dados

Validando dados do formulário usando 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

Validação de Objetos

Validando o estado de um objeto usando atributos 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

Um exemplo da saída da validação de um objeto validável seria assim: 

 // 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.

Verifique também ValidatableObject e ValidatableObjectChild .

■ Dica: Mais exemplos podem ser encontrados na seção Exemplos.

mighty linguagem de expressão de validação

mighty tem o conceito de Expressão de Validação. A Expressão de Validação em sua forma mais simples é apenas uma string que descreve o quão mighty deve validar os dados fornecidos. Essas strings são baseadas na mighty Especificação de Linguagem de Expressão de Validação (mVEL). mVEL é bastante simples, legível e fácil de usar. É uma combinação de conceitos e/ou especificações bem estabelecidos como Álgebra Booleana, Operadores Bitwise, JSON e CSV.

Portanto, Expressão de Validação pode ser definida como uma string que contém algumas regras separadas por Operadores Bitwise que construirão uma expressão que quando avaliada pela lógica da Álgebra Booleana , resultará no resultado final da validação. As regras podem ter argumentos, os tipos desses argumentos podem ser denotados usando as mesmas regras dos tipos JSON . Uma regra também pode ter vários argumentos e os argumentos são separados por vírgulas ( CSV ).

Por exemplo, required&string&between:2,255|null é uma expressão de validação válida, esta expressão pode ser entendida como o seguinte:

  1. A expressão tem quatro regras.
  2. A expressão contém as regras:
    1. required Afirma que a entrada está presente.
    2. string Afirma que a entrada é uma string.
    3. between:2,255 Afirma que a entrada é uma string com comprimento entre 2 e 255.
    4. null Afirma que a entrada é nula.
  3. O resultado final é o resultado da avaliação da expressão resultante do resultado de cada regra colada por meio de operadores bit a bit.

A expressão required&string&between:2,255|null significa que a entrada deve estar presente; AND do tipo string; E entre 2 e 255 de comprimento; OU nulo. Portanto, é uma string anulável que, quando não for nula, deve ter entre 2 e 255 caracteres.

Digamos que a entrada foi " mighty is Awesome!" , o resultado da expressão required&string&between:2,255|null contra essa entrada seria 1&1&1|0 que resultará em 1 que é true , se a entrada fosse null o resultado seria 0&0&0|1 = 1 , se a entrada fosse X o resultado seria 0&0&0|0 = 0 , etc ...

Ao contrário de outras implementações de validações, o conceito de Álgebra Booleana usando Operadores Bitwise , dá a possibilidade de construir validações complexas que são muito legíveis e compactas, mantendo as regras em um número mínimo, reutilizando a lógica existente de maneira invertida ou composta e, finalmente, mantendo o base de código tão SECA quanto possível. Os benefícios podem ser resumidos nos seguintes pontos:

  1. Uma regra NÃO pode ser editada (usando ~ ) para fazer exatamente o oposto do que normalmente faz.
  2. Uma regra complexa pode ser o resultado de AND (usando & ), OR (usando | ) ou XOR (usando ^ ), duas ou mais regras simples.
  3. As regras podem ser agrupadas e/ou receber maior precedência usando parênteses, ou seja, OPEN (usando ( ) e CLOSE (usando ) ).
  4. Uma Expressão de Validação também pode ter comportamento, que é um caractere que prefixa a string da Expressão de Validação que afetará todas as regras. Os comportamentos disponíveis são:
    1. NORMAL : executa todas as regras, comportamento padrão (sem prefixo).
    2. OPTIMISTIC : interrompe a execução de regras após o primeiro sucesso ( ? prefixo).
    3. PESSIMÍSTICO : interrompe a execução de regras após a primeira falha (prefixo ! ).
  5. A legibilidade pode ser melhorada criando alias para algumas regras ou adicionando conjuntos de regras como macros e executando-os usando a sintaxe [macro] .

Além disso, o conceito de JSON garante a segurança dos tipos de dados dos argumentos, e o conceito de CSV garante que a lista de argumentos tenha regras de análise claras.

O melhor de tudo é que você não precisa memorizar todas as regras nem a sintaxe da Validation Expression Language. A classe Validation é uma interface fluente que pode ser usada para construir uma Expressão de Validação. Ele conhece todas as regras mighty disponíveis e tem suporte completo ao IDE-Intellisense para tornar tudo o mais fácil possível. Por exemplo:

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 ();

■ Fato: Geralmente são necessárias mais palavras para descrever o que uma expressão de validação faz do que a própria expressão de validação!

Exemplos

Aqui estão alguns exemplos de cenários do mundo real:

Validando um único valor

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);

Validando Dados Estruturados

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);

■ Dica: Ao fornecer substituições de mensagens para Validator::class , é aconselhável usar RuleValidation::class para definir chaves de array. Esta classe contém todos os nomes de regras mighty como constantes de classe.

Estendendo o Validador

O validador pode ser estendido de três maneiras:

  • Adicionando uma regra.
  • Adicionando um alias.
  • Adicionando uma macro.
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) ' ,
        ],
    ],
];

■ Dica: Confira as rules padrão, aliases e macros do Validator para ver mais exemplos.

Restrições

mighty consiste em mais de 250 regras/atributos que podem ser usados ​​para validar quaisquer dados ou valores de classes, constantes de classe, propriedades e métodos.

Os atributos são divididos em três grupos principais:

  1. Atributos de restrição genéricos
  2. Atributos de restrição especiais
  3. Atributos de restrição de regra

Grupo de atributos de restrição genéricos

Os atributos de restrição genérica estão localizados no namespace MAKS mighty Validation .

Este grupo consiste atualmente em apenas um atributo; esse é o atributo Constraint . Este atributo utiliza uma Expressão de Validação para validar os dados aos quais é aplicado. É também a classe base para todos os outros atributos.

Grupo de atributos de restrição especial

Os atributos de restrição especiais estão localizados no MAKS mighty ValidationConstraint .

Este grupo contém atributos que realizam uma tarefa específica que está disponível apenas no contexto de atributos. Consiste nos seguintes atributos:

  • Rule : Este atributo é usado para validar quaisquer dados usando uma única regra de validação. É também a classe base para todos os atributos no grupo de atributos de restrição de regras.
  • Callback : este atributo é usado para validar quaisquer dados usando uma função de retorno de chamada.
  • Valid : Este atributo é usado para validar a validade de um objeto validável.
  • Shape : Este atributo é usado para validar a forma de um array ou objeto. Observe que este é o único atributo que valida um conjunto de valores (dados estruturados) em vez de um único valor.
  • Compound : Este atributo é usado para combinar um conjunto de restrições para construir uma Expressão de Validação. As restrições podem ser combinadas usando qualquer operador e também podem ter um comportamento. Ele serve como uma forma orientada a objetos para construir uma Expressão de Validação.

■ Nota: Observe que as restrições que podem ser usadas com os atributos Shape::class e Compound::class devem ser instâncias reais de Constraint::class , Rule::class ou Compound::class . O Callback::class , Valid::class ou Shape::class do grupo de atributos de restrição especial NÃO são permitidos. Se você precisar desse recurso, abra um problema e discutiremos sua implementação

Grupo de atributos de restrição de regras

Os atributos de restrição de regra estão localizados no namespace MAKS mighty ValidationConstraintRule .

Este grupo contém atributos baseados em uma única regra de validação. Consiste na maioria dos atributos que mighty fornece. Consulte a seção Validações para obter a lista completa.

Adicionando uma restrição personalizada

mighty tem uma lista enorme de restrições integradas, é realmente raro que você precise de algo diferente do que mighty fornece. No entanto, às vezes surge a necessidade de uma restrição personalizada. Veja como você pode conseguir isso:

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

■ Nota: As restrições personalizadas são consideradas parte do Grupo de Atributos de Restrições Especiais (ou seja, não podem ser usadas com/dentro das restrições Shape::class e Compound::class )

Validações

A tabela a seguir lista todas as regras disponíveis, incluindo seus equivalentes de atributos e métodos:

Regras e apelidos

  • Validation::class
  • Constraint::class e Constraint/Rule/*
Não. Regra Descrição Atributo/Método
001 Nome: null
Uso: null		 Afirma que a entrada é nula. Atributo:
NullConstraint::class
Método:
Validation::null()
002 Nome: boolean
Uso: boolean		 Afirma que a entrada é booleana. Atributo:
Boolean::class
Método:
Validation::boolean()
003 Nome: integer
Uso: integer		 Afirma que a entrada é um número inteiro. Atributo:
Integer::class
Método:
Validation::integer()
004 Nome: float
Uso: float		 Afirma que a entrada é um float. Atributo:
FloatConstraint::class
Método:
Validation::float()
005 Nome: numeric
Uso: numeric		 Afirma que a entrada é numérica. Atributo:
NumericConstraint::class
Método:
Validation::numeric()
006 Nome: string
Uso: string		 Afirma que a entrada é uma string. Atributo:
StringConstraint::class
Método:
Validation::string()
007 Nome: scalar
Uso: scalar		 Afirma que a entrada é um escalar. Atributo:
Scalar::class
Método:
Validation::scalar()
008 Nome: array
Uso: array		 Afirma que a entrada é uma matriz. Atributo:
ArrayConstraint::class
Método:
Validation::array()
009 Nome: object
Uso: object		 Afirma que a entrada é um objeto. Atributo:
ObjectConstraint::class
Método:
Validation::object()
010 Nome: callable
Uso: callable		 Afirma que a entrada pode ser chamada. Atributo:
CallableConstraint::class
Método:
Validation::callable()
011 Nome: iterable
Uso: iterable		 Afirma que a entrada é iterável. Atributo:
IterableConstraint::class
Método:
Validation::iterable()
012 Nome: countable
Uso: countable		 Afirma que a entrada é contável. Atributo:
Countable::class
Método:
Validation::countable()
013 Nome: resource
Uso: resource		 Afirma que a entrada é um recurso. Atributo:
ResourceConstraint::class
Método:
Validation::resource()
014 Nome: type
Uso: type:'["int","float"]'		 Afirma que a entrada é um dos tipos fornecidos. Atributo:
Type::class
Método:
Validation::type(string|array $type)
015 Nome: type.debug
Uso: type.debug:string		 Afirma que a entrada é do tipo fornecido usando get_debug_type(). Atributo:
TypeDebug::class
Método:
Validation::typeDebug(string $type)
016 Nome: alpha
Uso: alpha		 Afirma que a entrada consiste apenas em caracteres alfabéticos. Atributo:
Alpha::class
Método:
Validation::alpha()
017 Nome: alnum
Uso: alnum		 Afirma que a entrada consiste apenas em caracteres alfanuméricos. Atributo:
Alnum::class
Método:
Validation::alnum()
018 Nome: lower
Uso: lower		 Afirma que a entrada consiste apenas em caracteres minúsculos. Atributo:
Lower::class
Método:
Validation::lower()
019 Nome: upper
Uso: upper		 Afirma que a entrada consiste apenas em caracteres maiúsculos. Atributo:
Upper::class
Método:
Validation::upper()
020 Nome: cntrl
Uso: cntrl		 Afirma que a entrada consiste apenas em caracteres de controle. Atributo:
Cntrl::class
Método:
Validation::cntrl()
021 Nome: space
Uso: space		 Afirma que a entrada consiste apenas em caracteres de espaço em branco. Atributo:
Space::class
Método:
Validation::space()
022 Nome: punct
Uso: punct		 Afirma que a entrada consiste apenas em caracteres de pontuação. Atributo:
Punct::class
Método:
Validation::punct()
023 Nome: graph
Uso: graph		 Afirma que a entrada consiste apenas em caracteres gráficos (caracteres que criam uma saída visível). Atributo:
Graph::class
Método:
Validation::graph()
024 Nome: print
Uso: print		 Afirma que a entrada consiste apenas em caracteres imprimíveis. Atributo:
PrintConstraint::class
Método:
Validation::print()
025 Nome: digit
Uso: digit		 Afirma que a entrada consiste apenas em dígitos (caracteres numéricos). Atributo:
Digit::class
Método:
Validation::digit()
026 Nome: xdigit
Uso: xdigit		 Afirma que a entrada representa dígitos hexadecimais. Atributo:
Xdigit::class
Método:
Validation::xdigit()
027 Nome: booleanLike
Uso: booleanLike		 Afirma que a entrada é um valor que pode ser analisado como booleano (TRUE: true, "true", "1", "on", "yes"; FALSE: false, "false", "0", "off" , "não", "", nulo). Atributo:
BooleanLike::class
Método:
Validation::booleanLike()
028 Nome: integerLike
Uso: integerLike:0,100		 Afirma que a entrada é um valor que pode ser analisado como um número inteiro dentro do intervalo especificado. Atributo:
IntegerLike::class
Método:
Validation::integerLike(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
029 Nome: integerLike.allowOctal
Uso: integerLike.allowOctal:0,100		 Afirma que a entrada é um valor que pode ser analisado como um número inteiro dentro do intervalo especificado e pode estar em notação octal. Atributo:
IntegerLikeAllowOctal::class
Método:
Validation::integerLikeAllowOctal(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
030 Nome: integerLike.allowHex
Uso: integerLike.allowHex:0,100		 Afirma que a entrada é um valor que pode ser analisado como um número inteiro dentro do intervalo especificado e pode estar em notação hexadecimal. Atributo:
IntegerLikeAllowHex::class
Método:
Validation::integerLikeAllowHex(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
031 Nome: floatLike
Uso: floatLike:1.0,100.0		 Afirma que a entrada é um valor que pode ser analisado como um ponto flutuante dentro do intervalo especificado. Atributo:
FloatLike::class
Método:
Validation::floatLike(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
032 Nome: floatLike.allowThousands
Uso: floatLike.allowThousands:1.0,100.0		 Afirma que a entrada é um valor que pode ser analisado como um ponto flutuante dentro do intervalo especificado. Atributo:
FloatLikeAllowThousands::class
Método:
Validation::floatLikeAllowThousands(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
033 Nome: regexp
Uso: regexp:"/[az]/i"		 Afirma que a entrada corresponde a uma expressão regular compatível com Perl. Atributo:
Regexp::class
Método:
Validation::regexp(string $pattern)
034 Nome: ip
Uso: ip		 Afirma que a entrada é um endereço IP. Atributo:
Ip::class
Método:
Validation::ip()
035 Nome: ip.v4
Uso: ip.v4		 Afirma que a entrada é um endereço IPv4. Atributo:
IpV4::class
Método:
Validation::ipV4()
036 Nome: ip.v6
Uso: ip.v6		 Afirma que a entrada é um endereço IPv6. Atributo:
IpV6::class
Método:
Validation::ipV6()
037 Nome: ip.notReserved
Uso: ip.notReserved		 Afirma que a entrada é um endereço IP que não está dentro do intervalo de IPs reservados. Atributo:
IpNotReserved::class
Método:
Validation::ipNotReserved()
038 Nome: ip.notPrivate
Uso: ip.notPrivate		 Afirma que a entrada é um endereço IP que não está dentro do intervalo de IPs privados. Atributo:
IpNotPrivate::class
Método:
Validation::ipNotPrivate()
039 Nome: mac
Uso: mac		 Afirma que a entrada é um endereço MAC. Atributo:
Mac::class
Método:
Validation::mac()
040 Nome: url
Uso: url		 Afirma que a entrada é uma URL. Atributo:
Url::class
Método:
Validation::url()
041 Nome: url.withPath
Uso: url.withPath		 Afirma que a entrada é uma URL que contém um caminho. Atributo:
UrlWithPath::class
Método:
Validation::urlWithPath()
042 Nome: url.withQuery
Uso: url.withQuery		 Afirma que a entrada é uma URL que contém uma consulta. Atributo:
UrlWithQuery::class
Método:
Validation::urlWithQuery()
043 Nome: email
Uso: email		 Afirma que a entrada é um endereço de e-mail. Atributo:
Email::class
Método:
Validation::email()
044 Nome: email.withUnicode
Uso: email.withUnicode		 Afirma que a entrada é um endereço de e-mail (unicode permitido). Atributo:
EmailWithUnicode::class
Método:
Validation::emailWithUnicode()
045 Nome: domain
Uso: domain		 Afirma que a entrada é um domínio. Atributo:
Domain::class
Método:
Validation::domain()
046 Nome: domain.isActive
Uso: domain.isActive		 Afirma que a entrada é um domínio ativo. Funciona com domínios e e-mails. Atributo:
DomainIsActive::class
Método:
Validation::domainIsActive()
047 Nome: file
Uso: file		 Afirma que a entrada é um arquivo (pode ser um arquivo, um link ou um diretório). Atributo:
File::class
Método:
Validation::file()
048 Nome: file.isFile
Uso: file.isFile		 Afirma que a entrada é um arquivo. Atributo:
FileIsFile::class
Método:
Validation::fileIsFile()
049 Nome: file.isLink
Uso: file.isLink		 Afirma que a entrada é um link. Atributo:
FileIsLink::class
Método:
Validation::fileIsLink()
050 Nome: file.isDirectory
Uso: file.isDirectory		 Afirma que a entrada é um diretório. Atributo:
FileIsDirectory::class
Método:
Validation::fileIsDirectory()
051 Nome: file.isExecutable
Uso: file.isExecutable		 Afirma que a entrada é um arquivo e é executável. Atributo:
FileIsExecutable::class
Método:
Validation::fileIsExecutable()
052 Nome: file.isWritable
Uso: file.isWritable		 Afirma que a entrada é um arquivo e pode ser escrita. Atributo:
FileIsWritable::class
Método:
Validation::fileIsWritable()
053 Nome: file.isReadable
Uso: file.isReadable		 Afirma que a entrada é um arquivo e pode ser lida. Atributo:
FileIsReadable::class
Método:
Validation::fileIsReadable()
054 Nome: file.isUploaded
Uso: file.isUploaded		 Afirma que a entrada é um arquivo carregado via HTTP POST. Atributo:
FileIsUploaded::class
Método:
Validation::fileIsUploaded()
055 Nome: file.size
Uso: file.size:1024		 Afirma que a entrada é um arquivo e o tamanho é igual ao tamanho fornecido em bytes. Atributo:
FileSize::class
Método:
Validation::fileSize(int $sizeInBytes)
056 Nome: file.size.lte
Uso: file.size.lte:1024		 Afirma que a entrada é um arquivo e o tamanho é menor ou igual ao tamanho fornecido em bytes. Atributo:
FileSizeLte::class
Método:
Validation::fileSizeLte(int $sizeInBytes)
057 Nome: file.size.gte
Uso: file.size.gte:1024		 Afirma que a entrada é um arquivo e o tamanho é maior ou igual ao tamanho fornecido em bytes. Atributo:
FileSizeGte::class
Método:
Validation::fileSizeGte(int $sizeInBytes)
058 Nome: file.dirname
Uso: file.dirname:/path/to/dir		 Afirma que a entrada é um arquivo e seu dirname é igual ao dirname fornecido. Atributo:
FileDirname::class
Método:
Validation::fileDirname(string $dirname)
059 Nome: file.basename
Uso: file.basename:file.ext		 Afirma que a entrada é um arquivo e seu nome base é igual ao nome base fornecido. Atributo:
FileBasename::class
Método:
Validation::fileBasename(string $basename)
060 Nome: file.filename
Uso: file.filename:file		 Afirma que a entrada é um arquivo e seu nome de arquivo é igual ao nome de arquivo fornecido. Atributo:
FileFilename::class
Método:
Validation::fileFilename(string $filename)
061 Nome: file.extension
Uso: file.extension:ext		 Afirma que a entrada é um arquivo e sua extensão é igual à extensão fornecida. Atributo:
FileExtension::class
Método:
Validation::fileExtension(string $extension)
062 Nome: file.mime
Uso: file.mime:text/plain		 Afirma que a entrada é um arquivo e seu tipo MIME é um dos tipos MIME fornecidos. Atributo:
FileMime::class
Método:
Validation::fileMime(string|array $mine)
063 Nome: image
Uso: image		 Afirma que a entrada é um arquivo de imagem (jpg, jpeg, png, gif, bmp, svg ou webp). Atributo:
Image::class
Método:
Validation::image()
064 Nome: image.width
Uso: image.width:1920		 Afirma que a entrada é uma imagem e sua largura é igual à largura fornecida em pixels. Atributo:
ImageWidth::class
Método:
Validation::imageWidth(int $width)
065 Nome: image.width.lte
Uso: image.width.lte:1920		 Afirma que a entrada é uma imagem e sua largura é menor ou igual à largura fornecida em pixels. Atributo:
ImageWidthLte::class
Método:
Validation::imageWidthLte(int $width)
066 Nome: image.width.gte
Uso: image.width.gte:1920		 Afirma que a entrada é uma imagem e sua largura é maior ou igual à largura fornecida em pixels. Atributo:
ImageWidthGte::class
Método:
Validation::imageWidthGte(int $width)
067 Nome: image.height
Uso: image.height:1080		 Afirma que a entrada é uma imagem e sua altura é igual à altura fornecida em pixels. Atributo:
ImageHeight::class
Método:
Validation::imageHeight(int $height)
068 Nome: image.height.lte
Uso: image.height.lte:1080		 Afirma que a entrada é uma imagem e sua altura é menor ou igual à altura fornecida em pixels. Atributo:
ImageHeightLte::class
Método:
Validation::imageHeightLte(int $height)
069 Nome: image.height.gte
Uso: image.height.gte:1080		 Afirma que a entrada é uma imagem e sua altura é maior ou igual à altura fornecida em pixels. Atributo:
ImageHeightGte::class
Método:
Validation::imageHeightGte(int $height)
070 Nome: image.dimensions
Uso: image.dimensions:1920,1080,==		 Afirma que a entrada é uma imagem e suas dimensões são menores, iguais ou maiores que a largura e altura fornecidas em pixels. Atributo:
ImageDimensions::class
Método:
Validation::imageDimensions(int $width, int $height, string $operator = '==')
071 Nome: image.ratio
Uso: image.ratio:16:9		 Afirma que a entrada é uma imagem e sua proporção é igual à proporção fornecida (a proporção deve ser especificada como uma fração como "16/9"). Atributo:
ImageRatio::class
Método:
Validation::imageRatio(string $ratio)
072 Nome: if
Uso: if:7,7,==		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição também pode ser especificado como o terceiro argumento. Atributo:
IfConstraint::class
Método:
Validation::if(mixed $actual, mixed $expected = true, string $operator = '==')
073 Nome: if.eq
Uso: if.eq:3,3		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é "==". Atributo:
IfEq::class
Método:
Validation::ifEq(mixed $actual, mixed $expected)
074 Nome: if.neq
Uso: if.neq:1,2		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é "!=". Atributo:
IfNeq::class
Método:
Validation::ifNeq(mixed $actual, mixed $expected)
075 Nome: if.id
Uso: if.id:3,3		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é "===". Atributo:
IfId::class
Método:
Validation::ifId(mixed $actual, mixed $expected)
076 Nome: if.nid
Uso: if.nid:1,2		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é "!==". Atributo:
IfNid::class
Método:
Validation::ifNid(mixed $actual, mixed $expected)
077 Nome: if.gt
Uso: if.gt:2,1		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é ">". Atributo:
IfGt::class
Método:
Validation::ifGt(mixed $actual, mixed $expected)
078 Nome: if.gte
Uso: if.gte:2,2		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é ">=". Atributo:
IfGte::class
Método:
Validation::ifGte(mixed $actual, mixed $expected)
079 Nome: if.lt
Uso: if.lt:1,2		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é "<". Atributo:
IfLt::class
Método:
Validation::ifLt(mixed $actual, mixed $expected)
080 Nome: if.lte
Uso: if.lte:1,2		 Verifica a condição entre o primeiro argumento e o segundo argumento, o operador de condição é "<=". Atributo:
IfLte::class
Método:
Validation::ifLte(mixed $actual, mixed $expected)
081 Nome: empty
Uso: empty		 Afirma que a entrada está vazia usando a construção da linguagem vazia() (está em branco, ou seja, string vazia, matriz vazia, falso, nulo ou 0). Atributo:
EmptyConstraint::class
Método:
Validation::empty()
082 Nome: required
Uso: required		 Afirma que a entrada é necessária (não está em branco, ou seja, não é uma string vazia ou nula). Atributo:
Required::class
Método:
Validation::required()
083 Nome: allowed
Uso: allowed		 Afirma que a entrada é permitida (pode estar vazia ou ter qualquer valor, string nula e vazia são considerados valores válidos). Atributo:
Allowed::class
Método:
Validation::allowed()
084 Nome: forbidden
Uso: forbidden		 Afirma que a entrada é proibida (é nula ou não está presente). Atributo:
Forbidden::class
Método:
Validation::forbidden()
085 Nome: accepted
Uso: accepted		 Afirma que a entrada é aceita (igual a: "on", "yes", "yeah", "yep", "yo", "ok", "okay", "aye", 1 ou "1", true ou " true") observe que as strings são tratadas sem distinção entre maiúsculas e minúsculas. Atributo:
Accepted::class
Método:
Validation::accepted()
086 Nome: declined
Uso: declined		 Afirma que a entrada foi recusada (igual a: "off", "no", "not", "nope", "neh", "nay", 0 ou "0", false ou "false") observe que as strings são tratadas sem distinção entre maiúsculas e minúsculas. Atributo:
Declined::class
Método:
Validation::declined()
087 Nome: bit
Uso: bit		 Afirma que a entrada é bit (igual a: 1 ou "1", verdadeiro; 0 ou "0", falso). Atributo:
Bit::class
Método:
Validation::bit()
088 Nome: bit.isOn
Uso: bit.isOn		 Afirma que a entrada é um bit ativado (igual a: verdadeiro, 1 ou "1"). Atributo:
BitIsOn::class
Método:
Validation::bitIsOn()
089 Nome: bit.isOff
Uso: bit.isOff		 Afirma que a entrada é um bit desligado (igual a: falso, 0 ou “0”). Atributo:
BitIsOff::class
Método:
Validation::bitIsOff()
090 Nome: equals
Uso: equals:value		 Afirma que a entrada é igual ao valor fornecido. Funciona com tipos escalares e nulos. O operador de comparação é "==". Atributo:
Equals::class
Método:
Validation::equals(string|int|float|bool|null $value)
091 Nome: matches
Uso: matches:'"/^[a-zA-Z0-9]+$/"'		 Afirma que a entrada corresponde ao padrão fornecido. Funciona apenas com strings. Atributo:
Matches::class
Método:
Validation::matches(string $pattern)
092 Nome: in
Uso: in:val1,val2,...		 Afirma que a entrada está nos valores fornecidos. Funciona com tipos escalares e nulos. Atributo:
In::class
Método:
Validation::in(string|int|float|bool|null ...$values)
093 Nome: count
Uso: count:3		 Afirma que a contagem de entrada é igual ao valor fornecido. Funciona com todos os tipos de dados (nulo: 0; booleano: 0 ou 1; float/inteiro: valor numérico; string: contagem de caracteres; array/contável: contagem de elementos; objeto: contagem de propriedades acessíveis). Atributo:
Count::class
Método:
Validation::count(int $count)
094 Nome: min
Uso: min:3		 Afirma que a contagem de entrada é maior ou igual ao valor fornecido. Funciona com todos os tipos de dados (nulo: 0; booleano: 0 ou 1; float/inteiro: valor numérico; string: contagem de caracteres; array/contável: contagem de elementos; objeto: contagem de propriedades acessíveis). Atributo:
Min::class
Método:
Validation::min(int|float $count)
095 Nome: max
Uso: max:3		 Afirma que a contagem de entrada é menor ou igual ao valor fornecido. Funciona com todos os tipos de dados (nulo: 0; booleano: 0 ou 1; float/inteiro: valor numérico; string: contagem de caracteres; array/contável: contagem de elementos; objeto: contagem de propriedades acessíveis). Atributo:
Max::class
Método:
Validation::max(int|float $count)
096 Nome: between
Uso: between:3,7		 Afirma que a contagem de entrada está entre os valores fornecidos. Funciona com todos os tipos de dados (nulo: 0; booleano: 0 ou 1; float/inteiro: valor numérico; string: contagem de caracteres; array/contável: contagem de elementos; objeto: contagem de propriedades acessíveis). Atributo:
Between::class
Método:
Validation::between(int|float $min, int|float $max)
097 Nome: number.isPositive
Uso: number.isPositive		 Afirma que a entrada é um número positivo. Atributo:
NumberIsPositive::class
Método:
Validation::numberIsPositive()
098 Nome: number.isNegative
Uso: number.isNegative		 Afirma que a entrada é um número negativo. Atributo:
NumberIsNegative::class
Método:
Validation::numberIsNegative()
099 Nome: number.isEven
Uso: number.isEven		 Afirma que a entrada é um número par. Atributo:
NumberIsEven::class
Método:
Validation::numberIsEven()
100 Nome: number.isOdd
Uso: number.isOdd		 Afirma que a entrada é um número ímpar. Atributo:
NumberIsOdd::class
Método:
Validation::numberIsOdd()
101 Nome: number.isMultipleOf
Uso: number.isMultipleOf:3		 Afirma que a entrada é um múltiplo do número fornecido. Atributo:
NumberIsMultipleOf::class
Método:
Validation::numberIsMultipleOf(float $number)
102 Nome: number.isFinite
Uso: number.isFinite		 Afirma que a entrada é um número finito. Atributo:
NumberIsFinite::class
Método:
Validation::numberIsFinite()
103 Nome: number.isInfinite
Uso: number.isInfinite		 Afirma que a entrada é um número infinito. Atributo:
NumberIsInfinite::class
Método:
Validation::numberIsInfinite()
104 Nome: number.isNan
Uso: number.isNan		 Afirma que a entrada não é um número. Atributo:
NumberIsNan::class
Método:
Validation::numberIsNan()
105 Nome: string.charset
Uso: string.charset:UTF-8		 Afirma que a entrada está codificada em um dos conjuntos de caracteres fornecidos (aliases incluídos). A verificação é feita diferenciando maiúsculas de minúsculas. Atributo:
StringCharset::class
Método:
Validation::stringCharset(string|array $charset)
106 Nome: string.contains
Uso: string.contains:substring		 Afirma que a entrada contém a substring fornecida. Um segundo argumento booleano pode ser especificado para ativar o modo estrito (diferencia maiúsculas de minúsculas). Atributo:
StringContains::class
Método:
Validation::stringContains(string $substring, bool $strict = false)
107 Nome: string.startsWith
Uso: string.startsWith:substring,1		 Afirma que a entrada começa com a substring fornecida. Um segundo argumento booleano pode ser especificado para ativar o modo estrito (diferencia maiúsculas de minúsculas). Atributo:
StringStartsWith::class
Método:
Validation::stringStartsWith(string $substring, bool $strict = false)
108 Nome: string.endsWith
Uso: string.endsWith:substring,0		 Afirma que a entrada termina com a substring fornecida. Um segundo argumento booleano pode ser especificado para ativar o modo estrito (diferencia maiúsculas de minúsculas). Atributo:
StringEndsWith::class
Método:
Validation::stringEndsWith(string $substring, bool $strict = false)
109 Nome: string.length
Uso: string.length:3		 Afirma que a entrada é uma string com exatamente o comprimento determinado. Atributo:
StringLength::class
Método:
Validation::stringLength(int $length)
110 Nome: string.wordsCount
Uso: string.wordsCount:3		 Afirma que a entrada é uma string contendo exatamente a contagem de palavras fornecida. Atributo:
StringWordsCount::class
Método:
Validation::stringWordsCount(int $count)
111 Nome: array.hasKey
Uso: array.hasKey:key		 Afirma que a matriz de entrada possui a chave fornecida. Atributo:
ArrayHasKey::class
Método:
Validation::arrayHasKey(string|int $key)
112 Nome: array.hasValue
Uso: array.hasValue:value		 Afirma que a matriz de entrada contém o valor fornecido. Funciona com tipos escalares. Atributo:
ArrayHasValue::class
Método:
Validation::arrayHasValue(mixed $value)
113 Nome: array.hasDistinct
Uso: array.hasDistinct:key		 Afirma que a entrada é uma matriz multidimensional que contém valores distintos da chave fornecida. Atributo:
ArrayHasDistinct::class
Método:
Validation::arrayHasDistinct(string|int $key)
114 Nome: array.isAssociative
Uso: array.isAssociative		 Afirma que a entrada é uma matriz associativa. Atributo:
ArrayIsAssociative::class
Método:
Validation::arrayIsAssociative()
115 Nome: array.isSequential
Uso: array.isSequential		 Afirma que a entrada é uma matriz sequencial. Atributo:
ArrayIsSequential::class
Método:
Validation::arrayIsSequential()
116 Nome: array.isUnique
Uso: array.isUnique		 Afirma que a matriz de entrada contém valores exclusivos. Funciona apenas com matrizes unidimensionais. Atributo:
ArrayIsUnique::class
Método:
Validation::arrayIsUnique()
117 Nome: array.subset
Uso: array.subset:'{"a":1,"b":2}'		 Afirma que a entrada é uma matriz que contém o subconjunto fornecido. Observe que esta verificação se aplica apenas à primeira dimensão da matriz. Atributo:
ArraySubset::class
Método:
Validation::arraySubset(array $subset)
118 Nome: object.hasProperty
Uso: object.hasProperty:property		 Afirma que a entrada possui a propriedade fornecida. Atributo:
ObjectHasProperty::class
Método:
Validation::objectHasProperty(string $property)
119 Nome: object.hasMethod
Uso: object.hasMethod:method		 Afirma que a entrada possui o método fornecido. Atributo:
ObjectHasMethod::class
Método:
Validation::objectHasMethod(string $method)
120 Nome: object.isStringable
Uso: object.isStringable		 Afirma que a entrada implementa o método __toString(). Atributo:
ObjectIsStringable::class
Método:
Validation::objectIsStringable()
121 Nome: object.isInstanceOf
Uso: object.isInstanceOf:NamespaceClass		 Afirma que a entrada é uma instância da classe fornecida. Atributo:
ObjectIsInstanceOf::class
Método:
Validation::objectIsInstanceOf(string $classFQN)
122 Nome: object.isSubclassOf
Uso: object.isSubclassOf:NamespaceClass		 Afirma que a entrada é uma subclasse da classe fornecida. Atributo:
ObjectIsSubclassOf::class
Método:
Validation::objectIsSubclassOf(string $classFQN)
123 Nome: serialized
Uso: serialized		 Afirma que a entrada é um dado serializado PHP válido. Atributo:
Serialized::class
Método:
Validation::serialized()
124 Nome: json
Uso: json		 Afirma que a entrada é um JSON válido. Atributo:
Json::class
Método:
Validation::json()
125 Nome: base64
Uso: base64		 Afirma que a entrada é uma string codificada em Base64 válida. Atributo:
Base64::class
Método:
Validation::base64()
126 Nome: xml
Uso: xml		 Afirma que a entrada é um XML válido. Atributo:
Xml::class
Método:
Validation::xml()
127 Nome: locale
Uso: locale		 Afirma que a entrada é um identificador de localidade válido (padrão: [ISO 639-1] ou [ISO 639-1]_[ISO 3166-1 alpha-2], sem distinção entre maiúsculas e minúsculas, a entrada é canônica antes da verificação (traços para sublinhados, sem pontos ou conjunto de caracteres estrito: [ISO 639-1] ou [ISO 639-1]_[ISO 3166-1 alpha-2], diferencia maiúsculas de minúsculas sem canonização. Atributo:
Locale::class
Método:
Validation::locale(bool $strict = false)
128 Nome: language
Uso: language		 Afirma que a entrada é um código de idioma válido (padrão: "ISO 639-1"; longo: "ISO 639-2/T"). Atributo:
Language::class
Método:
Validation::language(bool $long = false)
129 Nome: country
Uso: country		 Afirma que a entrada é um código de país válido (padrão: "ISO 3166-1 alfa-2"; longo: "ISO 3166-1 alfa-3"). Atributo:
Country::class
Método:
Validation::country(bool $long = false)
130 Nome: timezone
Uso: timezone		 Afirma que a entrada é um identificador de fuso horário válido (padrão: não diferencia maiúsculas de minúsculas; estrito: diferencia maiúsculas de minúsculas). Atributo:
Timezone::class
Método:
Validation::timezone(bool $strict = false)
131 Nome: datetime
Uso: datetime		 Afirma que a entrada é uma string/objeto de data e hora válido. Atributo:
Datetime::class
Método:
Validation::datetime()
132 Nome: datetime.eq
Uso: datetime.eq:"2015-01-01"		 Afirma que a entrada é igual à string de data e hora fornecida. Atributo:
DatetimeEq::class
Método:
Validation::datetimeEq(string $datetime)
133 Nome: datetime.lt
Uso: datetime.lt:tomorrow		 Afirma que a entrada é uma string/objeto de data e hora menor que (antes) da string de data e hora fornecida. Atributo:
DatetimeLt::class
Método:
Validation::datetimeLt(string $datetime)
134 Nome: datetime.lte
Uso: datetime.lte:tomorrow		 Afirma que a entrada é uma string/objeto de data e hora menor que (antes) ou igual à string de data e hora fornecida. Atributo:
DatetimeLte::class
Método:
Validation::datetimeLte(string $datetime)
135 Nome: datetime.gt
Uso: datetime.gt:today		 Afirma que a entrada é uma string/objeto de data e hora maior que (após) a string de data e hora fornecida. Atributo:
DatetimeGt::class
Método:
Validation::datetimeGt(string $datetime)
136 Nome: datetime.gte
Uso: datetime.gte:today		 Afirma que a entrada é uma string/objeto de data e hora maior que (depois) ou igual à string de data e hora fornecida. Atributo:
DatetimeGte::class
Método:
Validation::datetimeGte(string $datetime)
137 Nome: datetime.birthday
Uso: datetime.birthday		 Afirma que a entrada é uma string/objeto de data e hora que faz aniversário hoje. A entrada deve estar preferencialmente no formato "AAAA-MM-DD". Atributo:
DatetimeBirthday::class
Método:
Validation::datetimeBirthday()
138 Nome: datetime.format
Uso: datetime.format:"Ymd H:i:s"		 Afirma que a entrada é uma data/hora válida com o formato fornecido. Atributo:
DatetimeFormat::class
Método:
Validation::datetimeFormat(string $format)
139 Nome: datetime.format.global
Uso: datetime.format.global		 Afirma que a entrada se parece com uma string de data e hora global válida, conforme definido na especificação HTML5. Atributo:
DatetimeFormatGlobal::class
Método:
Validation::datetimeFormatGlobal()
140 Nome: datetime.format.local
Uso: datetime.format.local		 Afirma que a entrada se parece com uma string de data e hora local válida, conforme definido na especificação HTML5. Atributo:
DatetimeFormatLocal::class
Método:
Validation::datetimeFormatLocal()
141 Nome: datestamp
Uso: datestamp		 Afirma que a entrada se parece com um carimbo de data humano, formato DMY ou MDY, separado por ponto, traço ou barra. Atributo:
Datestamp::class
Método:
Validation::datestamp()
142 Nome: datestamp.ymd
Uso: datestamp.ymd		 Afirma que a entrada se parece com um carimbo de data formatado em YMD humano, separado por ponto, traço ou barra. Atributo:
DatestampYmd::class
Método:
Validation::datestampYmd()
143 Nome: datestamp.dmy
Uso: datestamp.dmy		 Afirma que a entrada se parece com um carimbo de data formatado em DMY humano, separado por ponto, traço ou barra. Atributo:
DatestampDmy::class
Método:
Validation::datestampDmy()
144 Nome: datestamp.mdy
Uso: datestamp.mdy		 Afirma que a entrada se parece com um carimbo de data formatado em MDY humano, separado por ponto, traço ou barra. Atributo:
DatestampMdy::class
Método:
Validation::datestampMdy()
145 Nome: timestamp
Uso: timestamp		 Afirma que a entrada se parece com um carimbo de data/hora humano, formato de 24 ou 12 horas com ou sem segundos. Atributo:
Timestamp::class
Método:
Validation::timestamp()
146 Nome: timestamp.12
Uso: timestamp.12		 Afirma que a entrada se parece com um carimbo de data/hora humano, formato de 12 horas com ou sem segundos e AM/PM opcional. Atributo:
Timestamp12::class
Método:
Validation::timestamp12()
147 Nome: timestamp.hms
Uso: timestamp.hms		 Afirma que a entrada se parece com um carimbo de data/hora humano, formato de 24 ou 12 horas com segundos. Atributo:
TimestampHms::class
Método:
Validation::timestampHms()
148 Nome: timestamp.hm
Uso: timestamp.hm		 Afirma que a entrada se parece com um carimbo de data/hora humano, formato de 24 ou 12 horas sem segundos. Atributo:
TimestampHm::class
Método:
Validation::timestampHm()
149 Nome: timestamp.ms
Uso: timestamp.ms		 Afirma que a entrada se parece com um carimbo de data/hora humano, contendo apenas minutos e segundos. Atributo:
TimestampMs::class
Método:
Validation::timestampMs()
150 Nome: calender.day
Uso: calender.day		 Afirma que a entrada se parece com um dia do calendário em formato plano ou longo ("Seg" ou "Segunda-feira"). Atributo:
CalenderDay::class
Método:
Validation::calenderDay()
151 Nome: calender.month
Uso: calender.month		 Afirma que a entrada se parece com um mês do calendário em formato curto ou longo ("janeiro" ou "janeiro"). Atributo:
CalenderMonth::class
Método:
Validation::calenderMonth()
152 Nome: username
Uso: username		 Afirma que a entrada é um nome de usuário válido (entre 4 e 32 caracteres, consiste em letras em qualquer caso, opcionalmente números, opcionalmente um dos seguintes caracteres "-_." (não consecutivos) e deve sempre começar com uma letra e terminar com uma letra ou número). Atributo:
Username::class
Método:
Validation::username()
153 Nome: password
Uso: password		 Afirma que a entrada é uma senha válida (mínimo de 8 caracteres, composta por pelo menos uma letra minúscula e uma letra maiúscula, pelo menos um número, pelo menos um caractere especial e, opcionalmente, um espaço). Atributo:
Password::class
Método:
Validation::password()
154 Nome: uuid
Uso: uuid		 Afirma que a entrada é um UUID válido. A versão (v1/v2/v3/v4/v5) pode ser especificada para restringir o padrão. Atributo:
Uuid::class
Método:
Validation::uuid(string|int|null $version = null)
155 Nome: ascii
Uso: ascii		 Afirma que a entrada é uma string contendo apenas caracteres ASCII (string compatível com ASCII). Atributo:
Ascii::class
Método:
Validation::ascii()
156 Nome: slug
Uso: slug		 Afirma que a entrada é um slug válido. Atributo:
Slug::class
Método:
Validation::slug()
157 Nome: meta
Uso: meta		 Afirma que a entrada é uma string contendo apenas metacaracteres (caracteres especiais) (ou seja, "@, #, $, ..."). Atributo:
Meta::class
Método:
Validation::meta()
158 Nome: text
Uso: text		 Afirma que a entrada é uma string contendo letras e pontuação de qualquer idioma. Atributo:
Text::class
Método:
Validation::text()
159 Nome: words
Uso: words		 Afirma que a entrada é uma string contendo apenas palavras e espaços sem nenhum outro caractere. Atributo:
Words::class
Método:
Validation::words()
160 Nome: spaceless
Uso: spaceless		 Afirma que a entrada é uma string que não contém caracteres de espaço em branco. Atributo:
Spaceless::class
Método:
Validation::spaceless()
161 Nome: emoji
Uso: emoji		 Afirma que a entrada contém um emoji. Atributo:
Emoji::class
Método:
Validation::emoji()
162 Nome: roman
Uso: roman		 Afirma que a entrada é um número romano válido. Atributo:
Roman::class
Método:
Validation::roman()
163 Nome: phone
Uso: phone		 Afirma que a entrada é um número de telefone válido (suporta: América do Norte, Europa e a maioria dos países da Ásia e do Oriente Médio). Atributo:
Phone::class
Método:
Validation::phone()
164 Nome: geolocation
Uso: geolocation		 Afirma que a entrada é uma geolocalização válida (combinação de coordenadas de latitude e longitude). Atributo:
Geolocation::class
Método:
Validation::geolocation()
165 Nome: version
Uso: version		 Afirma que a entrada é um número de versão semântica válido. Atributo:
Version::class
Método:
Validation::version()
166 Nome: amount
Uso: amount		 Afirma que a entrada contém apenas números, um ponto decimal opcional (vírgula ou ponto) e um sinal de menos opcional (usado para quantias de dinheiro, por exemplo). Atributo:
Amount::class
Método:
Validation::amount()
167 Nome: amount.dollar
Uso: amount.dollar		 Afirma que a entrada é um valor em USD formatado de forma válida, onde o ponto decimal e o separador de milhares são opcionais. Atributo:
AmountDollar::class
Método:
Validation::amountDollar()
168 Nome: amount.euro
Uso: amount.euro		 Afirma que a entrada é um valor de EUR formatado de forma válida, onde o ponto decimal e o separador de milhares são opcionais. Atributo:
AmountEuro::class
Método:
Validation::amountEuro()
169 Nome: color
Uso: color		 Afirma que a entrada é uma cor CSS válida (palavra-chave "loose", HEX, HEX-Alpha, RGB, RGBA, RGB "nova sintaxe", HSL, HSLA, HSL "nova sintaxe"). Atributo:
Color::class
Método:
Validation::color()
170 Nome: color.hex
Uso: color.hex		 Afirma que a entrada é uma cor CSS HEX válida. Atributo:
ColorHex::class
Método:
Validation::colorHex()
171 Nome: color.hexShort
Uso: color.hexShort		 Afirma que a entrada é uma cor CSS 3-Char-HEX válida. Atributo:
ColorHexShort::class
Método:
Validation::colorHexShort()
172 Nome: color.hexLong
Uso: color.hexLong		 Afirma que a entrada é uma cor CSS 6-Char-HEX válida. Atributo:
ColorHexLong::class
Método:
Validation::colorHexLong()
173 Nome: color.hexAlpha
Uso: color.hexAlpha		 Afirma que a entrada é uma cor CSS HEX-Alpha válida (4 ou 8 caracteres). Atributo:
ColorHexAlpha::class
Método:
Validation::colorHexAlpha()
174 Nome: color.rgb
Uso: color.rgb		 Afirma que a entrada é uma cor CSS RGB válida. Atributo:
ColorRgb::class
Método:
Validation::colorRgb()
175 Nome: color.rgba
Uso: color.rgba		 Afirma que a entrada é uma cor CSS RGBA válida. Atributo:
ColorRgba::class
Método:
Validation::colorRgba()
176 Nome: color.rgb.new
Uso: color.rgb.new		 Afirma que a entrada é uma cor CSS4 RGB válida. Atributo:
ColorRgbNew::class
Método:
Validation::colorRgbNew()
177 Nome: color.hsl
Uso: color.hsl		 Afirma que a entrada é uma cor CSS HSL válida. Atributo:
ColorHsl::class
Método:
Validation::colorHsl()
178 Nome: color.hsla
Uso: color.hsla		 Afirma que a entrada é uma cor CSS HSLA válida. Atributo:
ColorHsla::class
Método:
Validation::colorHsla()
179 Nome: color.hsl.new
Uso: color.hsl.new		 Afirma que a entrada é uma cor CSS4 HSL válida. Atributo:
ColorHslNew::class
Método:
Validation::colorHslNew()
180 Nome: color.keyword
Uso: color.keyword		 Afirma que a entrada é uma cor de palavra -chave CSS válida (rigorosa, como na especificação CSS). Atributo:
ColorKeyword::class
Método:
Validation::colorKeyword()
181 Nome: ssn
Uso: ssn		 Afirma que a entrada é um SSN válido (número do Seguro Social dos EUA). Atributo:
Ssn::class
Método:
Validation::ssn()
182 Nome: sin
Uso: sin		 Afirma que a entrada é um sin válido (número de seguro social da CA). Atributo:
Sin::class
Método:
Validation::sin()
183 Nome: nino
Uso: nino		 Afirma que a entrada é um Nino válido (número de seguro nacional do Reino Unido). Atributo:
Nino::class
Método:
Validation::nino()
184 Nome: vin
Uso: vin		 Afirma que a entrada é um VIN válido (número de identificação do veículo). Atributo:
Vin::class
Método:
Validation::vin()
185 Nome: issn
Uso: issn		 Afirma que a entrada é um ISSN válido (número de série padrão internacional). Atributo:
Issn::class
Método:
Validation::issn()
186 Nome: isin
Uso: isin		 Afirma que a entrada é um ISIN válido (número de identificação de valores mobiliários internacionais). Atributo:
Isin::class
Método:
Validation::isin()
187 Nome: isbn
Uso: isbn		 Afirma que a entrada é um ISBN válido (número do livro padrão internacional). O tipo (10/13) pode ser especificado para restringir o padrão. Atributo:
Isbn::class
Método:
Validation::isbn(string|int|null $type = null)
188 Nome: imei
Uso: imei		 Afirma que a entrada é um IMEI válido (número de identidade de equipamentos de estação móvel internacional). Atributo:
Imei::class
Método:
Validation::imei()
189 Nome: imei.sv
Uso: imei.sv		 Afirma que a entrada é um IMEI-SV válido (identidade internacional de equipamentos para estações móveis e número de versão do software). Atributo:
ImeiSv::class
Método:
Validation::imeiSv()
190 Nome: meid
Uso: meid		 Afirma que a entrada é um MEID válido (identificador de equipamentos móveis). Atributo:
Meid::class
Método:
Validation::meid()
191 Nome: esn
Uso: esn		 Afirma que a entrada é um ESN válido (número de série eletrônico). Atributo:
Esn::class
Método:
Validation::esn()
192 Nome: currency
Uso: currency		 Afirma que a entrada é um código de moeda válido (padrão: "ISO 4217 alpha"; numérico: "ISO 4217 numérico"). Atributo:
Currency::class
Método:
Validation::currency(bool $numeric = false)
193 Nome: currency.name
Uso: currency.name		 Afirma que a entrada é um nome de moeda válido (como na ISO 4217). Atributo:
CurrencyName::class
Método:
Validation::currencyName()
194 Nome: creditcard
Uso: creditcard		 Afirma que a entrada é um número de cartão de crédito válido, espaços equilibrados e/ou traços são permitidos. Atributo:
Creditcard::class
Método:
Validation::creditcard()
195 Nome: creditcard.visa
Uso: creditcard.visa		 Afirma que a entrada é um número de cartão de crédito Visa válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardVisa::class
Método:
Validation::creditcardVisa()
196 Nome: creditcard.mastercard
Uso: creditcard.mastercard		 Afirma que a entrada é um número de cartão de crédito MasterCard válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardMastercard::class
Método:
Validation::creditcardMastercard()
197 Nome: creditcard.discover
Uso: creditcard.discover		 Afirma que a entrada é um número de cartão de crédito Discover válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardDiscover::class
Método:
Validation::creditcardDiscover()
198 Nome: creditcard.americanExpress
Uso: creditcard.americanExpress		 Afirma que a entrada é um número válido de cartão de crédito American Express, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardAmericanExpress::class
Método:
Validation::creditcardAmericanExpress()
199 Nome: creditcard.dinersClub
Uso: creditcard.dinersClub		 Afirma que a entrada é um número de cartão de crédito do Diners Club válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardDinersClub::class
Método:
Validation::creditcardDinersClub()
200 Nome: creditcard.jcb
Uso: creditcard.jcb		 Afirma que a entrada é um número de cartão de crédito JCB válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardJcb::class
Método:
Validation::creditcardJcb()
201 Nome: creditcard.maestro
Uso: creditcard.maestro		 Afirma que a entrada é um número de cartão de crédito Maestro válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardMaestro::class
Método:
Validation::creditcardMaestro()
202 Nome: creditcard.chinaUnionPay
Uso: creditcard.chinaUnionPay		 Afirma que a entrada é um número válido de cartão de crédito da China UnionPay, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardChinaUnionPay::class
Método:
Validation::creditcardChinaUnionPay()
203 Nome: creditcard.instaPayment
Uso: creditcard.instaPayment		 Afirma que a entrada é um número de cartão de crédito Instapayment válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardInstaPayment::class
Método:
Validation::creditcardInstaPayment()
204 Nome: creditcard.laser
Uso: creditcard.laser		 Afirma que a entrada é um número de cartão de crédito a laser válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardLaser::class
Método:
Validation::creditcardLaser()
205 Nome: creditcard.uatp
Uso: creditcard.uatp		 Afirma que a entrada é um número de cartão de crédito UATP válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardUatp::class
Método:
Validation::creditcardUatp()
206 Nome: creditcard.mir
Uso: creditcard.mir		 Afirma que a entrada é um número de cartão do sistema de pagamento MIR válido, espaços equilibrados e/ou traços são permitidos. Atributo:
CreditcardMir::class
Método:
Validation::creditcardMir()
207 Nome: cvv
Uso: cvv		 Afirma que a entrada é um CVV válido (código de segurança do cartão). Atributo:
Cvv::class
Método:
Validation::cvv()
208 Nome: bic
Uso: bic		 Afirma que a entrada é um BIC válido (código de identificador bancário). Atributo:
Bic::class
Método:
Validation::bic()
209 Nome: iban
Uso: iban:IQ		 Afirma que a entrada é um IBAN válido (número da conta bancária internacional). O código do país "ISO 3166-1 alfa-2" pode ser especificado para restringir o padrão. Atributo:
Iban::class
Método:
Validation::iban(?string $country = null)
210 Nome: luhn
Uso: luhn		 Afirma que a entrada passa a verificação do algoritmo Luhn. Esta regra é usada principalmente em conjunto com outras regras, como números e identificadores de cartão de crédito para verificar ainda mais a validade do assunto. Atributo:
Luhn::class
Método:
Validation::luhn()
211 Nome: php.keyword
Uso: php.keyword		 Afirma que a entrada é uma palavra -chave do idioma PHP. Atributo:
PhpKeyword::class
Método:
Validation::phpKeyword()
212 Nome: php.reserved
Uso: php.reserved		 Afirma que a entrada é uma palavra reservada para idioma php. Atributo:
PhpReserved::class
Método:
Validation::phpReserved()
213 Nome: php.reserved.extra
Uso: php.reserved.extra		 Afirma que a entrada é uma palavra de idioma PHP, incluindo palavras suaves reservadas. Atributo:
PhpReservedExtra::class
Método:
Validation::phpReservedExtra()
214 Nome: regex
Uso: regex		 Afirma que a entrada é uma expressão regular válida. Atributo:
Regex::class
Método:
Validation::regex()
215 Nome: bool
Uso: veja boolean		 Alias, consulte a boolean para obter a descrição completa. Atributo:
BoolConstraint::class
Método:
Validation::bool()
216 Nome: int
Uso: veja integer		 Alias, consulte o integer para obter a descrição completa. Atributo:
IntConstraint::class
Método:
Validation::int()
217 Nome: long
Uso: veja integer		 Alias, consulte o integer para obter a descrição completa. Atributo:
Long::class
Método:
Validation::long()
218 Nome: double
Uso: veja float		 Alias, consulte o float para obter a descrição completa. Atributo:
Double::class
Método:
Validation::double()
219 Nome: real
Uso: veja float		 Alias, consulte o float para obter a descrição completa. Atributo:
Real::class
Método:
Validation::real()
220 Nome: str
Uso: veja string		 Alias, consulte a string para obter a descrição completa. Atributo:
Str::class
Método:
Validation::str()
221 Nome: arr
Uso: veja array		 Alias, consulte a array para obter a descrição completa. Atributo:
Arr::class
Método:
Validation::arr()
222 Nome: obj
Uso: veja object		 Alias, consulte o object para obter a descrição completa. Atributo:
Obj::class
Método:
Validation::obj()
223 Nome: stream
Uso: consulte resource		 Alias, consulte o resource para obter a descrição completa. Atributo:
Stream::class
Método:
Validation::stream()
224 Nome: assert
Uso: veja if		 Alias, consulte if para obter a descrição completa. Atributo:
Assert::class
Método:
Validation::assert(mixed $actual, mixed $expected = true, string $operator = '==')
225 Nome: assert.equals
Uso: veja if.eq		 Alias, consulte o if.eq para obter a descrição completa. Atributo:
AssertEquals::class
Método:
Validation::assertEquals(mixed $actual, mixed $expected)
226 Nome: assert.notEquals
Uso: veja if.neq		 Alias, consulte o if.neq para obter a descrição completa. Atributo:
AssertNotEquals::class
Método:
Validation::assertNotEquals(mixed $actual, mixed $expected)
227 Nome: assert.greaterThan
Uso: veja if.gt		 Alias, consulte o if.gt para obter a descrição completa. Atributo:
AssertGreaterThan::class
Método:
Validation::assertGreaterThan(mixed $actual, mixed $expected)
228 Nome: assert.greaterThanOrEquals
Uso: veja if.gte		 Alias, consulte o if.gte para obter a descrição completa. Atributo:
AssertGreaterThanOrEquals::class
Método:
Validation::assertGreaterThanOrEquals(mixed $actual, mixed $expected)
229 Nome: assert.lessThan
Uso: veja if.lt		 Alias, consulte o if.lt para obter a descrição completa. Atributo:
AssertLessThan::class
Método:
Validation::assertLessThan(mixed $actual, mixed $expected)
230 Nome: assert.lessThanOrEquals
Uso: veja if.lte		 Alias, consulte o if.lte para obter a descrição completa. Atributo:
AssertLessThanOrEquals::class
Método:
Validation::assertLessThanOrEquals(mixed $actual, mixed $expected)
231 Nome: blank
Uso: veja empty		 Alias, consulte o empty para obter a descrição completa. Atributo:
Blank::class
Método:
Validation::blank()
232 Nome: is
Uso: veja equals		 Alias, consulte equals para obter a descrição completa. Atributo:
Is::class
Método:
Validation::is(mixed $value)
233 Nome: same
Uso: veja equals		 Alias, consulte equals para obter a descrição completa. Atributo:
Same::class
Método:
Validation::same(mixed $value)
234 Nome: pattern
Uso: veja matches		 Alias, consulte as matches para obter a descrição completa. Atributo:
Pattern::class
Método:
Validation::pattern(string $pattern)
235 Nome: choice
Uso: veja in		 Alias, in a descrição completa. Atributo:
Choice::class
Método:
Validation::choice(string|int|float|bool|null ...$values)
236 Nome: size
Uso: veja count		 Alias, consulte a count para obter a descrição completa. Atributo:
Size::class
Método:
Validation::size(int $size)
237 Nome: length
Uso: veja count		 Alias, consulte a count para obter a descrição completa. Atributo:
Length::class
Método:
Validation::length(int $count)
238 Nome: range
Uso: veja between		 Alias, consulte between a descrição completa. Atributo:
Range::class
Método:
Validation::range(int|float $min, int|float $max)
239 Nome: minmax
Uso: veja between		 Alias, consulte between a descrição completa. Atributo:
Minmax::class
Método:
Validation::minmax(int|float $min, int|float $max)
240 Nome: filled
Uso: veja required		 Alias, required a descrição completa. Atributo:
Filled::class
Método:
Validation::filled()
241 Nome: present
Uso: veja required		 Alias, required a descrição completa. Atributo:
Present::class
Método:
Validation::present()
242 Nome: optional
Uso: veja allowed		 Alias, allowed a descrição completa. Atributo:
Optional::class
Método:
Validation::optional()
243 Nome: date
Uso: consulte datetime		 Alias, consulte o datetime para obter a descrição completa. Atributo:
Date::class
Método:
Validation::date()
244 Nome: date.equals
Uso: consulte datetime.eq		 Alias, consulte o datetime.eq para obter a descrição completa. Atributo:
DateEquals::class
Método:
Validation::dateEquals(string $datetime)
245 Nome: date.before
Uso: consulte datetime.lt		 Alias, consulte o datetime.lt para obter a descrição completa. Atributo:
DateBefore::class
Método:
Validation::dateBefore(string $datetime)
246 Nome: date.beforeOrEquals
Uso: consulte datetime.lte		 Alias, consulte o datetime.lte para obter a descrição completa. Atributo:
DateBeforeOrEquals::class
Método:
Validation::dateBeforeOrEquals(string $datetime)
247 Nome: date.after
Uso: consulte datetime.gt		 Alias, consulte o datetime.gt para obter a descrição completa. Atributo:
DateAfter::class
Método:
Validation::dateAfter(string $datetime)
248 Nome: date.afterOrEquals
Uso: consulte datetime.gte		 Alias, consulte o datetime.gte para obter a descrição completa. Atributo:
DateAfterOrEquals::class
Método:
Validation::dateAfterOrEquals(string $datetime)
249 Nome: date.format
Uso: consulte datetime.format		 Alias, consulte o datetime.format para obter a descrição completa. Atributo:
DateFormat::class
Método:
Validation::dateFormat(string $format)
250 Nome: cakeday
Uso: consulte datetime.birthday		 Alias, consulte o datetime.birthday para obter a descrição completa. Atributo:
Cakeday::class
Método:
Validation::cakeday()

Macros

macro Expressão de validação
[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"

Benchmarks

Até agora, pode parecer que mighty está fazendo muito e as preocupações de desempenho estão começando a surgir. Bem, não há necessidade de se preocupar com isso. mighty é muito rápido e é otimizado para fornecer o melhor desempenho. Aqui estão alguns benchmarks do desempenho do validador:

Não é tão científico referência

O desempenho do mighty Validator e Laravel Validator em um aplicativo Laravel. O teste foi realizado usando uma matriz de 50000 elementos, metade deles são inteiros e a outra metade são seqüências numéricas. Cada validador foi testado 10 vezes (consecutivamente) e o resultado médio desses 10 foi coletado:

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 ' ,
]

Então, mighty é cerca de 12,5x vezes mais rápido que o Validador do Laravel com o Xdebug desativado e cerca de 4x vezes mais rápido com o Xdebug ativado.

Referência científica

O benchmark é feito usando o PHPBEnch. Aqui está uma visão geral rápida:

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

■ Fato: o resultado mais recente de referência também pode ser encontrado no pipeline de IC, que será atualizado com cada push/pr para o upsteam.

Notas

  1. mighty gera mensagens de erro realmente amigáveis ​​por padrão (atualmente apenas em inglês). Essas mensagens podem ser facilmente substituídas em bases de validador/restrição. Você pode querer ter essas mensagens em diferentes idiomas, para isso, o método MAKS mighty Rule::setMessageTranslator() pode ser usado. Este método é uma maneira conveniente de definir um tradutor de mensagem global, é necessário um fechamento que recebe a mensagem bruta (com os espaços reservados) como um argumento e deve retornar a versão traduzida dessa mensagem.
  2. Consulte a mighty especificação da linguagem de expressão de validação de validação para saber mais sobre a teoria por trás mighty e entender como o idioma funciona.
  3. Consulte a mighty API Documentation para saber mais sobre a API PHP. A API está bem documentada e não deve haver nada que não seja coberto lá.
  4. Atualmente, mighty é uma biblioteca de validação pura, não faz nenhum tipo de transformação nos dados. O motor e o design atual são flexíveis o suficiente e podem ser usados ​​para implementar facilmente um desinfetante em cima, não há plano para fazer isso no momento, mas pode ser um marco futuro.

Licença

mighty é um projeto de código aberto licenciado sob a licença do MIT .
Copyright (C) 2022 Marwan al-Soltany. Todos os direitos reservados.

Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos