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? Para eso te será útil Nette\Utils\Validators, una clase estática con funciones útiles para la validación de valores.

Instalación:

composer require nette/utils

Todos los ejemplos asumen que se ha creado un alias:

use Nette\Utils\Validators;

Uso básico

La clase dispone de una serie de métodos para comprobar valores, como isUnicode(), isEmail(), isUrl(), etc., que puedes usar en tu código:

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

Además, puede verificar si un valor pertenece a los llamados tipos esperados, que es una cadena donde las diferentes opciones se separan con una barra vertical |. Así podemos verificar fácilmente múltiples tipos usando is():

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

Esto también nos da la opción de crear un sistema donde las expectativas se escriben como cadenas (por ejemplo, en anotaciones o configuración) y luego se usan para validar los valores.

También se puede aplicar una aserción a los tipos esperados usando assert(), que lanza una excepción si no se cumple.

Tipos esperados

Los tipos esperados forman una cadena que consta de una o más variantes separadas por una barra vertical |, de forma similar a como se escriben los tipos en PHP (p. ej., 'int|string|bool'). También se acepta la notación nullable ?int.

Un array donde todos los elementos son de un tipo determinado se escribe en la forma int[].

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

Resumen de tipos y reglas:

Aserciones

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

Verifica que el valor pertenezca a uno de los tipos esperados separados por barra vertical. Si no es así, lanza una excepción Nette\Utils\AssertionException. La palabra variable en el texto de la excepción se puede reemplazar por otra mediante 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 si el elemento con la clave $key en el array $array pertenece a uno de los tipos esperados separados por barra vertical. Si no es así, lanza una excepción Nette\Utils\AssertionException. La cadena item '%' in array en el texto de la excepción se puede reemplazar por otra mediante 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

Verifica si el valor pertenece a uno de los tipos esperados separados por barra vertical.

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

isEmail (mixed $value): bool

Verifica si el valor es una dirección de correo electrónico válida. No comprueba si el dominio existe realmente, solo verifica la sintaxis. La función también tiene en cuenta 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

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

Si faltan ambos límites ([null, null]) o si 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

Verifica 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

Verifica si el valor es un número o un número representado como 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

Verifica si el valor es un número entero o un entero representado como 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

Verifica 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

Comprueba si $type es un tipo incorporado (builtin) de PHP. En caso contrario, se asume que es un nombre de clase.

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

isTypeDeclaration (string $type): bool

Comprueba si la declaración de tipo dada es sintácticamente válida.

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

Comprueba si $type es una de las palabras clave internas self, parent, static.

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

isUnicode (mixed $value): bool

Verifica 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

Verifica 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

Verifica si el valor es una URI válida, es decir, 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