Inicio>código fuente PHP>Otras categorias
Descargar

mighty

¡La última biblioteca de validación que necesitará!


Tabla de contenido

Instalación
Acerca de mighty
Inicio rápido
mVEL
Ejemplos
Restricciones
Validaciones
Documentación
Especificación
Registro de cambios


Si te gusta este proyecto y te gustaría apoyar su desarrollo, ¡te lo agradeceríamos!


Características clave

  1. Cero dependencias.
  2. Independiente del marco, se puede integrar en cualquier base de código.
  3. Expresivo, intuitivo y fácil de manejar con más de 250 reglas de validación integradas.

<clase abarcada= poderosa demostración" style="max-width: 100%;">

Instalación 

composer require marwanalsoltany/ mighty

Acerca de mighty

La validación es una tarea común en cualquier aplicación web. Los datos pasados ​​a la aplicación a través de formularios (o cualquier tipo de entrada) siempre deben validarse según un conjunto de reglas. mighty puede manejar de una manera fácil y expresiva.

mighty es una biblioteca de validación rápida, poderosa, robusta y fácil de usar con la que es divertido trabajar, hace que validar cualquier dato sea muy sencillo. Gracias al poder del mighty Lenguaje de Expresión de Validación (mVEL), no se parece a nada que hayas visto antes. Con su enfoque de validación y más de 250 reglas integradas, no hay prácticamente nada que no puedas validar con él, de una manera muy expresiva y compacta. En pocas palabras, mighty es la validación con esteroides! De hecho, es la última biblioteca de validación que necesitará.

mighty proporciona varios enfoques diferentes para validar datos. Su caso de uso más común es validar datos entrantes a través de solicitudes HTTP, pero por supuesto no se limita a eso; mighty también proporciona atributos en forma de restricciones para validar fácilmente modelos y/o cualquier tipo de objetos.

mighty incluye una amplia variedad de reglas de validación convenientes que puede aplicar como una sola regla o combinarlas entre sí utilizando operadores para crear validaciones aún más complejas.

Inicio rápido

Para conocer las potentes funciones de validación de mighty , vayamos directo al grano y veamos algunos ejemplos:

Validación de datos generales

Validar datos del formulario 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

Validación de objetos

Validar el estado de un objeto usando los 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

Un ejemplo del resultado de validar un objeto validable se vería así: 

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

Consulte también ValidatableObject y ValidatableObjectChild .

■ Sugerencia: Puede encontrar más ejemplos en la sección Ejemplos.

mighty lenguaje de expresión de validación

mighty tiene el concepto de expresión de validación. La expresión de validación en sus formas más simples es solo una cadena que describe cuán mighty se deben validar los datos dados. Estas cadenas se basan en la mighty Especificación del lenguaje de expresión de validación (mVEL). mVEL es bastante simple, legible por humanos y fácil de manejar. Es una combinación de conceptos y/o especificaciones bien establecidos como álgebra booleana, operadores bit a bit, JSON y CSV.

Por lo tanto, la expresión de validación se puede definir como una cadena que contiene algunas reglas separadas por operadores bit a bit que construirán una expresión que, cuando se evalúe utilizando la lógica del álgebra booleana , dará como resultado el resultado final de la validación. Las reglas pueden tener argumentos, los tipos de estos argumentos se pueden indicar usando las mismas reglas de los tipos JSON . Una regla también puede tener varios argumentos y los argumentos están separados por comas ( CSV ).

Por ejemplo, required&string&between:2,255|null es una expresión de validación válida, esta expresión puede entenderse como la siguiente:

  1. La expresión tiene cuatro reglas.
  2. La expresión contiene las reglas:
    1. required Afirma que la entrada está presente.
    2. string Afirma que la entrada es una cadena.
    3. between:2,255 Afirma que la entrada es una cadena con una longitud entre 2 y 255.
    4. null Afirma que la entrada es nula.
  3. El resultado final es el resultado de evaluar la expresión resultante del resultado de cada regla pegada usando operadores bit a bit.

La expresión required&string&between:2,255|null significa que la entrada debe estar presente; Y de tipo cadena; Y entre 2 y 255 de largo; O nulo. Por lo tanto, es una cadena que acepta valores NULL y, cuando no es nula, debe tener entre 2 y 255 caracteres.

Digamos que la entrada fue " mighty is Awesome!" , el resultado de la expresión required&string&between:2,255|null contra esa entrada sería 1&1&1|0 lo que resultará en 1 que es true , si la entrada fuera null el resultado sería 0&0&0|1 = 1 , si la entrada fuera X el resultado sería 0&0&0|0 = 0 , etc...

A diferencia de otras implementaciones de validaciones, el concepto de álgebra booleana que utiliza operadores bit a bit brinda la posibilidad de crear validaciones complejas que son muy legibles y compactas manteniendo las reglas en un número mínimo, reutilizando la lógica existente de manera inversa o compuesta y, finalmente, manteniendo la base de código lo más SECO posible. Los beneficios se pueden resumir en los siguientes puntos:

  1. Una regla NO se puede editar (usando ~ ) para hacer exactamente lo contrario de lo que hace normalmente.
  2. Una regla compleja puede ser el resultado de realizar AND (usando & ), OR (usando | ) o XOR (usando ^ ), dos o más reglas simples.
  3. Las reglas se pueden agrupar y/o darles mayor prioridad mediante el uso de paréntesis, es decir, ABRIR (usando ( ) y CLOSE (usando ) ).
  4. Una expresión de validación también puede tener un comportamiento, que es un carácter que antepone la cadena de expresión de validación que afectará a todas las reglas. Los comportamientos disponibles son:
    1. NORMAL : ejecuta todas las reglas, comportamiento predeterminado (sin prefijo).
    2. OPTIMISTIC : deja de ejecutar reglas después del primer éxito (prefijo ? ).
    3. PESIMISTICO : deja de ejecutar reglas después del primer error (prefijo ! ).
  5. La legibilidad se puede mejorar asignando alias a algunas reglas o agregando conjuntos de reglas como macros y ejecutándolas usando la sintaxis [macro] .

Además, el concepto de JSON garantiza la seguridad de los tipos de datos de los argumentos, y el concepto de CSV garantiza que la lista de argumentos tenga reglas de análisis claras.

Lo mejor es que no es necesario memorizar todas las reglas ni la sintaxis del lenguaje de expresión de validación. La clase Validation es una interfaz fluida que se puede utilizar para crear una expresión de validación. Conoce todas mighty reglas disponibles y tiene soporte completo de IDE-Intellisense para que sea lo más fácil posible. Por ejemplo:

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

■ Hecho: ¡Por lo general, se necesitan más palabras para describir lo que hace una expresión de validación que la expresión de validación misma!

Ejemplos

A continuación se muestran algunos ejemplos de escenarios del mundo real:

Validar un valor único

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

Validación de datos estructurados

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

■ Sugerencia: Al proporcionar anulaciones de mensajes a Validator::class , se recomienda utilizar RuleValidation::class para establecer claves de matriz. Esta clase contiene todos mighty nombres de reglas integradas como constantes de clase.

Ampliando el validador

El validador se puede ampliar de tres formas:

  • Añadiendo una regla.
  • Añadiendo un alias.
  • Añadiendo una 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) ' ,
        ],
    ],
];

■ Sugerencia: consulte las rules , aliases y macros predeterminados del Validator para ver más ejemplos.

Restricciones

mighty consta de más de 250 reglas/atributos que se pueden utilizar para validar cualquier dato o los valores de clases, constantes de clase, propiedades y métodos.

Los atributos se dividen en tres grupos principales:

  1. Atributos de restricción genérica
  2. Atributos de restricciones especiales
  3. Atributos de restricción de regla

Grupo de atributos de restricción genérica

Los atributos de restricción genérica se encuentran en el espacio de nombres MAKS mighty Validation .

Este grupo consta actualmente de un solo atributo; ese es el atributo Constraint . Este atributo requiere una expresión de validación para validar los datos a los que se aplica. También es la clase base para todos los demás atributos.

Grupo de atributos de restricciones especiales

Los atributos de restricción especiales se encuentran en el espacio de nombres MAKS mighty ValidationConstraint .

Este grupo contiene atributos que realizan un trabajo específico que solo está disponible en el contexto de atributos. Consta de los siguientes atributos:

  • Rule : este atributo se utiliza para validar cualquier dato utilizando una única regla de validación. También es la clase base para todos los atributos del grupo de atributos de restricciones de reglas.
  • Callback : este atributo se utiliza para validar cualquier dato mediante una función de devolución de llamada.
  • Valid : este atributo se utiliza para validar la validez de un objeto validable.
  • Shape : este atributo se utiliza para validar la forma de una matriz u objeto. Tenga en cuenta que este es el único atributo que valida un conjunto de valores (datos estructurados) en lugar de un valor único.
  • Compound : este atributo se utiliza para combinar un conjunto de restricciones para crear una expresión de validación. Las restricciones se pueden combinar utilizando cualquier operador y también pueden tener un comportamiento. Sirve como una forma orientada a objetos de crear una expresión de validación.

■ Nota: Tenga en cuenta que las restricciones que se pueden usar con los atributos Shape::class y Compound::class deben ser instancias reales de Constraint::class , Rule::class o Compound::class . NO se permiten Callback::class , Valid::class o Shape::class del grupo de atributos de restricción especial . Si necesita esta función, abra un problema y discutiremos su implementación.

Grupo de atributos de restricción de reglas

Los atributos de restricción de regla se encuentran en el espacio de nombres MAKS mighty ValidationConstraintRule .

Este grupo contiene atributos que se basan en una única regla de validación. Consiste en la mayoría de los atributos que proporciona mighty . Consulte la sección Validaciones para obtener la lista completa.

Agregar una restricción personalizada

mighty tiene una lista enorme de restricciones integradas, es realmente raro que necesites algo más que lo que mighty proporciona. Sin embargo, a veces surge la necesidad de una restricción personalizada, así es como se puede lograr:

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: Las restricciones personalizadas se consideran parte del grupo de atributos de restricciones especiales (es decir, no se permite su uso con/dentro de las restricciones Shape::class y Compound::class ).

Validaciones

La siguiente tabla enumera todas las reglas disponibles, incluidos sus equivalentes de atributos y métodos:

Reglas y alias

  • Validation::class
  • Constraint::class y Constraint/Rule/*
No. Regla Descripción Atributo / Método
001 Nombre: null
Uso: null		 Afirma que la entrada es nula. Atributo:
NullConstraint::class
Método:
Validation::null()
002 Nombre: boolean
Uso: boolean		 Afirma que la entrada es booleana. Atributo:
Boolean::class
Método:
Validation::boolean()
003 Nombre: integer
Uso: integer		 Afirma que la entrada es un número entero. Atributo:
Integer::class
Método:
Validation::integer()
004 Nombre: float
Uso: float		 Afirma que la entrada es un flotante. Atributo:
FloatConstraint::class
Método:
Validation::float()
005 Nombre: numeric
Uso: numeric		 Afirma que la entrada es numérica. Atributo:
NumericConstraint::class
Método:
Validation::numeric()
006 Nombre: string
Uso: string		 Afirma que la entrada es una cadena. Atributo:
StringConstraint::class
Método:
Validation::string()
007 Nombre: scalar
Uso: scalar		 Afirma que la entrada es un escalar. Atributo:
Scalar::class
Método:
Validation::scalar()
008 Nombre: array
Uso: array		 Afirma que la entrada es una matriz. Atributo:
ArrayConstraint::class
Método:
Validation::array()
009 Nombre: object
Uso: object		 Afirma que la entrada es un objeto. Atributo:
ObjectConstraint::class
Método:
Validation::object()
010 Nombre: callable
Uso: callable		 Afirma que la entrada es invocable. Atributo:
CallableConstraint::class
Método:
Validation::callable()
011 Nombre: iterable
Uso: iterable		 Afirma que la entrada es iterable. Atributo:
IterableConstraint::class
Método:
Validation::iterable()
012 Nombre: countable
Uso: countable		 Afirma que la entrada es contable. Atributo:
Countable::class
Método:
Validation::countable()
013 Nombre: resource
Uso: resource		 Afirma que la entrada es un recurso. Atributo:
ResourceConstraint::class
Método:
Validation::resource()
014 Nombre: type
Uso: type:'["int","float"]'		 Afirma que la entrada es uno de los tipos dados. Atributo:
Type::class
Método:
Validation::type(string|array $type)
015 Nombre: type.debug
Uso: type.debug:string		 Afirma que la entrada es del tipo dado usando get_debug_type(). Atributo:
TypeDebug::class
Método:
Validation::typeDebug(string $type)
016 Nombre: alpha
Uso: alpha		 Afirma que la entrada consta únicamente de caracteres alfabéticos. Atributo:
Alpha::class
Método:
Validation::alpha()
017 Nombre: alnum
Uso: alnum		 Afirma que la entrada consta únicamente de caracteres alfanuméricos. Atributo:
Alnum::class
Método:
Validation::alnum()
018 Nombre: lower
Uso: lower		 Afirma que la entrada consta únicamente de caracteres en minúscula. Atributo:
Lower::class
Método:
Validation::lower()
019 Nombre: upper
Uso: upper		 Afirma que la entrada consta únicamente de caracteres en mayúsculas. Atributo:
Upper::class
Método:
Validation::upper()
020 Nombre: cntrl
Uso: cntrl		 Afirma que la entrada consta únicamente de caracteres de control. Atributo:
Cntrl::class
Método:
Validation::cntrl()
021 Nombre: space
Uso: space		 Afirma que la entrada consta únicamente de caracteres de espacio en blanco. Atributo:
Space::class
Método:
Validation::space()
022 Nombre: punct
Uso: punct		 Afirma que la entrada consta únicamente de caracteres de puntuación. Atributo:
Punct::class
Método:
Validation::punct()
023 Nombre: graph
Uso: graph		 Afirma que la entrada consta únicamente de caracteres gráficos (caracteres que crean una salida visible). Atributo:
Graph::class
Método:
Validation::graph()
024 Nombre: print
Uso: print		 Afirma que la entrada consta únicamente de caracteres imprimibles. Atributo:
PrintConstraint::class
Método:
Validation::print()
025 Nombre: digit
Uso: digit		 Afirma que la entrada consta únicamente de dígitos (caracteres numéricos). Atributo:
Digit::class
Método:
Validation::digit()
026 Nombre: xdigit
Uso: xdigit		 Afirma que la entrada representa dígitos hexadecimales. Atributo:
Xdigit::class
Método:
Validation::xdigit()
027 Nombre: booleanLike
Uso: booleanLike		 Afirma que la entrada es un valor que se puede analizar como booleano (VERDADERO: verdadero, "verdadero", "1", "activado", "sí"; FALSO: falso, "falso", "0", "desactivado" , "no", "", nulo). Atributo:
BooleanLike::class
Método:
Validation::booleanLike()
028 Nombre: integerLike
Uso: integerLike:0,100		 Afirma que la entrada es un valor que se puede analizar como un número entero dentro del rango especificado. Atributo:
IntegerLike::class
Método:
Validation::integerLike(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
029 Nombre: integerLike.allowOctal
Uso: integerLike.allowOctal:0,100		 Afirma que la entrada es un valor que se puede analizar como un número entero dentro del rango especificado y puede estar en notación octal. Atributo:
IntegerLikeAllowOctal::class
Método:
Validation::integerLikeAllowOctal(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
030 Nombre: integerLike.allowHex
Uso: integerLike.allowHex:0,100		 Afirma que la entrada es un valor que se puede analizar como un número entero dentro del rango especificado y puede estar en notación hexadecimal. Atributo:
IntegerLikeAllowHex::class
Método:
Validation::integerLikeAllowHex(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
031 Nombre: floatLike
Uso: floatLike:1.0,100.0		 Afirma que la entrada es un valor que se puede analizar como un valor flotante dentro del rango especificado. Atributo:
FloatLike::class
Método:
Validation::floatLike(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
032 Nombre: floatLike.allowThousands
Uso: floatLike.allowThousands:1.0,100.0		 Afirma que la entrada es un valor que se puede analizar como un valor flotante dentro del rango especificado. Atributo:
FloatLikeAllowThousands::class
Método:
Validation::floatLikeAllowThousands(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
033 Nombre: regexp
Uso: regexp:"/[az]/i"		 Afirma que la entrada coincide con una expresión regular compatible con Perl. Atributo:
Regexp::class
Método:
Validation::regexp(string $pattern)
034 Nombre: ip
Uso: ip		 Afirma que la entrada es una dirección IP. Atributo:
Ip::class
Método:
Validation::ip()
035 Nombre: ip.v4
Uso: ip.v4		 Afirma que la entrada es una dirección IPv4. Atributo:
IpV4::class
Método:
Validation::ipV4()
036 Nombre: ip.v6
Uso: ip.v6		 Afirma que la entrada es una dirección IPv6. Atributo:
IpV6::class
Método:
Validation::ipV6()
037 Nombre: ip.notReserved
Uso: ip.notReserved		 Afirma que la entrada es una dirección IP que no está dentro del rango de IP reservado. Atributo:
IpNotReserved::class
Método:
Validation::ipNotReserved()
038 Nombre: ip.notPrivate
Uso: ip.notPrivate		 Afirma que la entrada es una dirección IP que no está dentro del rango de IP privadas. Atributo:
IpNotPrivate::class
Método:
Validation::ipNotPrivate()
039 nombre: mac
Uso: mac		 Afirma que la entrada es una dirección MAC. Atributo:
Mac::class
Método:
Validation::mac()
040 Nombre: url
Uso: url		 Afirma que la entrada es una URL. Atributo:
Url::class
Método:
Validation::url()
041 Nombre: url.withPath
Uso: url.withPath		 Afirma que la entrada es una URL que contiene una ruta. Atributo:
UrlWithPath::class
Método:
Validation::urlWithPath()
042 Nombre: url.withQuery
Uso: url.withQuery		 Afirma que la entrada es una URL que contiene una consulta. Atributo:
UrlWithQuery::class
Método:
Validation::urlWithQuery()
043 Nombre: email
Uso: email		 Afirma que la entrada es una dirección de correo electrónico. Atributo:
Email::class
Método:
Validation::email()
044 Nombre: email.withUnicode
Uso: email.withUnicode		 Afirma que la entrada es una dirección de correo electrónico (se permite Unicode). Atributo:
EmailWithUnicode::class
Método:
Validation::emailWithUnicode()
045 Nombre: domain
Uso: domain		 Afirma que la entrada es un dominio. Atributo:
Domain::class
Método:
Validation::domain()
046 Nombre: domain.isActive
Uso: domain.isActive		 Afirma que la entrada es un dominio activo. Funciona con dominios y correos electrónicos. Atributo:
DomainIsActive::class
Método:
Validation::domainIsActive()
047 Nombre: file
Uso: file		 Afirma que la entrada es un archivo (puede ser un archivo, un enlace o un directorio). Atributo:
File::class
Método:
Validation::file()
048 Nombre: file.isFile
Uso: file.isFile		 Afirma que la entrada es un archivo. Atributo:
FileIsFile::class
Método:
Validation::fileIsFile()
049 Nombre: file.isLink
Uso: file.isLink		 Afirma que la entrada es un enlace. Atributo:
FileIsLink::class
Método:
Validation::fileIsLink()
050 Nombre: file.isDirectory
Uso: file.isDirectory		 Afirma que la entrada es un directorio. Atributo:
FileIsDirectory::class
Método:
Validation::fileIsDirectory()
051 Nombre: file.isExecutable
Uso: file.isExecutable		 Afirma que la entrada es un archivo y es ejecutable. Atributo:
FileIsExecutable::class
Método:
Validation::fileIsExecutable()
052 Nombre: file.isWritable
Uso: file.isWritable		 Afirma que la entrada es un archivo y se puede escribir. Atributo:
FileIsWritable::class
Método:
Validation::fileIsWritable()
053 Nombre: file.isReadable
Uso: file.isReadable		 Afirma que la entrada es un archivo y es legible. Atributo:
FileIsReadable::class
Método:
Validation::fileIsReadable()
054 Nombre: file.isUploaded
Uso: file.isUploaded		 Afirma que la entrada es un archivo que se carga a través de HTTP POST. Atributo:
FileIsUploaded::class
Método:
Validation::fileIsUploaded()
055 Nombre: file.size
Uso: file.size:1024		 Afirma que la entrada es un archivo y que el tamaño es igual al tamaño dado en bytes. Atributo:
FileSize::class
Método:
Validation::fileSize(int $sizeInBytes)
056 Nombre: file.size.lte
Uso: file.size.lte:1024		 Afirma que la entrada es un archivo y que el tamaño es menor o igual al tamaño dado en bytes. Atributo:
FileSizeLte::class
Método:
Validation::fileSizeLte(int $sizeInBytes)
057 Nombre: file.size.gte
Uso: file.size.gte:1024		 Afirma que la entrada es un archivo y que el tamaño es mayor o igual al tamaño dado en bytes. Atributo:
FileSizeGte::class
Método:
Validation::fileSizeGte(int $sizeInBytes)
058 Nombre: file.dirname
Uso: file.dirname:/path/to/dir		 Afirma que la entrada es un archivo y su nombre de directorio es igual al nombre de directorio dado. Atributo:
FileDirname::class
Método:
Validation::fileDirname(string $dirname)
059 Nombre: file.basename
Uso: file.basename:file.ext		 Afirma que la entrada es un archivo y su nombre base es igual al nombre base dado. Atributo:
FileBasename::class
Método:
Validation::fileBasename(string $basename)
060 Nombre: file.filename
Uso: file.filename:file		 Afirma que la entrada es un archivo y su nombre de archivo es igual al nombre de archivo dado. Atributo:
FileFilename::class
Método:
Validation::fileFilename(string $filename)
061 Nombre: file.extension
Uso: file.extension:ext		 Afirma que la entrada es un archivo y su extensión es igual a la extensión dada. Atributo:
FileExtension::class
Método:
Validation::fileExtension(string $extension)
062 Nombre: file.mime
Uso: file.mime:text/plain		 Afirma que la entrada es un archivo y su tipo MIME es uno de los tipos MIME dados. Atributo:
FileMime::class
Método:
Validation::fileMime(string|array $mine)
063 Nombre: image
Uso: image		 Afirma que la entrada es un archivo de imagen (jpg, jpeg, png, gif, bmp, svg o webp). Atributo:
Image::class
Método:
Validation::image()
064 Nombre: image.width
Uso: image.width:1920		 Afirma que la entrada es una imagen y su ancho es igual al ancho dado en píxeles. Atributo:
ImageWidth::class
Método:
Validation::imageWidth(int $width)
065 Nombre: image.width.lte
Uso: image.width.lte:1920		 Afirma que la entrada es una imagen y su ancho es menor o igual al ancho dado en píxeles. Atributo:
ImageWidthLte::class
Método:
Validation::imageWidthLte(int $width)
066 Nombre: image.width.gte
Uso: image.width.gte:1920		 Afirma que la entrada es una imagen y su ancho es mayor o igual al ancho dado en píxeles. Atributo:
ImageWidthGte::class
Método:
Validation::imageWidthGte(int $width)
067 Nombre: image.height
Uso: image.height:1080		 Afirma que la entrada es una imagen y su altura es igual a la altura dada en píxeles. Atributo:
ImageHeight::class
Método:
Validation::imageHeight(int $height)
068 Nombre: image.height.lte
Uso: image.height.lte:1080		 Afirma que la entrada es una imagen y su altura es menor o igual a la altura dada en píxeles. Atributo:
ImageHeightLte::class
Método:
Validation::imageHeightLte(int $height)
069 Nombre: image.height.gte
Uso: image.height.gte:1080		 Afirma que la entrada es una imagen y su altura es mayor o igual a la altura dada en píxeles. Atributo:
ImageHeightGte::class
Método:
Validation::imageHeightGte(int $height)
070 Nombre: image.dimensions
Uso: image.dimensions:1920,1080,==		 Afirma que la entrada es una imagen y sus dimensiones son menores, iguales o mayores que el ancho y alto dados en píxeles. Atributo:
ImageDimensions::class
Método:
Validation::imageDimensions(int $width, int $height, string $operator = '==')
071 Nombre: image.ratio
Uso: image.ratio:16:9		 Afirma que la entrada es una imagen y su relación de aspecto es igual a la relación dada (la relación debe especificarse como una fracción como "16/9"). Atributo:
ImageRatio::class
Método:
Validation::imageRatio(string $ratio)
072 Nombre: if
Uso: if:7,7,==		 Comprueba la condición entre el primer argumento y el segundo argumento; el operador de condición también se puede especificar como tercer argumento. Atributo:
IfConstraint::class
Método:
Validation::if(mixed $actual, mixed $expected = true, string $operator = '==')
073 Nombre: if.eq
Uso: if.eq:3,3		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es "==". Atributo:
IfEq::class
Método:
Validation::ifEq(mixed $actual, mixed $expected)
074 Nombre: if.neq
Uso: if.neq:1,2		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es "!=". Atributo:
IfNeq::class
Método:
Validation::ifNeq(mixed $actual, mixed $expected)
075 Nombre: if.id
Uso: if.id:3,3		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es "===". Atributo:
IfId::class
Método:
Validation::ifId(mixed $actual, mixed $expected)
076 Nombre: if.nid
Uso: if.nid:1,2		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es "!==". Atributo:
IfNid::class
Método:
Validation::ifNid(mixed $actual, mixed $expected)
077 Nombre: if.gt
Uso: if.gt:2,1		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es ">". Atributo:
IfGt::class
Método:
Validation::ifGt(mixed $actual, mixed $expected)
078 Nombre: if.gte
Uso: if.gte:2,2		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es ">=". Atributo:
IfGte::class
Método:
Validation::ifGte(mixed $actual, mixed $expected)
079 Nombre: if.lt
Uso: if.lt:1,2		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es "<". Atributo:
IfLt::class
Método:
Validation::ifLt(mixed $actual, mixed $expected)
080 Nombre: if.lte
Uso: if.lte:1,2		 Comprueba la condición entre el primer argumento y el segundo argumento, el operador de condición es "<=". Atributo:
IfLte::class
Método:
Validation::ifLte(mixed $actual, mixed $expected)
081 Nombre: empty
Uso: empty		 Afirma que la entrada está vacía utilizando la construcción de lenguaje vacía() (está en blanco, es decir, una cadena vacía, una matriz vacía, falso, nulo o 0). Atributo:
EmptyConstraint::class
Método:
Validation::empty()
082 Nombre: required
Uso: required		 Afirma que la entrada es obligatoria (no está en blanco, es decir, no es una cadena vacía o nula). Atributo:
Required::class
Método:
Validation::required()
083 Nombre: allowed
Uso: allowed		 Afirma que la entrada está permitida (puede estar vacía o tener cualquier valor, las cadenas nulas y vacías se consideran valores válidos). Atributo:
Allowed::class
Método:
Validation::allowed()
084 Nombre: forbidden
Uso: forbidden		 Afirma que la entrada está prohibida (es nula o no está presente). Atributo:
Forbidden::class
Método:
Validation::forbidden()
085 Nombre: accepted
Uso: accepted		 Afirma que la entrada es aceptada (es igual a: "on", "yes", "yeah", "yep", "yo", "ok", "okay", "aye", 1 o "1", true o " true") tenga en cuenta que las cadenas se tratan sin distinguir entre mayúsculas y minúsculas. Atributo:
Accepted::class
Método:
Validation::accepted()
086 Nombre: declined
Uso: declined		 Afirma que la entrada se rechaza (es igual a: "off", "no", "not", "nope", "neh", "nay", 0 o "0", false o "false") tenga en cuenta que las cadenas se tratan sin distinguir entre mayúsculas y minúsculas. Atributo:
Declined::class
Método:
Validation::declined()
087 Nombre: bit
Uso: bit		 Afirma que la entrada es bit (es igual a: 1 o "1", verdadero; 0 o "0", falso). Atributo:
Bit::class
Método:
Validation::bit()
088 Nombre: bit.isOn
Uso: bit.isOn		 Afirma que la entrada es un bit activado (es igual a: verdadero, 1 o "1"). Atributo:
BitIsOn::class
Método:
Validation::bitIsOn()
089 Nombre: bit.isOff
Uso: bit.isOff		 Afirma que la entrada es un bit desactivado (es igual a: falso, 0 o "0"). Atributo:
BitIsOff::class
Método:
Validation::bitIsOff()
090 Nombre: equals
Uso: equals:value		 Afirma que la entrada es igual al valor dado. Funciona con tipos escalares y nulos. El operador de comparación es "==". Atributo:
Equals::class
Método:
Validation::equals(string|int|float|bool|null $value)
091 Nombre: matches
Uso: matches:'"/^[a-zA-Z0-9]+$/"'		 Afirma que la entrada coincide con el patrón dado. Funciona sólo con cuerdas. Atributo:
Matches::class
Método:
Validation::matches(string $pattern)
092 Nombre: in
Uso: in:val1,val2,...		 Afirma que la entrada está en los valores dados. Funciona con tipos escalares y nulos. Atributo:
In::class
Método:
Validation::in(string|int|float|bool|null ...$values)
093 Nombre: count
Uso: count:3		 Afirma que el recuento de entrada es igual al valor dado. Funciona con todos los tipos de datos (nulo: 0; booleano: 0 o 1; flotante/entero: valor numérico; cadena: recuento de caracteres; matriz/contable: recuento de elementos; objeto: recuento de propiedades accesibles). Atributo:
Count::class
Método:
Validation::count(int $count)
094 Nombre: min
Uso: min:3		 Afirma que el recuento de entrada es mayor o igual que el valor dado. Funciona con todos los tipos de datos (nulo: 0; booleano: 0 o 1; flotante/entero: valor numérico; cadena: recuento de caracteres; matriz/contable: recuento de elementos; objeto: recuento de propiedades accesibles). Atributo:
Min::class
Método:
Validation::min(int|float $count)
095 Nombre: max
Uso: max:3		 Afirma que el recuento de entrada es menor o igual que el valor dado. Funciona con todos los tipos de datos (nulo: 0; booleano: 0 o 1; flotante/entero: valor numérico; cadena: recuento de caracteres; matriz/contable: recuento de elementos; objeto: recuento de propiedades accesibles). Atributo:
Max::class
Método:
Validation::max(int|float $count)
096 Nombre: between
Uso: between:3,7		 Afirma que el recuento de entrada está entre los valores dados. Funciona con todos los tipos de datos (nulo: 0; booleano: 0 o 1; flotante/entero: valor numérico; cadena: recuento de caracteres; matriz/contable: recuento de elementos; objeto: recuento de propiedades accesibles). Atributo:
Between::class
Método:
Validation::between(int|float $min, int|float $max)
097 Nombre: number.isPositive
Uso: number.isPositive		 Afirma que la entrada es un número positivo. Atributo:
NumberIsPositive::class
Método:
Validation::numberIsPositive()
098 Nombre: number.isNegative
Uso: number.isNegative		 Afirma que la entrada es un número negativo. Atributo:
NumberIsNegative::class
Método:
Validation::numberIsNegative()
099 Nombre: number.isEven
Uso: number.isEven		 Afirma que la entrada es un número par. Atributo:
NumberIsEven::class
Método:
Validation::numberIsEven()
100 Nombre: number.isOdd
Uso: number.isOdd		 Afirma que la entrada es un número impar. Atributo:
NumberIsOdd::class
Método:
Validation::numberIsOdd()
101 Nombre: number.isMultipleOf
Uso: number.isMultipleOf:3		 Afirma que la entrada es un múltiplo del número dado. Atributo:
NumberIsMultipleOf::class
Método:
Validation::numberIsMultipleOf(float $number)
102 Nombre: number.isFinite
Uso: number.isFinite		 Afirma que la entrada es un número finito. Atributo:
NumberIsFinite::class
Método:
Validation::numberIsFinite()
103 Nombre: number.isInfinite
Uso: number.isInfinite		 Afirma que la entrada es un número infinito. Atributo:
NumberIsInfinite::class
Método:
Validation::numberIsInfinite()
104 Nombre: number.isNan
Uso: number.isNan		 Afirma que la entrada no es un número. Atributo:
NumberIsNan::class
Método:
Validation::numberIsNan()
105 Nombre: string.charset
Uso: string.charset:UTF-8		 Afirma que la entrada está codificada en uno de los conjuntos de caracteres dados (alias incluidos). La verificación se realiza distinguiendo entre mayúsculas y minúsculas. Atributo:
StringCharset::class
Método:
Validation::stringCharset(string|array $charset)
106 Nombre: string.contains
Uso: string.contains:substring		 Afirma que la entrada contiene la subcadena dada. Se puede especificar un segundo argumento booleano para habilitar el modo estricto (distingue entre mayúsculas y minúsculas). Atributo:
StringContains::class
Método:
Validation::stringContains(string $substring, bool $strict = false)
107 Nombre: string.startsWith
Uso: string.startsWith:substring,1		 Afirma que la entrada comienza con la subcadena dada. Se puede especificar un segundo argumento booleano para habilitar el modo estricto (distingue entre mayúsculas y minúsculas). Atributo:
StringStartsWith::class
Método:
Validation::stringStartsWith(string $substring, bool $strict = false)
108 Nombre: string.endsWith
Uso: string.endsWith:substring,0		 Afirma que la entrada termina con la subcadena dada. Se puede especificar un segundo argumento booleano para habilitar el modo estricto (distingue entre mayúsculas y minúsculas). Atributo:
StringEndsWith::class
Método:
Validation::stringEndsWith(string $substring, bool $strict = false)
109 Nombre: string.length
Uso: string.length:3		 Afirma que la entrada es una cadena que tiene exactamente la longitud dada. Atributo:
StringLength::class
Método:
Validation::stringLength(int $length)
110 Nombre: string.wordsCount
Uso: string.wordsCount:3		 Afirma que la entrada es una cadena que contiene exactamente el recuento de palabras dado. Atributo:
StringWordsCount::class
Método:
Validation::stringWordsCount(int $count)
111 Nombre: array.hasKey
Uso: array.hasKey:key		 Afirma que la matriz de entrada tiene la clave dada. Atributo:
ArrayHasKey::class
Método:
Validation::arrayHasKey(string|int $key)
112 Nombre: array.hasValue
Uso: array.hasValue:value		 Afirma que la matriz de entrada contiene el valor dado. Funciona con tipos escalares. Atributo:
ArrayHasValue::class
Método:
Validation::arrayHasValue(mixed $value)
113 Nombre: array.hasDistinct
Uso: array.hasDistinct:key		 Afirma que la entrada es una matriz multidimensional que contiene valores distintos de la clave dada. Atributo:
ArrayHasDistinct::class
Método:
Validation::arrayHasDistinct(string|int $key)
114 Nombre: array.isAssociative
Uso: array.isAssociative		 Afirma que la entrada es una matriz asociativa. Atributo:
ArrayIsAssociative::class
Método:
Validation::arrayIsAssociative()
115 Nombre: array.isSequential
Uso: array.isSequential		 Afirma que la entrada es una matriz secuencial. Atributo:
ArrayIsSequential::class
Método:
Validation::arrayIsSequential()
116 Nombre: array.isUnique
Uso: array.isUnique		 Afirma que la matriz de entrada contiene valores únicos. Funciona sólo con matrices unidimensionales. Atributo:
ArrayIsUnique::class
Método:
Validation::arrayIsUnique()
117 Nombre: array.subset
Uso: array.subset:'{"a":1,"b":2}'		 Afirma que la entrada es una matriz que contiene el subconjunto dado. Tenga en cuenta que esta verificación se aplica solo a la primera dimensión de la matriz. Atributo:
ArraySubset::class
Método:
Validation::arraySubset(array $subset)
118 Nombre: object.hasProperty
Uso: object.hasProperty:property		 Afirma que la entrada tiene la propiedad dada. Atributo:
ObjectHasProperty::class
Método:
Validation::objectHasProperty(string $property)
119 Nombre: object.hasMethod
Uso: object.hasMethod:method		 Afirma que la entrada tiene el método dado. Atributo:
ObjectHasMethod::class
Método:
Validation::objectHasMethod(string $method)
120 Nombre: object.isStringable
Uso: object.isStringable		 Afirma que la entrada implementa el método __toString(). Atributo:
ObjectIsStringable::class
Método:
Validation::objectIsStringable()
121 Nombre: object.isInstanceOf
Uso: object.isInstanceOf:NamespaceClass		 Afirma que la entrada es una instancia de la clase dada. Atributo:
ObjectIsInstanceOf::class
Método:
Validation::objectIsInstanceOf(string $classFQN)
122 Nombre: object.isSubclassOf
Uso: object.isSubclassOf:NamespaceClass		 Afirma que la entrada es una subclase de la clase dada. Atributo:
ObjectIsSubclassOf::class
Método:
Validation::objectIsSubclassOf(string $classFQN)
123 Nombre: serialized
Uso: serialized		 Afirma que la entrada es un dato serializado PHP válido. Atributo:
Serialized::class
Método:
Validation::serialized()
124 Nombre: json
Uso: json		 Afirma que la entrada es un JSON válido. Atributo:
Json::class
Método:
Validation::json()
125 Nombre: base64
Uso: base64		 Afirma que la entrada es una cadena codificada en Base64 válida. Atributo:
Base64::class
Método:
Validation::base64()
126 Nombre: xml
Uso: xml		 Afirma que la entrada es un XML válido. Atributo:
Xml::class
Método:
Validation::xml()
127 Nombre: locale
Uso: locale		 Afirma que la entrada es un identificador local válido (predeterminado: [ISO 639-1] o [ISO 639-1]_[ISO 3166-1 alpha-2], no distingue entre mayúsculas y minúsculas, la entrada se canonicaliza antes de verificar (guiones para subrayar, sin puntos ni juego de caracteres); estricto: [ISO 639-1] o [ISO 639-1]_[ISO 3166-1 alfa-2], distingue entre mayúsculas y minúsculas sin canonicalización. Atributo:
Locale::class
Método:
Validation::locale(bool $strict = false)
128 Nombre: language
Uso: language		 Afirma que la entrada es un código de idioma válido (predeterminado: "ISO 639-1"; largo: "ISO 639-2/T"). Atributo:
Language::class
Método:
Validation::language(bool $long = false)
129 Nombre: country
Uso: country		 Afirma que la entrada es un código de país válido (predeterminado: "ISO 3166-1 alfa-2"; largo: "ISO 3166-1 alfa-3"). Atributo:
Country::class
Método:
Validation::country(bool $long = false)
130 Nombre: timezone
Uso: timezone		 Afirma que la entrada es un identificador de zona horaria válido (predeterminado: no distingue entre mayúsculas y minúsculas; estricto: distingue entre mayúsculas y minúsculas). Atributo:
Timezone::class
Método:
Validation::timezone(bool $strict = false)
131 Nombre: datetime
Uso: datetime		 Afirma que la entrada es una cadena/objeto de fecha y hora válido. Atributo:
Datetime::class
Método:
Validation::datetime()
132 Nombre: datetime.eq
Uso: datetime.eq:"2015-01-01"		 Afirma que la entrada es igual a la cadena de fecha y hora dada. Atributo:
DatetimeEq::class
Método:
Validation::datetimeEq(string $datetime)
133 Nombre: datetime.lt
Uso: datetime.lt:tomorrow		 Afirma que la entrada es una cadena/objeto de fecha y hora menor que (antes) de la cadena de fecha y hora dada. Atributo:
DatetimeLt::class
Método:
Validation::datetimeLt(string $datetime)
134 Nombre: datetime.lte
Uso: datetime.lte:tomorrow		 Afirma que la entrada es una cadena/objeto de fecha y hora menor que (antes) o igual a la cadena de fecha y hora dada. Atributo:
DatetimeLte::class
Método:
Validation::datetimeLte(string $datetime)
135 Nombre: datetime.gt
Uso: datetime.gt:today		 Afirma que la entrada es una cadena/objeto de fecha y hora mayor que (después) de la cadena de fecha y hora dada. Atributo:
DatetimeGt::class
Método:
Validation::datetimeGt(string $datetime)
136 Nombre: datetime.gte
Uso: datetime.gte:today		 Afirma que la entrada es una cadena/objeto de fecha y hora mayor que (después) o igual a la cadena de fecha y hora dada. Atributo:
DatetimeGte::class
Método:
Validation::datetimeGte(string $datetime)
137 Nombre: datetime.birthday
Uso: datetime.birthday		 Afirma que la entrada es una cadena/objeto de fecha y hora que cumple años hoy. La entrada debe estar preferiblemente en formato "AAAA-MM-DD". Atributo:
DatetimeBirthday::class
Método:
Validation::datetimeBirthday()
138 Nombre: datetime.format
Uso: datetime.format:"Ymd H:i:s"		 Afirma que la entrada es una fecha/hora válida con el formato dado. Atributo:
DatetimeFormat::class
Método:
Validation::datetimeFormat(string $format)
139 Nombre: datetime.format.global
Uso: datetime.format.global		 Afirma que la entrada parece una cadena de fecha y hora global válida según lo definido en la especificación HTML5. Atributo:
DatetimeFormatGlobal::class
Método:
Validation::datetimeFormatGlobal()
140 Nombre: datetime.format.local
Uso: datetime.format.local		 Afirma que la entrada parece una cadena de fecha y hora local válida según lo definido en la especificación HTML5. Atributo:
DatetimeFormatLocal::class
Método:
Validation::datetimeFormatLocal()
141 Nombre: datestamp
Uso: datestamp		 Afirma que la entrada parece una marca de fecha humana, en formato DMY o MDY, separada por punto, guión o barra. Atributo:
Datestamp::class
Método:
Validation::datestamp()
142 Nombre: datestamp.ymd
Uso: datestamp.ymd		 Afirma que la entrada parece una marca de fecha humana con formato YMD, separada por punto, guión o barra. Atributo:
DatestampYmd::class
Método:
Validation::datestampYmd()
143 Nombre: datestamp.dmy
Uso: datestamp.dmy		 Afirma que la entrada parece una marca de fecha humana con formato DMY, separada por punto, guión o barra. Atributo:
DatestampDmy::class
Método:
Validation::datestampDmy()
144 Nombre: datestamp.mdy
Uso: datestamp.mdy		 Afirma que la entrada parece una marca de fecha humana con formato MDY, separada por un punto, un guión o una barra. Atributo:
DatestampMdy::class
Método:
Validation::datestampMdy()
145 Nombre: timestamp
Uso: timestamp		 Afirma que la entrada parece una marca de tiempo humana, en formato de 24 o 12 horas con o sin segundos. Atributo:
Timestamp::class
Método:
Validation::timestamp()
146 Nombre: timestamp.12
Uso: timestamp.12		 Afirma que la entrada parece una marca de tiempo humana, formato de 12 horas con o sin segundos y AM/PM opcional. Atributo:
Timestamp12::class
Método:
Validation::timestamp12()
147 Nombre: timestamp.hms
Uso: timestamp.hms		 Afirma que la entrada parece una marca de tiempo humana, en formato de 24 o 12 horas con segundos. Atributo:
TimestampHms::class
Método:
Validation::timestampHms()
148 Nombre: timestamp.hm
Uso: timestamp.hm		 Afirma que la entrada parece una marca de tiempo humana, en formato de 24 o 12 horas sin segundos. Atributo:
TimestampHm::class
Método:
Validation::timestampHm()
149 Nombre: timestamp.ms
Uso: timestamp.ms		 Afirma que la entrada parece una marca de tiempo humana, que contiene solo minutos y segundos. Atributo:
TimestampMs::class
Método:
Validation::timestampMs()
150 Nombre: calender.day
Uso: calender.day		 Afirma que la entrada parece un día calendario en plano o en formato largo ("lunes" o "lunes"). Atributo:
CalenderDay::class
Método:
Validation::calenderDay()
151 Nombre: calender.month
Uso: calender.month		 Afirma que la entrada parece un mes calendario en formato plano o largo ("enero" o "enero"). Atributo:
CalenderMonth::class
Método:
Validation::calenderMonth()
152 Nombre: username
Uso: username		 Afirma que la entrada es un nombre de usuario válido (entre 4 y 32 caracteres, consta de letras en cualquier caso, opcionalmente números, opcionalmente uno de los siguientes caracteres "-_." (no consecutivos) y siempre debe comenzar con una letra y terminar con una letra o un número). Atributo:
Username::class
Método:
Validation::username()
153 Nombre: password
Uso: password		 Afirma que la entrada es una contraseña válida (mínimo 8 caracteres, consta de al menos una letra minúscula y una mayúscula, al menos un número, al menos un carácter especial y, opcionalmente, un espacio). Atributo:
Password::class
Método:
Validation::password()
154 Nombre: uuid
Uso: uuid		 Afirma que la entrada es un UUID válido. La versión (v1/v2/v3/v4/v5) se puede especificar para limitar el patrón. Atributo:
Uuid::class
Método:
Validation::uuid(string|int|null $version = null)
155 Nombre: ascii
Uso: ascii		 Afirma que la entrada es una cadena que contiene solo caracteres ASCII (cadena compatible con ASCII). Atributo:
Ascii::class
Método:
Validation::ascii()
156 Nombre: slug
Uso: slug		 Afirma que la entrada es un slug válido. Atributo:
Slug::class
Método:
Validation::slug()
157 Nombre: meta
Uso: meta		 Afirma que la entrada es una cadena que contiene sólo metacaracteres (caracteres especiales) (es decir, "@, #, $, ..."). Atributo:
Meta::class
Método:
Validation::meta()
158 Nombre: text
Uso: text		 Afirma que la entrada es una cadena que contiene letras y puntuación de cualquier idioma. Atributo:
Text::class
Método:
Validation::text()
159 Nombre: words
Uso: words		 Afirma que la entrada es una cadena que contiene solo palabras y espacios sin ningún otro carácter. Atributo:
Words::class
Método:
Validation::words()
160 Nombre: spaceless
Uso: spaceless		 Afirma que la entrada es una cadena que no contiene espacios en blanco. Atributo:
Spaceless::class
Método:
Validation::spaceless()
161 Nombre: emoji
Uso: emoji		 Afirma que la entrada contiene un emoji. Atributo:
Emoji::class
Método:
Validation::emoji()
162 Nombre: roman
Uso: roman		 Afirma que la entrada es un número romano válido. Atributo:
Roman::class
Método:
Validation::roman()
163 Nombre: phone
Uso: phone		 Afirma que la entrada es un número de teléfono válido (admite: América del Norte, Europa y la mayoría de los países de Asia y Medio Oriente). Atributo:
Phone::class
Método:
Validation::phone()
164 Nombre: geolocation
Uso: geolocation		 Afirma que la entrada es una geolocalización válida (combinación de coordenadas de latitud y longitud). Atributo:
Geolocation::class
Método:
Validation::geolocation()
165 Nombre: version
Uso: version		 Afirma que la entrada es un número de versión semántica válido. Atributo:
Version::class
Método:
Validation::version()
166 Nombre: amount
Uso: amount		 Afirma que la entrada contiene solo números, un punto decimal opcional (coma o punto) y un signo menos opcional (usado para cantidades de dinero, por ejemplo). Atributo:
Amount::class
Método:
Validation::amount()
167 Nombre: amount.dollar
Uso: amount.dollar		 Afirma que la entrada es una cantidad de USD con formato válido, donde el punto decimal y el separador de miles son opcionales. Atributo:
AmountDollar::class
Método:
Validation::amountDollar()
168 Nombre: amount.euro
Uso: amount.euro		 Afirma que la entrada es una cantidad de EUR con formato válido, donde el punto decimal y el separador de miles son opcionales. Atributo:
AmountEuro::class
Método:
Validation::amountEuro()
169 Nombre: color
Uso: color		 Afirma que la entrada es un color CSS válido (palabra clave "suelta", HEX, HEX-Alpha, RGB, RGBA, RGB "nueva sintaxis", HSL, HSLA, HSL "nueva sintaxis"). Atributo:
Color::class
Método:
Validation::color()
170 Nombre: color.hex
Uso: color.hex		 Afirma que la entrada es un color CSS HEX válido. Atributo:
ColorHex::class
Método:
Validation::colorHex()
171 Nombre: color.hexShort
Uso: color.hexShort		 Afirma que la entrada es un color CSS 3-Char-HEX válido. Atributo:
ColorHexShort::class
Método:
Validation::colorHexShort()
172 Nombre: color.hexLong
Uso: color.hexLong		 Afirma que la entrada es un color CSS 6-Char-HEX válido. Atributo:
ColorHexLong::class
Método:
Validation::colorHexLong()
173 Nombre: color.hexAlpha
Uso: color.hexAlpha		 Afirma que la entrada es un color CSS HEX-Alfa (4 u 8 caracteres) válido. Atributo:
ColorHexAlpha::class
Método:
Validation::colorHexAlpha()
174 Nombre: color.rgb
Uso: color.rgb		 Afirma que la entrada es un color CSS RGB válido. Atributo:
ColorRgb::class
Método:
Validation::colorRgb()
175 Nombre: color.rgba
Uso: color.rgba		 Afirma que la entrada es un color CSS RGBA válido. Atributo:
ColorRgba::class
Método:
Validation::colorRgba()
176 Nombre: color.rgb.new
Uso: color.rgb.new		 Afirma que la entrada es un color CSS4 RGB válido. Atributo:
ColorRgbNew::class
Método:
Validation::colorRgbNew()
177 Nombre: color.hsl
Uso: color.hsl		 Afirma que la entrada es un color CSS HSL válido. Atributo:
ColorHsl::class
Método:
Validation::colorHsl()
178 Nombre: color.hsla
Uso: color.hsla		 Afirma que la entrada es un color CSS HSLA válido. Atributo:
ColorHsla::class
Método:
Validation::colorHsla()
179 Nombre: color.hsl.new
Uso: color.hsl.new		 Afirma que la entrada es un color CSS4 HSL válido. Atributo:
ColorHslNew::class
Método:
Validation::colorHslNew()
180 Nombre: color.keyword
Uso: color.keyword		 Afirma que la entrada es un color de palabra clave CSS válido (estricto, como en la especificación CSS). Atributo:
ColorKeyword::class
Método:
Validation::colorKeyword()
181 Nombre: ssn
Uso: ssn		 Afirma que la entrada es un SSN válido (número de seguro social de los Estados Unidos). Atributo:
Ssn::class
Método:
Validation::ssn()
182 Nombre: sin
Uso: sin		 Afirma que la entrada es un pecado válido (número de seguro social de CA). Atributo:
Sin::class
Método:
Validation::sin()
183 Nombre: nino
Uso: nino		 Afirma que la entrada es un nino válido (número de seguro nacional del Reino Unido). Atributo:
Nino::class
Método:
Validation::nino()
184 Nombre: vin
Uso: vin		 Afirma que la entrada es un VIN válido (número de identificación del vehículo). Atributo:
Vin::class
Método:
Validation::vin()
185 Nombre: issn
Uso: issn		 Afirma que la entrada es una ISSN válida (número de serie estándar internacional). Atributo:
Issn::class
Método:
Validation::issn()
186 Nombre: isin
Uso: isin		 Afirma que la entrada es un ISIN válido (número de identificación de valores internacionales). Atributo:
Isin::class
Método:
Validation::isin()
187 Nombre: isbn
Uso: isbn		 Afirma que la entrada es un ISBN válido (número de libro estándar internacional). Se puede especificar el tipo (10/13) para reducir el patrón. Atributo:
Isbn::class
Método:
Validation::isbn(string|int|null $type = null)
188 Nombre: imei
Uso: imei		 Afirma que la entrada es un IMEI válido (número de identidad de equipos de estación móvil internacional). Atributo:
Imei::class
Método:
Validation::imei()
189 Nombre: imei.sv
Uso: imei.sv		 Afirma que la entrada es un IMEI-SV válido (número de versión internacional de identidad de equipos de estación móvil y software). Atributo:
ImeiSv::class
Método:
Validation::imeiSv()
190 Nombre: meid
Uso: meid		 Afirma que la entrada es un meid válido (identificador de equipos móviles). Atributo:
Meid::class
Método:
Validation::meid()
191 Nombre: esn
Uso: esn		 Afirma que la entrada es un ESN válido (número de serie electrónico). Atributo:
Esn::class
Método:
Validation::esn()
192 Nombre: currency
Uso: currency		 Afirma que la entrada es un código de divisas válido (predeterminado: "ISO 4217 alfa"; numérico: "ISO 4217 numérico"). Atributo:
Currency::class
Método:
Validation::currency(bool $numeric = false)
193 Nombre: currency.name
Uso: currency.name		 Afirma que la entrada es un nombre de moneda válido (como en ISO 4217). Atributo:
CurrencyName::class
Método:
Validation::currencyName()
194 Nombre: creditcard
Uso: creditcard		 Afirma que la entrada es un número de tarjeta de crédito válido, se permiten espacios equilibrados y/o guiones. Atributo:
Creditcard::class
Método:
Validation::creditcard()
195 Nombre: creditcard.visa
Uso: creditcard.visa		 Afirma que la entrada es un número de tarjeta de crédito Visa válido, se permiten espacios y/o guiones equilibrados. Atributo:
CreditcardVisa::class
Método:
Validation::creditcardVisa()
196 Nombre: creditcard.mastercard
Uso: creditcard.mastercard		 Afirma que la entrada es un número de tarjeta de crédito MasterCard válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardMastercard::class
Método:
Validation::creditcardMastercard()
197 Nombre: creditcard.discover
Uso: creditcard.discover		 Afirma que la entrada es un número de tarjeta de crédito Discover válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardDiscover::class
Método:
Validation::creditcardDiscover()
198 Nombre: creditcard.americanExpress
Uso: creditcard.americanExpress		 Afirma que la entrada es un número de tarjeta de crédito American Express válido, se permiten espacios y/o guiones equilibrados. Atributo:
CreditcardAmericanExpress::class
Método:
Validation::creditcardAmericanExpress()
199 Nombre: creditcard.dinersClub
Uso: creditcard.dinersClub		 Afirma que la entrada es un número de tarjeta de crédito de Diners Club válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardDinersClub::class
Método:
Validation::creditcardDinersClub()
200 Nombre: creditcard.jcb
Uso: creditcard.jcb		 Afirma que la entrada es un número de tarjeta de crédito JCB válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardJcb::class
Método:
Validation::creditcardJcb()
201 Nombre: creditcard.maestro
Uso: creditcard.maestro		 Afirma que la entrada es un número de tarjeta de crédito de Maestro válido, se permiten espacios y/o guiones equilibrados. Atributo:
CreditcardMaestro::class
Método:
Validation::creditcardMaestro()
202 Nombre: creditcard.chinaUnionPay
Uso: creditcard.chinaUnionPay		 Afirma que la entrada es un número de tarjeta de crédito válido de China UnionPay, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardChinaUnionPay::class
Método:
Validation::creditcardChinaUnionPay()
203 Nombre: creditcard.instaPayment
Uso: creditcard.instaPayment		 Afirma que la entrada es un número de tarjeta de crédito de Instapayment válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardInstaPayment::class
Método:
Validation::creditcardInstaPayment()
204 Nombre: creditcard.laser
Uso: creditcard.laser		 Afirma que la entrada es un número de tarjeta de crédito láser válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardLaser::class
Método:
Validation::creditcardLaser()
205 Nombre: creditcard.uatp
Uso: creditcard.uatp		 Afirma que la entrada es un número de tarjeta de crédito UATP válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardUatp::class
Método:
Validation::creditcardUatp()
206 Nombre: creditcard.mir
Uso: creditcard.mir		 Afirma que la entrada es un número de tarjeta del sistema de pago MIR válido, se permiten espacios equilibrados y/o guiones. Atributo:
CreditcardMir::class
Método:
Validation::creditcardMir()
207 Nombre: cvv
Uso: cvv		 Afirma que la entrada es un CVV válido (código de seguridad de la tarjeta). Atributo:
Cvv::class
Método:
Validation::cvv()
208 Nombre: bic
Uso: bic		 Afirma que la entrada es un BIC válido (código de identificador bancario). Atributo:
Bic::class
Método:
Validation::bic()
209 Nombre: iban
Uso: iban:IQ		 Afirma que la entrada es un IBAN válido (número de cuenta bancaria internacional). Se puede especificar el código de país "ISO 3166-1 alfa-2" para reducir el patrón. Atributo:
Iban::class
Método:
Validation::iban(?string $country = null)
210 Nombre: luhn
Uso: luhn		 Afirma que la entrada pasa la verificación del algoritmo Luhn. Esta regla se usa principalmente junto con otras reglas como números de tarjetas de crédito e identificadores para verificar aún más la validez del sujeto. Atributo:
Luhn::class
Método:
Validation::luhn()
211 Nombre: php.keyword
Uso: php.keyword		 Afirma que la entrada es una palabra clave de lenguaje PHP. Atributo:
PhpKeyword::class
Método:
Validation::phpKeyword()
212 Nombre: php.reserved
Uso: php.reserved		 Afirma que la entrada es una palabra reservada de lenguaje PHP. Atributo:
PhpReserved::class
Método:
Validation::phpReserved()
213 Nombre: php.reserved.extra
Uso: php.reserved.extra		 Afirma que la entrada es una palabra reservada de lenguaje PHP que incluye palabras reservadas suaves. Atributo:
PhpReservedExtra::class
Método:
Validation::phpReservedExtra()
214 Nombre: regex
Uso: regex		 Afirma que la entrada es una expresión regular válida. Atributo:
Regex::class
Método:
Validation::regex()
215 Nombre: bool
Uso: ver boolean		 Alias, consulte boolean para la descripción completa. Atributo:
BoolConstraint::class
Método:
Validation::bool()
216 Nombre: int
Uso: ver integer		 Alias, consulte el integer para la descripción completa. Atributo:
IntConstraint::class
Método:
Validation::int()
217 Nombre: long
Uso: ver integer		 Alias, consulte el integer para la descripción completa. Atributo:
Long::class
Método:
Validation::long()
218 Nombre: double
Uso: ver float		 Alias, consulte float para la descripción completa. Atributo:
Double::class
Método:
Validation::double()
219 Nombre: real
Uso: ver float		 Alias, consulte float para la descripción completa. Atributo:
Real::class
Método:
Validation::real()
220 Nombre: str
Uso: ver string		 Alias, consulte la string para la descripción completa. Atributo:
Str::class
Método:
Validation::str()
221 Nombre: arr
Uso: ver array		 Alias, consulte la array para la descripción completa. Atributo:
Arr::class
Método:
Validation::arr()
222 Nombre: obj
Uso: ver object		 Alias, consulte el object para la descripción completa. Atributo:
Obj::class
Método:
Validation::obj()
223 Nombre: stream
Uso: ver resource		 Alias, consulte el resource para la descripción completa. Atributo:
Stream::class
Método:
Validation::stream()
224 Nombre: assert
Uso: ver if		 Alias, consulte if para la descripción completa. Atributo:
Assert::class
Método:
Validation::assert(mixed $actual, mixed $expected = true, string $operator = '==')
225 Nombre: assert.equals
Uso: ver if.eq		 Alias, consulte if.eq para obtener la descripción completa. Atributo:
AssertEquals::class
Método:
Validation::assertEquals(mixed $actual, mixed $expected)
226 Nombre: assert.notEquals
Uso: ver if.neq		 Alias, consulte if.neq para la descripción completa. Atributo:
AssertNotEquals::class
Método:
Validation::assertNotEquals(mixed $actual, mixed $expected)
227 Nombre: assert.greaterThan
Uso: ver if.gt		 Alias, consulte if.gt para obtener la descripción completa. Atributo:
AssertGreaterThan::class
Método:
Validation::assertGreaterThan(mixed $actual, mixed $expected)
228 Nombre: assert.greaterThanOrEquals
Uso: ver if.gte		 Alias, consulte if.gte para ver la descripción completa. Atributo:
AssertGreaterThanOrEquals::class
Método:
Validation::assertGreaterThanOrEquals(mixed $actual, mixed $expected)
229 Nombre: assert.lessThan
Uso: ver if.lt		 Alias, consulte if.lt para obtener la descripción completa. Atributo:
AssertLessThan::class
Método:
Validation::assertLessThan(mixed $actual, mixed $expected)
230 Nombre: assert.lessThanOrEquals
Uso: ver if.lte		 Alias, consulte if.lte para ver la descripción completa. Atributo:
AssertLessThanOrEquals::class
Método:
Validation::assertLessThanOrEquals(mixed $actual, mixed $expected)
231 Nombre: blank
Uso: ver empty		 Alias, consulte empty para obtener la descripción completa. Atributo:
Blank::class
Método:
Validation::blank()
232 Nombre: is
Uso: ver equals		 Alias, consulte equals para la descripción completa. Atributo:
Is::class
Método:
Validation::is(mixed $value)
233 Nombre: same
Uso: ver equals		 Alias, consulte equals para la descripción completa. Atributo:
Same::class
Método:
Validation::same(mixed $value)
234 Nombre: pattern
Uso: ver matches		 Alias, consulte matches para la descripción completa. Atributo:
Pattern::class
Método:
Validation::pattern(string $pattern)
235 Nombre: choice
Uso: ver in		 Alias, in la descripción completa. Atributo:
Choice::class
Método:
Validation::choice(string|int|float|bool|null ...$values)
236 Nombre: size
Uso: ver count		 Alias, consulte el count para la descripción completa. Atributo:
Size::class
Método:
Validation::size(int $size)
237 Nombre: length
Uso: ver count		 Alias, consulte el count para la descripción completa. Atributo:
Length::class
Método:
Validation::length(int $count)
238 Nombre: range
Uso: ver between		 Alias, consulte between la descripción completa. Atributo:
Range::class
Método:
Validation::range(int|float $min, int|float $max)
239 Nombre: minmax
Uso: ver between		 Alias, consulte between la descripción completa. Atributo:
Minmax::class
Método:
Validation::minmax(int|float $min, int|float $max)
240 Nombre: filled
Uso: ver required		 Alias, consulte required para la descripción completa. Atributo:
Filled::class
Método:
Validation::filled()
241 Nombre: present
Uso: ver required		 Alias, consulte required para la descripción completa. Atributo:
Present::class
Método:
Validation::present()
242 Nombre: optional
Uso: ver allowed		 Alias, consulte el allowed para la descripción completa. Atributo:
Optional::class
Método:
Validation::optional()
243 Nombre: date
Uso: ver datetime		 Alias, consulte datetime para obtener la descripción completa. Atributo:
Date::class
Método:
Validation::date()
244 Nombre: date.equals
Uso: ver datetime.eq		 Alias, consulte datetime.eq para obtener la descripción completa. Atributo:
DateEquals::class
Método:
Validation::dateEquals(string $datetime)
245 Nombre: date.before
Uso: ver datetime.lt		 Alias, consulte datetime.lt para obtener la descripción completa. Atributo:
DateBefore::class
Método:
Validation::dateBefore(string $datetime)
246 Nombre: date.beforeOrEquals
Uso: ver datetime.lte		 Alias, consulte datetime.lte para ver la descripción completa. Atributo:
DateBeforeOrEquals::class
Método:
Validation::dateBeforeOrEquals(string $datetime)
247 Nombre: date.after
Uso: ver datetime.gt		 Alias, consulte datetime.gt para obtener la descripción completa. Atributo:
DateAfter::class
Método:
Validation::dateAfter(string $datetime)
248 Nombre: date.afterOrEquals
Uso: ver datetime.gte		 Alias, consulte datetime.gte para ver la descripción completa. Atributo:
DateAfterOrEquals::class
Método:
Validation::dateAfterOrEquals(string $datetime)
249 Nombre: date.format
Uso: ver datetime.format		 Alias, consulte datetime.format para obtener la descripción completa. Atributo:
DateFormat::class
Método:
Validation::dateFormat(string $format)
250 Nombre: cakeday
Uso: ver datetime.birthday		 Alias, consulte datetime.birthday para obtener la descripción completa. Atributo:
Cakeday::class
Método:
Validation::cakeday()

macros

Macro Expresión de validación
[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"

Puntos de referencia

A estas alturas, puede parecer que mighty está haciendo demasiado y las preocupaciones de rendimiento están comenzando a surgir. Bueno, no hay necesidad de preocuparse por eso. mighty es realmente rápido y está optimizado para proporcionar el mejor rendimiento. Aquí hay algunos puntos de referencia del rendimiento del validador:

No tan científico de referencia

El rendimiento del mighty validador y el validador de Laravel en una aplicación de Laravel. La prueba se llevó a cabo utilizando una matriz de 50000 elementos, la mitad de ellos son enteros y la otra mitad son cadenas numéricas. Cada validador se probó 10 veces (consecutivamente) y se recogió el resultado promedio de estos 10:

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

Entonces mighty es aproximadamente 12.5 veces más rápido que el validador de Laravel con XDebug Discapacitada y aproximadamente 4x veces más rápido con XDebug habilitado.

Punto de referencia científico

El punto de referencia se realiza usando phpbench. Aquí hay una visión general 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

■ Hecho: El resultado de referencia más reciente también se puede encontrar en la tubería CI, que se actualizará con cada empuje/PR al escenario.

Notas

  1. mighty genera mensajes de error realmente amigables de forma predeterminada (actualmente solo en inglés). Estos mensajes se pueden sobrescribir fácilmente en las bases de validador/restricción. Es posible que desee tener estos mensajes en diferentes idiomas, para eso, se puede utilizar el método MAKS mighty Rule::setMessageTranslator() . Este método es una forma conveniente de establecer un traductor de mensajes global, requiere un cierre que recibe el mensaje sin procesar (con marcadores de posición) como argumento y debe devolver la versión traducida de ese mensaje.
  2. Consulte la mighty especificación del lenguaje de expresión de validación para aprender más sobre la teoría detrás de mighty y comprender cómo funciona el lenguaje.
  3. Consulte la mighty documentación de la API para obtener más información sobre la API PHP. La API está bien documentada y no debería haber nada que no esté cubierto allí.
  4. mighty es actualmente una biblioteca de validación pura, no hace ningún tipo de transformación en los datos. El motor y el diseño actual son lo suficientemente flexibles y se pueden usar para implementar fácilmente un desinfectante además, no hay plan para hacer esto en este momento, pero puede ser un hito futuro.

Licencia

mighty es un proyecto de código abierto con licencia bajo la licencia MIT .
Copyright (c) 2022 Marwan al-Soltany. Reservados todos los derechos.

Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo