Validadores de valores

¿Necesitas verificar rápida y fácilmente que una variable contiene, por ejemplo, una dirección de correo electrónico válida? Entonces le resultará útil Nette\Utils\Validators, una clase estática con funciones útiles para validar valores.

Instalación:

composer require nette/utils

Todos los ejemplos asumen que el siguiente alias de clase está definido:

use Nette\Utils\Validators;

Uso básico

La clase Validators tiene un número de métodos para validar valores, como isList(), isUnicode(), isEmail(), isUrl(), etc. para usar en tu código:

if (!Validators::isEmail($email)) {
	throw new InvalidArgumentException;
}

Además, puede verificar si el valor satisface los llamados tipos esperados, que es una cadena donde las opciones individuales están separadas por una barra vertical |. Esto facilita la verificación de tipos de unión utilizando if():

if (!Validators::is($val, 'int|string|bool')) {
	// ...
}

Pero también te da la oportunidad de crear un sistema donde es necesario escribir las expectativas como cadenas (por ejemplo en anotaciones o configuración) y luego verificar de acuerdo a ellas.

También puede declarar aserción, que lanza una excepción si no se cumple.

Tipos esperados

Un tipo esperado es una cadena formada por una o más variantes separadas por una barra vertical |, similar to writing types in PHP (ie. 'int|string|bool'). También se permite la notación nulable ?int.

Una matriz en la que todos los elementos son de un tipo determinado se escribe de la forma int[].

Algunos tipos pueden ir seguidos de dos puntos y la longitud :length o el rango :[min]..[max] por ejemplo, string:10 (cadena con una longitud de 10 bytes), float:10.. (número 10 y mayores), array:..10 (matriz de hasta diez elementos) o list:10..20 (lista de 10 a 20 elementos), o una expresión regular para pattern:[0-9]+.

Resumen de tipos y reglas:

Afirmación

assert($value, string $expected, string $label='variable'): void

Verifica que el valor es de los tipos esperados separados por una tubería. Si no es así, lanza la excepción Nette\Utils\AssertionException. La palabra variable del mensaje de excepción puede sustituirse por el parámetro $label.

Validators::assert('Nette', 'string:5'); // OK
Validators::assert('Lorem ipsum dolor sit', 'string:78');
// AssertionException: The variable expects to be string:78, string 'Lorem ipsum dolor sit' given.

assertField(array $array, string|int $key, string $expected=null, string $label=null): void

Verifica que el elemento $key en el array $array es de los tipos esperados separados por una tubería. Si no es así, lanza la excepción Nette\Utils\AssertionException. La cadena item '%' in array del mensaje de excepción puede sustituirse por el parámetro $label.

$arr = ['foo' => 'Nette'];

Validators::assertField($arr, 'foo', 'string:5'); // OK
Validators::assertField($arr, 'bar', 'string:15');
// AssertionException: Missing item 'bar' in array.
Validators::assertField($arr, 'foo', 'int');
// AssertionException: The item 'foo' in array expects to be int, string 'Nette' given.

Validadores

is($value, string $expected): bool

Comprueba si el valor es de los tipos esperados separados por una tubería.

Validators::is(1, 'int|float');  // true
Validators::is(23, 'int:0..10'); // false
Validators::is('Nette Framework', 'string:15');     // true, length is 15 bytes
Validators::is('Nette Framework', 'string:8..');    // true
Validators::is('Nette Framework', 'string:30..40'); // false

isEmail(mixed $value): bool

Verifica que el valor es una dirección de correo electrónico válida. No verifica que el dominio exista realmente, sólo se verifica la sintaxis. La función también cuenta con futuros TLD, que también pueden estar en unicode.

Validators::isEmail('example@nette.org'); // true
Validators::isEmail('example@localhost'); // false
Validators::isEmail('nette');             // false

isInRange(mixed $value, array $range): bool

Comprueba si el valor está dentro del rango dado [min, max]donde se puede omitir el límite superior o inferior (null). Se pueden comparar números, cadenas y objetos DateTime.

Si faltan ambos límites ([null, null]) o el valor es null, devuelve false.

Validators::isInRange(5, [0, 5]);     // true
Validators::isInRange(23, [null, 5]); // false
Validators::isInRange(23, [5]);       // true
Validators::isInRange(1, [5]);        // false

isNone(mixed $value): bool

Comprueba si el valor es 0, '', false o null.

Validators::isNone(0); // true
Validators::isNone(''); // true
Validators::isNone(false); // true
Validators::isNone(null); // true
Validators::isNone('nette'); // false

isNumeric(mixed $value): bool

Comprueba si el valor es un número o un número escrito en una cadena.

Validators::isNumeric(23);      // true
Validators::isNumeric(1.78);    // true
Validators::isNumeric('+42');   // true
Validators::isNumeric('3.14');  // true
Validators::isNumeric('nette'); // false
Validators::isNumeric('1e6');   // false

isNumericInt(mixed $value): bool

Comprueba si el valor es un número entero o un número entero escrito en una cadena.

Validators::isNumericInt(23);      // true
Validators::isNumericInt(1.78);    // false
Validators::isNumericInt('+42');   // true
Validators::isNumericInt('3.14');  // false
Validators::isNumericInt('nette'); // false

isPhpIdentifier(string $value): bool

Comprueba si el valor es un identificador sintácticamente válido en PHP, por ejemplo para nombres de clases, métodos, funciones, etc.

Validators::isPhpIdentifier('');        // false
Validators::isPhpIdentifier('Hello1');  // true
Validators::isPhpIdentifier('1Hello');  // false
Validators::isPhpIdentifier('one two'); // false

isBuiltinType(string $type): bool

Determina si $type es un tipo incorporado en PHP. De lo contrario, es el nombre de la clase.

Validators::isBuiltinType('string'); // true
Validators::isBuiltinType('Foo');    // false

isTypeDeclaration(string $type): bool

Comprueba si la declaración de tipo es sintácticamente correcta.

Validators::isTypeDeclaration('?string');      // true
Validators::isTypeDeclaration('string|null');  // true
Validators::isTypeDeclaration('Foo&Bar');      // true
Validators::isTypeDeclaration('(A&C)|null');   // true

Validators::isTypeDeclaration('?string|null'); // false
Validators::isTypeDeclaration('|foo');         // false
Validators::isTypeDeclaration('(A|B)');        // false

isClassKeyword(string $type): bool

Determine si $type es uno de los tipos internos self, parent, static.

Validators::isClassKeyword('self'); // true
Validators::isClassKeyword('Foo');  // false

isUnicode(mixed $value): bool

Comprueba si el valor es una cadena UTF-8 válida.

Validators::isUnicode('nette'); // true
Validators::isUnicode('');      // true
Validators::isUnicode("\xA0");  // false

isUrl(mixed $value): bool

Comprueba si el valor es una dirección URL válida.

Validators::isUrl('https://nette.org:8080/path?query#fragment'); // true
Validators::isUrl('http://localhost');            // true
Validators::isUrl('http://192.168.1.1');          // true
Validators::isUrl('http://[::1]');                // true
Validators::isUrl('http://user:pass@nette.org');  // false
Validators::isUrl('nette.org');                   // false

isUri(string $value): bool

Comprueba que el valor es una dirección URI válida, es decir, realmente una cadena que comienza con un esquema sintácticamente válido.

Validators::isUri('https://nette.org');           // true
Validators::isUri('mailto:gandalf@example.org');  // true
Validators::isUri('nette.org');                   // false