valitron

Valitron: validación sencilla que no apesta

Valitron es una biblioteca de validación independiente simple, minimalista y elegante SIN dependencias. Valitron utiliza métodos de validación sencillos y directos centrados en una sintaxis legible y concisa. Valitron es la biblioteca de validación simple y pragmática que estaba buscando.

Obtenga soporte para vlucas/valitron con la suscripción a Tidelift

¿Por qué Valitrón?

Valitron se creó a partir de la frustración con otras bibliotecas de validación que dependen de componentes grandes de otros marcos como HttpFoundation de Symfony, generando una tonelada de archivos adicionales que realmente no son necesarios para la validación básica. También tiene una sintaxis deliberadamente simple que se utiliza para ejecutar todas las validaciones en una sola llamada en lugar de validar individualmente cada valor creando instancias de nuevas clases y validando valores uno a la vez, como lo requieren otras bibliotecas de validación.

En resumen, Valitron es todo lo que ha estado buscando en una biblioteca de validación pero que no ha podido encontrar hasta ahora: sintaxis pragmática simple, código liviano que tiene sentido, extensible para validaciones y devoluciones de llamadas personalizadas, bien probado y sin dependencias. . Empecemos.

Instalación

Valitron usa Composer para instalar y actualizar:

 curl -s http://getcomposer.org/installer | php
php composer.phar require vlucas/valitron

Los ejemplos siguientes utilizan la sintaxis de PHP 5.4, pero Valitron funciona en PHP 5.3+.

Uso

El uso es simple y directo. Simplemente proporcione una serie de datos que desea validar, agregue algunas reglas y luego llame validate() . Si hay algún error, puede llamar errors() para obtenerlo.

 $ v = new Valitron  Validator ( array ( ' name ' => ' Chester Tester ' ));
$ v -> rule ( ' required ' , ' name ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

Con este formato, puede validar los datos $_POST directa y fácilmente, e incluso puede aplicar una regla como required a una serie de campos:

 $ v = new Valitron  Validator ( $ _POST );
$ v -> rule ( ' required ' , [ ' name ' , ' email ' ]);
$ v -> rule ( ' email ' , ' email ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

Puede utilizar la sintaxis de puntos para acceder a los miembros de matrices multidimensionales y un asterisco para validar cada miembro de una matriz:

 $ v = new Valitron  Validator ( array ( ' settings ' => array (
    array ( ' threshold ' => 50 ),
    array ( ' threshold ' => 90 )
)));
$ v -> rule ( ' max ' , ' settings.*.threshold ' , 100 );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

O utilice la sintaxis de puntos para validar todos los miembros de una matriz numérica:

 $ v = new Valitron  Validator ( array ( ' values ' => array ( 50 , 90 )));
$ v -> rule ( ' max ' , ' values.* ' , 100 );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

También puede acceder a valores anidados usando notación de puntos:

 $ v = new Valitron  Validator ( array ( ' user ' => array ( ' first_name ' => ' Steve ' , ' last_name ' => ' Smith ' , ' username ' => ' Batman123 ' )));
$ v -> rule ( ' alpha ' , ' user.first_name ' )-> rule ( ' alpha ' , ' user.last_name ' )-> rule ( ' alphaNum ' , ' user.username ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

Configuración del idioma y el directorio de idioma globalmente:

 // boot or config file

use Valitron  Validator as V ;

V:: langDir ( __DIR__ . ' /validator_lang ' ); // always set langDir before lang.
V:: lang ( ' ar ' );

Deshabilitar el nombre del {campo} en la salida del mensaje de error.

 use Valitron  Validator as V ;

$ v = new Valitron  Validator ([ ' name ' => ' John ' ]);
$ v -> rule ( ' required ' , [ ' name ' ]);

// Disable prepending the labels
$ v -> setPrependLabels ( false );

// Error output for the "false" condition
[
    [ " name " ] => [
        " is required "
    ]
]

// Error output for the default (true) condition
[
    [ " name " ] => [
        " name is required "
    ]
]

Puede exigir valores condicionalmente utilizando reglas condicionales requeridas. En este ejemplo, para la autenticación, requerimos un token cuando el correo electrónico y la contraseña no están presentes, o una contraseña cuando la dirección de correo electrónico está presente.

 // this rule set would work for either data set...
$ data = [ ' email ' => ' [email protected] ' , ' password ' => ' mypassword ' ];
// or...
$ data = [ ' token ' => ' jashdjahs83rufh89y38h38h ' ];

$ v = new Valitron  Validator ( $ data );
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' token ' , [ ' email ' , ' password ' ], true ]
    ],
    ' requiredWith ' => [
        [ ' password ' , [ ' email ' ]]
    ],
    ' email ' => [
        [ ' email ' ]
    ]
    ' optional ' => [
        [ ' email ' ]
    ]
]);
$ this -> assertTrue ( $ v -> validate ());

Reglas de validación integradas

• required : el campo es obligatorio
• requiredWith : el campo es obligatorio si hay otros campos presentes
• requiredWithout : el campo es obligatorio si NO hay otros campos presentes
• equals : el campo debe coincidir con otro campo (confirmación de correo electrónico/contraseña)
• different : el campo debe ser diferente de otro campo
• accepted : se debe aceptar la casilla de verificación o la radio (sí, activado, 1, verdadero)
• numeric : debe ser numérico
• integer : debe ser un número entero
• boolean : debe ser booleano
• array : debe ser una matriz
• length : la cadena debe tener cierta longitud
• lengthBetween : la cadena debe estar entre longitudes dadas
• lengthMin : la cadena debe ser mayor que la longitud dada
• lengthMax : la cadena debe ser menor que la longitud especificada
• min - Mínimo
• max - Máximo
• listContains : realiza una verificación in_array en valores de matriz dados (al revés que in )
• in : realiza una comprobación in_array de los valores de matriz dados.
• notIn - Negación de in regla (no en una matriz de valores)
• ip : dirección IP válida
• ipv4 : dirección IP v4 válida
• ipv6 : dirección IP v6 válida
• email : dirección de correo electrónico válida
• emailDNS : dirección de correo electrónico válida con registro DNS activo
• url : URL válida
• urlActive : URL válida con registro DNS activo
• alpha : solo caracteres alfabéticos
• alphaNum : solo caracteres alfabéticos y numéricos
• ascii : solo caracteres ASCII
• slug - caracteres de slug de URL (az, 0-9, -, _)
• regex - Coincidencias de campo dado el patrón de expresión regular
• date : el campo es una fecha válida
• dateFormat : el campo es una fecha válida en el formato dado
• dateBefore : el campo es una fecha válida y es anterior a la fecha indicada
• dateAfter : el campo es una fecha válida y es posterior a la fecha indicada
• contains : el campo es una cadena y contiene la cadena dada
• subset : el campo es una matriz o un escalar y todos los elementos están contenidos en la matriz dada
• containsUnique : el campo es una matriz y contiene valores únicos
• creditCard : el campo es un número de tarjeta de crédito válido
• instanceOf : el campo contiene una instancia de la clase dada
• optional : no es necesario incluir el valor en la matriz de datos. Sin embargo, si es así, debe pasar la validación.
• arrayHasKeys : el campo es una matriz y contiene todas las claves especificadas.

NOTA : Si está comparando números de punto flotante con validadores mínimo/máximo, debe instalar la extensión BCMath para mayor precisión y confiabilidad. La extensión no es necesaria para que Valitron funcione, pero Valitron la usará si está disponible y es muy recomendable.

uso de campos requeridos

la regla required verifica si existe un campo en la matriz de datos y si no es nulo o una cadena vacía.

 $ v -> rule ( ' required ' , ' field_name ' );

Usando un parámetro adicional, puede hacer que esta regla sea más flexible y solo verificar si el campo existe en la matriz de datos.

 $ v -> rule ( ' required ' , ' field_name ' , true );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' , ' required_but_null ' => null ]);
$ v -> rules ([
    ' required ' => [
        [ ' username ' ],
        [ ' password ' ],
        [ ' required_but_null ' , true ] // boolean flag allows empty value so long as the field name is set on the data array
    ]
]);
$ v -> validate ();

requeridoCon uso de campos

La regla requiredWith verifica que el campo sea obligatorio, no nulo y no la cadena vacía, si hay otros campos presentes, no nulo y no la cadena vacía.

 // password field will be required when the username field is provided and not empty
$ v -> rule ( ' requiredWith ' , ' password ' , ' username ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' password ' , ' username ' ]
    ]
]);
$ v -> validate ();

Nota Puede proporcionar varios valores como una matriz. En este caso, si CUALQUIERA de los campos está presente, el campo será obligatorio.

 // in this case the password field will be required if the username or email fields are present
$ v -> rule ( ' requiredWith ' , ' password ' , [ ' username ' , ' email ' ]);

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' password ' , [ ' username ' , ' email ' ]]
    ]
]);
$ v -> validate ();

bandera estricta

El indicador estricto cambiará la regla requiredWith a requiredWithAll lo que requerirá el campo solo si TODOS los demás campos están presentes, no son nulos ni la cadena vacía.

 // in this example the suffix field is required only when both the first_name and last_name are provided
$ v -> rule ( ' requiredWith ' , ' suffix ' , [ ' first_name ' , ' last_name ' ], true );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' , ' suffix ' => ' Mr ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

Del mismo modo, en este caso validate() seguiría devolviendo verdadero, ya que el campo sufijo no sería necesario en modo estricto, ya que no se proporcionan todos los campos.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

obligatorioSin uso de campos

La regla requiredWithout verifica que el campo sea obligatorio, no nulo y no la cadena vacía, si NO hay otros campos presentes.

 // this rule will require the username field when the first_name is not present
$ v -> rule ( ' requiredWithout ' , ' username ' , ' first_name ' )

Sintaxis alternativa.

 // this will return true, as the username is provided when the first_name is not provided
$ v = new Valitron  Validator ([ ' username ' => ' spiderman ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , ' first_name ' ]
    ]
]);
$ v -> validate ();

Nota Puede proporcionar varios valores como una matriz. En este caso, si CUALQUIERA de los campos NO está presente, el campo será obligatorio.

 // in this case the username field will be required if either the first_name or last_name fields are not present
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ]);

Sintaxis alternativa.

 // this passes validation because although the last_name field is not present, the username is provided
$ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' first_name ' => ' Peter ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , [ ' first_name ' , ' last_name ' ]]
    ]
]);
$ v -> validate ();

bandera estricta

El indicador estricto cambiará la regla requiredWithout a requiredWithoutAll lo que requerirá el campo solo si TODOS los demás campos no están presentes.

 // in this example the username field is required only when both the first_name and last_name are not provided
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ], true );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' BatMan ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

Del mismo modo, en este caso validate() aún devolvería verdadero, ya que el campo de nombre de usuario no sería obligatorio en modo estricto, ya que se proporcionan todos los campos.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

es igual al uso de campos

La regla de equals verifica si dos campos son iguales en la matriz de datos y que el segundo campo no es nulo.

 $ v -> rule ( ' equals ' , ' password ' , ' confirmPassword ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' password ' => ' youshouldnotseethis ' , ' confirmPassword ' => ' youshouldnotseethis ' ]);
$ v -> rules ([
    ' equals ' => [
        [ ' password ' , ' confirmPassword ' ]
    ]
]);
$ v -> validate ();

uso de diferentes campos

La regla different verifica si dos campos no son iguales o diferentes en la matriz de datos y que el segundo campo no es nulo.

 $ v -> rule ( ' different ' , ' username ' , ' password ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' different ' => [
        [ ' username ' , ' password ' ]
    ]
]);
$ v -> validate ();

uso de campos aceptados

La regla accepted comprueba si el campo es "sí", "activado", 1 o verdadero.

 $ v -> rule ( ' accepted ' , ' remember_me ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
    ' accepted ' => [
        [ ' remember_me ' ]
    ]
]);
$ v -> validate ();

uso de campos numéricos

La regla numeric verifica si el campo es numérico. Esto es análogo a la función is_numeric() de PHP.

 $ v -> rule ( ' numeric ' , ' amount ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' amount ' => 3.14 ]);
$ v -> rules ([
    ' numeric ' => [
        [ ' amount ' ]
    ]
]);
$ v -> validate ();

uso de campos enteros

La regla de integer verifica si el campo es un número entero.

 $ v -> rule ( ' integer ' , ' age ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' age ' => ' 27 ' ]);
$ v -> rules ([
    ' integer ' => [
        [ ' age ' ]
    ]
]);
$ v -> validate ();

Tenga en cuenta que el indicador booleano opcional para el modo estricto garantiza que los números enteros se proporcionen en forma estrictamente numérica. Entonces la siguiente regla se evaluaría como verdadera:

 $ v = new Valitron  Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' 27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate ();

Mientras que lo siguiente se evaluará como falso, ya que el + para el número positivo en este caso es redundante:

 $ v = new Valitron  Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' +27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate ();

uso de campos booleanos

La regla boolean comprueba si el campo es booleano. Esto es análogo a la función is_bool() de php.

 $ v -> rule ( ' boolean ' , ' remember_me ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
    ' boolean ' => [
        [ ' remember_me ' ]
    ]
]);
$ v -> validate ();

uso de campos de matriz

La regla array comprueba si el campo es una matriz. Esto es análogo a la función is_array() de PHP.

 $ v -> rule ( ' array ' , ' user_notifications ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' user_notifications ' => [ ' bulletin_notifications ' => true , ' marketing_notifications ' => false , ' message_notification ' => true ]]);
$ v -> rules ([
    ' array ' => [
        [ ' user_notifications ' ]
    ]
]);
$ v -> validate ();

uso de campos de longitud

La regla length verifica si el campo tiene exactamente una longitud determinada y que el campo es una cadena válida.

 $ v -> rule ( ' length ' , ' username ' , 10 );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
    ' length ' => [
        [ ' username ' , 10 ]
    ]
]);
$ v -> validate ();

Longitud entre campos de uso

La regla lengthBetween comprueba si el campo está entre una longitud dada y que el campo es una cadena válida.

 $ v -> rule ( ' lengthBetween ' , ' username ' , 1 , 10 );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
    ' lengthBetween ' => [
        [ ' username ' , 1 , 10 ]
    ]
]);
$ v -> validate ();

Uso de campos de longitud mínima

La regla lengthMin comprueba si el campo tiene al menos una longitud determinada y que el campo es una cadena válida.

 $ v -> rule ( ' lengthMin ' , ' username ' , 5 );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' martha ' ]);
$ v -> rules ([
    ' lengthMin ' => [
        [ ' username ' , 5 ]
    ]
]);
$ v -> validate ();

uso de campos lengthMax

La regla lengthMax comprueba si el campo tiene como máximo una longitud determinada y que el campo es una cadena válida.

 $ v -> rule ( ' lengthMax ' , ' username ' , 10 );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' bruins91 ' ]);
$ v -> rules ([
    ' lengthMax ' => [
        [ ' username ' , 10 ]
    ]
]);
$ v -> validate ();

uso mínimo de campos

La regla min comprueba si el campo tiene al menos un valor determinado y que el valor proporcionado es numérico.

 $ v -> rule ( ' min ' , ' age ' , 18 );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' age ' => 28 ]);
$ v -> rules ([
    ' min ' => [
        [ ' age ' , 18 ]
    ]
]);
$ v -> validate ();

uso máximo de campos

La regla max comprueba si el campo tiene como máximo un valor determinado y que el valor proporcionado es numérico.

 $ v -> rule ( ' max ' , ' age ' , 12 );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' age ' => 10 ]);
$ v -> rules ([
    ' max ' => [
        [ ' age ' , 12 ]
    ]
]);
$ v -> validate ();

listaContiene uso de campos

La regla listContains verifica que el campo esté presente en una matriz de valores determinada.

 $ v -> rule ( ' listContains ' , ' color ' , ' yellow ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' color ' => [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]);
$ v -> rules ([
    ' listContains ' => [
        [ ' color ' , ' yellow ' ]
    ]
]);
$ v -> validate ();

en el uso de campos

La regla in verifica que el campo esté presente en una matriz de valores determinada.

 $ v -> rule ( ' in ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]);

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
    ' in ' => [
        [ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]]
    ]
]);
$ v -> validate ();

uso de campos notIn

La regla notIn verifica que el campo NO esté presente en una matriz de valores determinada.

 $ v -> rule ( ' notIn ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]);

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
    ' notIn ' => [
        [ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]
    ]
]);
$ v -> validate ();

uso de campos ip

La regla ip verifica que el campo sea una dirección IP válida. Esto incluye rangos IPv4, IPv6, privados y reservados.

 $ v -> rule ( ' ip ' , ' user_ip ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
    ' ip ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

uso de campos ipv4

La regla ipv4 verifica que el campo sea una dirección IPv4 válida.

 $ v -> rule ( ' ipv4 ' , ' user_ip ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
    ' ipv4 ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

uso de campos ipv6

La regla ipv6 verifica que el campo sea una dirección IPv6 válida.

 $ v -> rule ( ' ipv6 ' , ' user_ip ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 0:0:0:0:0:0:0:1 ' ]);
$ v -> rules ([
    ' ipv6 ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

uso de campos de correo electrónico

La regla email comprueba que el campo sea una dirección de correo electrónico válida.

 $ v -> rule ( ' email ' , ' user_email ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
    ' email ' => [
        [ ' user_email ' ]
    ]
]);
$ v -> validate ();

Uso de campos de emailDNS

La regla emailDNS valida que el campo sea una dirección de correo electrónico válida con un registro DNS activo o de cualquier tipo.

 $ v -> rule ( ' emailDNS ' , ' user_email ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
    ' emailDNS ' => [
        [ ' user_email ' ]
    ]
]);
$ v -> validate ();

uso de campos de URL

La regla url verifica que el campo sea una URL válida.

 $ v -> rule ( ' url ' , ' website ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
    ' url ' => [
        [ ' website ' ]
    ]
]);
$ v -> validate ();

Uso de campos urlActive

La regla urlActive comprueba que el campo sea una URL válida con un registro A, AAAA o CNAME activo.

 $ v -> rule ( ' urlActive ' , ' website ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
    ' urlActive ' => [
        [ ' website ' ]
    ]
]);
$ v -> validate ();

uso de campos alfa

La regla alpha verifica que el campo tenga solo caracteres alfabéticos.

 $ v -> rule ( ' alpha ' , ' username ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

Uso de campos alfanuméricos

La regla alphaNum comprueba que el campo contenga sólo caracteres alfabéticos o numéricos.

 $ v -> rule ( ' alphaNum ' , ' username ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' alphaNum ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

uso de campos ascii

La regla ascii comprueba que el campo contenga sólo caracteres del conjunto de caracteres ascii.

 $ v -> rule ( ' ascii ' , ' username ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' ascii ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

uso de campos de babosas

La regla slug comprueba que el campo solo contenga caracteres slug de URL (az, 0-9, -, _).

 $ v -> rule ( ' slug ' , ' username ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' L337-H4ckZ0rz_123 ' ]);
$ v -> rules ([
    ' slug ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

uso de campos de expresiones regulares

La regla regex garantiza que el campo coincida con un patrón de expresiones regulares determinado. (Esta expresión regular verifica que la cadena sea alfanumérica entre 5 y 10 caracteres).

 $ v -> rule ( ' regex ' , ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' regex ' => [
        [ ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' ]
    ]
]);
$ v -> validate ();

uso de campos de fecha

La regla date verifica si el campo proporcionado es un objeto DateTime válido o si la cadena se puede convertir a una marca de tiempo Unix mediante strtotime().

 $ v -> rule ( ' date ' , ' created_at ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
    ' date ' => [
        [ ' created_at ' ]
    ]
]);
$ v -> validate ();

Uso de los campos dateFormat

La regla dateFormat verifica que el campo proporcionado sea una fecha válida en un formato de fecha específico.

 $ v -> rule ( ' dateFormat ' , ' created_at ' , ' Y-m-d ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
    ' dateFormat ' => [
        [ ' created_at ' , ' Y-m-d ' ]
    ]
]);
$ v -> validate ();

fechaAntes del uso de campos

La regla dateBefore verifica que el campo proporcionado sea una fecha válida anterior a una fecha específica.

 $ v -> rule ( ' dateBefore ' , ' created_at ' , ' 2018-10-13 ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
    ' dateBefore ' => [
        [ ' created_at ' , ' 2018-10-13 ' ]
    ]
]);
$ v -> validate ();

fechaDespués del uso de campos

La regla dateAfter verifica que el campo proporcionado sea una fecha válida después de una fecha específica.

 $ v -> rule ( ' dateAfter ' , ' created_at ' , ' 2018-10-13 ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
    ' dateAfter ' => [
        [ ' created_at ' , ' 2018-01-01 ' ]
    ]
]);
$ v -> validate ();

contiene el uso de campos

La regla contains verifica que exista una cadena determinada dentro del campo y verifica que tanto el campo como el valor de búsqueda sean cadenas válidas.

 $ v -> rule ( ' contains ' , ' username ' , ' man ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' man ' ]
    ]
]);
$ v -> validate ();

Nota Puede utilizar el indicador estricto opcional para garantizar una coincidencia que distinga entre mayúsculas y minúsculas. El siguiente ejemplo devolverá verdadero:

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' man ' ]
    ]
]);
$ v -> validate ();

Mientras que esto devolvería falso, ya que la M en la cadena de búsqueda no está en mayúscula en el valor proporcionado:

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' Man ' , true ]
    ]
]);
$ v -> validate ();

uso de campos de subconjunto

La regla subset verifica que el campo sea un campo escalar o de matriz y que todos sus valores estén contenidos dentro de un conjunto de valores determinado.

 $ v -> rule ( ' subset ' , ' colors ' , [ ' green ' , ' blue ' , ' orange ' ]);

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' green ' , ' blue ' ]]);
$ v -> rules ([
    ' subset ' => [
        [ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
    ]
]);
$ v -> validate ();

Este ejemplo devolvería falso, ya que el color proporcionado, violeta, no existe en la matriz de valores aceptados que proporcionamos.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
    ' subset ' => [
        [ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
    ]
]);
$ v -> validate ();

contieneUso de campos únicos

La regla containsUnique verifica que el campo proporcionado sea una matriz y que todos los valores contenidos en ella sean únicos, es decir, que no haya valores duplicados en la matriz.

 $ v -> rule ( ' containsUnique ' , ' colors ' );

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
    ' containsUnique ' => [
        [ ' colors ' ]
    ]
]);
$ v -> validate ();

Este ejemplo devolvería falso, ya que los valores de la matriz proporcionada están duplicados.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' purple ' ]]);
$ v -> rules ([
    ' containsUnique ' => [
        [ ' colors ' ]
    ]
]);
$ v -> validate ();

Uso de validación de tarjeta de crédito

La validación de tarjetas de crédito actualmente permite validar una Visa visa , Mastercard mastercard , Dinersclub dinersclub , American Express amex o Discover discover

Esto comparará la tarjeta de crédito con cada tipo de tarjeta.

 $ v -> rule ( ' creditCard ' , ' credit_card ' );

Para filtrar opcionalmente los tipos de tarjetas, agregue el slug a una matriz como el siguiente parámetro:

 $ v -> rule ( ' creditCard ' , ' credit_card ' , [ ' visa ' , ' mastercard ' ]);

Si solo quieres validar un tipo de tarjeta, ponlo como una cadena:

 $ v -> rule ( ' creditCard ' , ' credit_card ' , ' visa ' );

Si la información del tipo de tarjeta proviene del cliente, es posible que también desee especificar una serie de tipos de tarjeta válidos:

 $ cardType = ' amex ' ;
$ v -> rule ( ' creditCard ' , ' credit_card ' , $ cardType , [ ' visa ' , ' mastercard ' ]);
$ v -> validate (); // false 

uso de campos de instancia

La regla instanceOf comprueba que el campo sea una instancia de una clase determinada.

 $ v -> rule ( ' instanceOf ' , ' date ' , DateTime);

Sintaxis alternativa.

 $ v = new Valitron  Validator ([ ' date ' => new  DateTime ()]);
$ v -> rules ([
    ' instanceOf ' => [
        [ ' date ' , ' DateTime ' ]
    ]
]);
$ v -> validate ();

Nota También puede comparar el valor con un objeto determinado en lugar del nombre de la clase de cadena. Este ejemplo también devolvería verdadero:

 $ v = new Valitron  Validator ([ ' date ' => new  DateTime ()]);
$ existingDateObject = new  DateTime ();
$ v -> rules ([
    ' instanceOf ' => [
        [ ' date ' , $ existingDateObject ]
    ]
]);
$ v -> validate ();

uso de campos opcionales

La regla optional garantiza que, si el campo está presente en el conjunto de datos, pasará todas las reglas de validación.

 $ v -> rule ( ' optional ' , ' username ' );

Sintaxis alternativa. Este ejemplo devolvería verdadero cuando el campo 'nombre de usuario' no esté presente o en el caso de que el nombre de usuario tenga solo caracteres alfabéticos.

 $ v = new Valitron  Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ],
    ' optional ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

Este ejemplo devolvería falso, ya que aunque el campo es opcional, como se proporciona debe pasar todas las reglas de validación, lo cual en este caso no es así.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ],
    ' optional ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

Uso de los campos arrayHasKeys

La regla arrayHasKeys garantiza que el campo sea una matriz y que contenga todas las claves especificadas. Devuelve falso si el campo no es una matriz, si no se especifican las claves requeridas o si falta alguna clave.

 $ v = new Valitron  Validator ([
    ' address ' => [
        ' name ' => ' Jane Doe ' ,
        ' street ' => ' Doe Square ' ,
        ' city ' => ' Doe D.C. '
    ]
]);
$ v -> rule ( ' arrayHasKeys ' , ' address ' , [ ' name ' , ' street ' , ' city ' ]);
$ v -> validate ();

Agregar reglas de validación personalizadas

Para agregar su propia regla de validación, use el método addRule con un nombre de regla, una devolución de llamada o cierre personalizado y un mensaje de error para mostrar en caso de error. La devolución de llamada proporcionada debe devolver un valor booleano verdadero o falso.

 Valitron Validator:: addRule ( ' alwaysFail ' , function ( $ field , $ value , array $ params , array $ fields ) {
    return false ;
}, ' Everything you do is wrong. You fail. ' );

También puede utilizar reglas únicas que solo sean válidas para los campos especificados.

 $ v = new Valitron  Validator ( array ( " foo " => " bar " ));
$ v -> rule ( function ( $ field , $ value , $ params , $ fields ) {
    return true ;
}, " foo " )-> message ( " {field} failed... " );

Esto es útil porque dichas reglas pueden tener acceso a variables definidas en el ámbito donde vive el Validator . La firma del cierre es idéntica a la firma de la devolución de llamada de Validator::addRule .

Si desea agregar sus propias reglas que no sean estáticas (es decir, su regla no es estática y está disponible para llamar a instancias Validator ), debe usar Validator::addInstanceRule . Esta regla tomará los mismos parámetros que Validator::addRule pero debe invocarse en una instancia Validator .

Reglas de encadenamiento

Puede encadenar varias reglas utilizando la siguiente sintaxis.

 $ v = new Valitron  Validator ([ ' email_address ' => ' [email protected] ' ]);
$ v -> rule ( ' required ' , ' email_address ' )-> rule ( ' email ' , ' email_address ' );
$ v -> validate ();

Sintaxis alternativa para agregar reglas

A medida que crece el número de reglas, es posible que prefiera la sintaxis alternativa para definir varias reglas a la vez.

 $ rules = [
    ' required ' => ' foo ' ,
    ' accepted ' => ' bar ' ,
    ' integer ' =>  ' bar '
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> validate ();

Si su regla requiere múltiples parámetros o un solo parámetro más complejo que una cadena, debe envolver la regla en una matriz.

 $ rules = [
    ' required ' => [
        [ ' foo ' ],
        [ ' bar ' ]
    ],
    ' length ' => [
        [ ' foo ' , 3 ]
    ]
];

También puede especificar varias reglas para cada tipo de regla.

 $ rules = [
    ' length '   => [
        [ ' foo ' , 5 ],
        [ ' bar ' , 5 ]
    ]
];

Al combinar estas técnicas, puede crear una definición de regla completa en una estructura de datos relativamente compacta.

Puede continuar agregando reglas individuales con el método rule incluso después de especificar una definición de regla mediante una matriz. Esto es especialmente útil si define reglas de validación personalizadas.

 $ rules = [
    ' required ' => ' foo ' ,
    ' accepted ' => ' bar ' ,
    ' integer ' =>  ' bar '
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> rule ( ' min ' , ' bar ' , 0 );
$ v -> validate ();

También puede agregar reglas por campo:

 $ rules = [
    ' required ' ,
    [ ' lengthMin ' , 4 ]
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' ));
$ v -> mapFieldRules ( ' foo ' , $ rules );
$ v -> validate ();

O para varios campos a la vez:

 $ rules = [
    ' foo ' => [ ' required ' , ' integer ' ],
    ' bar ' =>[ ' email ' , [ ' lengthMin ' , 4 ]]
];

$ v = new Valitron Validator(array( ' foo ' => ' bar ' , ' bar ' => '[email protected]));
$v->mapFieldsRules($rules);
$v->validate();

Agregar etiqueta de campo a los mensajes

Puede hacer esto de dos maneras diferentes: puede agregar una etiqueta individual a una regla o una matriz de todas las etiquetas para las reglas.

Para agregar una etiqueta individual a la regla, simplemente agregue el método label después de la regla.

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate ();

Hay un caso extremo en este método: no podría usar una serie de nombres de campos en la definición de la regla, por lo que una regla por campo. Entonces esto no funcionaría:

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate ();

Sin embargo, podemos usar una variedad de etiquetas para resolver este problema simplemente agregando el método labels :

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' );
$ v -> labels ( array (
    ' name ' => ' Name ' ,
    ' email ' => ' Email address '
));
$ v -> validate ();

Esto introduce un nuevo conjunto de etiquetas en su archivo de idioma de error que se parece a {field} ; si está utilizando una regla como equals puede acceder al segundo valor en el archivo de idioma incrementando el campo con un valor como {field1} .

Reutilización de reglas de validación

Puede reutilizar sus reglas de validación para validar rápidamente diferentes datos con las mismas reglas utilizando el método withData:

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' );
$ v -> validate (); //false

$ v2 = $ v -> withData ( array ( ' name ' => ' example ' ));
$ v2 -> validate (); //true 

Ejecución de pruebas

El conjunto de pruebas depende del cargador automático de Composer para cargar y ejecutar los archivos de Valitron. Asegúrese de haber descargado e instalado Composer antes de ejecutar las pruebas:

1. Descargar Composer curl -s http://getcomposer.org/installer | php
2. Ejecute 'instalar' php composer.phar install
3. Ejecute las pruebas phpunit

Contribuyendo

1. bifurcarlo
2. Crea tu rama de funciones ( git checkout -b my-new-feature )
3. Haz tus cambios
4. Ejecute las pruebas, agregando nuevas para su propio código si es necesario ( phpunit )
5. Confirme sus cambios ( git commit -am 'Added some feature' )
6. Empujar a la rama ( git push origin my-new-feature )
7. Crear nueva solicitud de extracción
8. Date una palmadita en la espalda por ser tan increíble.

Divulgaciones de seguridad e información de contacto

Para informar una vulnerabilidad de seguridad, utilice el contacto de seguridad de Tidelift. Tidelift coordinará la solución y la divulgación.