Validadores de valor
********************

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


Instalação:

```shell
composer require nette/utils
```

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

```php
use Nette\Utils\Validators;
```


Utilização básica .[#toc-basic-usage]
=====================================

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

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

Além disso, pode verificar se o valor satisfaz os chamados [tipos esperados |#expected types], 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()]:

```php
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 |#assert], que lança uma exceção se não for cumprida.


Tipos Esperados .[#toc-expected-types]
======================================

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:

.[wide]
| Tipos de PHP |||
|--------------------------
| `array` .{width: 140px} | 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 |#isList], 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 |#isNumeric]
| `numericint`| [integer incluindo representação textual |#isNumericInt]
| `unicode` | [Cordel UTF-8 |#isUnicode], 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 |#isEmail]
| `identifier`| [Identificador PHP |#isPhpIdentifier]
| `url` | [URL |#isUrl]
| `uri` | [URI |#isUri]
|------------------------------------------------
| validação do ambiente |||
|------------------------------------------------
| `class` | é uma classe existente
| `interface` | é a interface existente
| `directory` | é um diretório existente
| `file` | é um arquivo existente


Asserção .[#toc-assertion]
==========================


assert($value, string $expected, string $label='variable'): void .[method]
--------------------------------------------------------------------------

Verifica que o valor é do [tipo esperado |#expected types], separado por tubo. Caso contrário, lança a exceção [api:Nette\Utils\AssertionException]. A palavra `variable` na mensagem de exceção pode ser substituída pelo parâmetro `$label`.

```php
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 .[method]
-----------------------------------------------------------------------------------------------------

Verifica que o elemento `$key` na matriz `$array` é de [tipos esperados |#expected types] separados por tubo. Caso contrário, ele lança a exceção [api:Nette\Utils\AssertionException]. A string `item '%' in array` na mensagem de exceção pode ser substituída pelo parâmetro `$label`.

```php
$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 .[#toc-validators]
==============================


is($value, string $expected): bool .[method]
--------------------------------------------

Verifica se o valor é do [tipo esperado |#expected types], separado por tubo.

```php
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 .[method]
-------------------------------------

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 |https://en.wikipedia.org/wiki/Top-level_domain] futuros, que também podem estar em unicode.

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


isInRange(mixed $value, array $range): bool .[method]
-----------------------------------------------------

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

```php
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 .[method]
------------------------------------

Verifica se o valor é `0`, `''`, `false` ou `null`.

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


isNumeric(mixed $value): bool .[method]
---------------------------------------

Verifica se o valor é um número ou um número escrito em um fio.

```php
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 .[method]
------------------------------------------

Verifica se o valor é um número inteiro ou um número inteiro escrito em um fio.

```php
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 .[method]
----------------------------------------------

Verifica se o valor é um identificador sintáctico válido em PHP, por exemplo, para nomes de classes, métodos, funções, etc.

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


isBuiltinType(string $type): bool .[method]
-------------------------------------------

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

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


isTypeDeclaration(string $type): bool .[method]
-----------------------------------------------

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

```php
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 .[method]
--------------------------------------------

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

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


isUnicode(mixed $value): bool .[method]
---------------------------------------

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

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


isUrl(mixed $value): bool .[method]
-----------------------------------

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

```php
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 .[method]
------------------------------------

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.

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