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