Validadores de valor

Precisa verificar rápida e facilmente se uma variável contém, por exemplo, um endereço de e-mail válido? Então Nette\Utils\Validators virá a calhar, uma classe estática com funções úteis para a validação de valores.

Instalação:

composer require nette/utils

Todos os exemplos assumem que a seguinte classe está definida:

use Nette\Utils\Validators;

Utilização básica

A classe Validators tem vários métodos para validação de valores, tais como isList(), isUnicode(), isEmail(), isUrl(), etc., para uso em seu código:

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

Além disso, pode verificar se o valor satisfaz os chamados tipos esperados, que é um fio onde as opções individuais são separadas por uma barra vertical |. Isto facilita a verificação dos tipos de união utilizando if():

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

Mas também lhe dá a oportunidade de criar um sistema onde é necessário escrever as expectativas como cordas (por exemplo, em anotações ou configuração) e depois verificar de acordo com elas.

Você também pode declarar a afirmação, que lança uma exceção se não for cumprida.

Tipos Esperados

Um tipo esperado é uma cadeia que consiste em uma ou mais variantes separadas por uma barra vertical |, similar to writing types in PHP (ie. 'int|string|bool'). Notação nula também é permitida ?int.

Um array onde todos os elementos são de um certo tipo está escrito no formulário int[].

Alguns tipos podem ser seguidos por um cólon e o comprimento :length ou a faixa :[min]..[max]por exemplo string:10 (um fio com 10 bytes de comprimento), float:10.. (número 10 e maior), array:..10 (conjunto de até dez elementos) ou list:10..20 (lista com 10 a 20 elementos), ou uma expressão regular para pattern:[0-9]+.

Visão geral dos tipos e regras:

Tipos de PHP
`array`	intervalo para o número de itens pode ser dado
`bool`
`float`	intervalo para o valor pode ser dado
`int`	intervalo para o valor pode ser dado
`null`
`object`
`resource`
`scalar`	int	float	bool	string
`string`	o intervalo para o comprimento em bytes pode ser dado
`callable`
`iterable`
`mixed`
pseudo-tipos
`list`	matriz indexada, o intervalo para o número de itens pode ser dado
`none`	valor vazio: `''`	`null`, `false`
`number`	int\\	float
`numeric`	número incluindo representação textual
`numericint`	integer incluindo representação textual
`unicode`	Cordel UTF-8, o intervalo para o comprimento em caracteres pode ser dado
classe de caracteres (não pode ser uma corda vazia)
`alnum`	todos os caracteres são alfanuméricos
`alpha`	todos os caracteres são letras `[A-Za-z]`
`digit`	todos os caracteres são dígitos
`lower`	todos os caracteres são letras minúsculas `[a-z]`
`space`	todos os caracteres são espaços
`upper`	todos os caracteres são letras maiúsculas `[A-Z]`
`xdigit`	todos os caracteres são dígitos hexadecimais `[0-9A-Fa-f]`
validação da sintaxe
`pattern`	uma expressão regular que a string entire* deve combinar
`email`	Email
`identifier`	Identificador PHP
`url`	URL
`uri`	URI
validação do ambiente
`class`	é uma classe existente
`interface`	é a interface existente
`directory`	é um diretório existente
`file`	é um arquivo existente

Asserção

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

Verifica que o valor é do tipo esperado, separado por tubo. Caso contrário, lança a exceção Nette\Utils\AssertionException. A palavra variable na mensagem de exceção pode ser substituída pelo 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 o elemento $key na matriz $array é de tipos esperados separados por tubo. Caso contrário, ele lança a exceção Nette\Utils\AssertionException. A string item '%' in array na mensagem de exceção pode ser substituída pelo 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 se o valor é do tipo esperado, separado por tubo.

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 o valor é um endereço de e-mail válido. Não verifica que o domínio realmente existe, apenas a sintaxe é verificada. A função também conta com TLDs futuros, que também podem estar em unicode.

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

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

Verifica se o valor está na faixa determinada [min, max]onde o limite superior ou inferior pode ser omitido (null). Números, cordas e objetos DateTime podem ser comparados.

Se ambos os limites estiverem ausentes ([null, null]) ou o valor é null, ele retorna 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 se o valor é 0, '', false ou 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 se o valor é um número ou um número escrito em um fio.

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 se o valor é um número inteiro ou um número inteiro escrito em um fio.

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 se o valor é um identificador sintáctico válido em PHP, por exemplo, para nomes de classes, métodos, funções, etc.

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

isBuiltinType(string $type): bool

Determina se $type é do tipo PHP incorporado. Caso contrário, é o nome da classe.

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

isTypeDeclaration(string $type): bool

Verifica se a declaração de tipo está sintaticamente correta.

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

Determinar se $type é um dos tipos internos self, parent, static.

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

isUnicode(mixed $value): bool

Verifica se o valor é um fio UTF-8 válido.

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

isUrl(mixed $value): bool

Verifica se o valor é um endereço URL válido.

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 que o valor é um endereço URI válido, ou seja, na verdade, uma cadeia que começa com um esquema sintáctico válido.

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

Nette Documentation Preview