Validatori de valori

Aveți nevoie să verificați rapid și ușor dacă o variabilă conține, de exemplu, o adresă de e-mail validă? Atunci vă va fi de folos Nette\Utils\Validators, o clasă statică cu funcții utile pentru validarea valorilor.

Instalare:

composer require nette/utils

Toate exemplele presupun că este definit următorul alias de clasă:

use Nette\Utils\Validators;

Utilizare de bază

Clasa Validators are o serie de metode de validare a valorilor, cum ar fi isList(), isUnicode(), isEmail(), isUrl() etc., care pot fi utilizate în codul dumneavoastră:

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

În plus, aceasta poate verifica dacă valoarea satisface așa-numitele tipuri așteptate, care este un șir de caractere în care opțiunile individuale sunt separate de o bară verticală |. Acest lucru facilitează verificarea tipurilor de uniune folosind if():

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

Dar vă oferă, de asemenea, posibilitatea de a crea un sistem în care este necesar să scrieți așteptările sub formă de șiruri de caractere (de exemplu, în adnotări sau în configurare) și apoi să verificați în funcție de acestea.

De asemenea, puteți declara o aserțiune, care aruncă o excepție dacă nu este îndeplinită.

Tipuri de așteptări

Un tip așteptat este un șir de caractere format din una sau mai multe variante separate de o bară verticală |, similar to writing types in PHP (ie. 'int|string|bool'). Este permisă, de asemenea, o notație nulă ?int.

O matrice în care toate elementele sunt de un anumit tip se scrie sub forma int[].

Unele tipuri pot fi urmate de două puncte și de lungimea :length sau de intervalul :[min]..[max], de exemplu string:10 (un șir de caractere cu o lungime de 10 octeți), float:10.. (număr mai mare sau egal cu 10), array:..10 (matrice de până la zece elemente) sau list:10..20 (listă cu 10–20 de elemente), sau o expresie regulată pentru pattern:[0-9]+.

Prezentare generală a tipurilor și a regulilor:

Tipuri PHP
`array`	se poate da un interval pentru numărul de elemente
`bool`
`float`	se poate da un interval pentru valoarea
`int`	se poate indica intervalul pentru valoarea
`null`
`object`
`resource`
`scalar`	int\|float\|bool\|stringă
`string`	se poate indica intervalul pentru lungimea în octeți
`callable`
`iterable`
`mixed`
pseudo-tipuri
`list`	array indexat, se poate da un interval pentru numărul de elemente
`none`	valoare goală: `''`, `null`, `false`
`number`	int\|float
`numeric`	număr care include o reprezentare textuală
`numericint`	număr întreg, inclusiv reprezentare textuală
`unicode`	șir UTF-8, se poate da un interval pentru lungimea în caractere
clasa de caractere (nu poate fi un șir gol)
`alnum`	toate caracterele sunt alfanumerice
`alpha`	toate caracterele sunt litere `[A-Za-z]`
`digit`	toate caracterele sunt cifre
`lower`	toate caracterele sunt litere minuscule `[a-z]`
`space`	toate caracterele sunt spații
`upper`	toate caracterele sunt litere majuscule `[A-Z]`
`xdigit`	toate caracterele sunt cifre hexazecimale `[0-9A-Fa-f]`
validarea sintaxei
`pattern`	o expresie regulată cu care trebuie să se potrivească întregul șir de caractere
`email`	Email
`identifier`	Identificatorul PHP
`url`	URL
`uri`	URI
validarea mediului
`class`	este o clasă existentă
`interface`	este o interfață existentă
`directory`	este un director existent
`file`	este un fișier existent

Afirmație

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

Verifică dacă valoarea este de tipurile așteptate, separate prin pipe. În caz contrar, se aruncă o excepție Nette\Utils\AssertionException. Cuvântul variable din mesajul de excepție poate fi înlocuit cu parametrul $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

Verifică dacă elementul $key din array-ul $array este format din tipurile așteptate, separate prin pipe. În caz contrar, se aruncă excepția Nette\Utils\AssertionException. Șirul item '%' in array din mesajul de excepție poate fi înlocuit cu parametrul $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.

Validatori

is($value, string $expected): bool

Verifică dacă valoarea este formată din tipurile așteptate, separate prin pipe.

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

Verifică dacă valoarea este o adresă de e-mail validă. Nu se verifică dacă domeniul există cu adevărat, ci doar sintaxa. Funcția ia în calcul și viitoarele TLD-uri, care pot fi, de asemenea, în unicode.

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

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

Verifică dacă valoarea se află în intervalul dat [min, max], unde limita superioară sau inferioară poate fi omisă (null). Pot fi comparate numere, șiruri de caractere și obiecte DateTime.

În cazul în care ambele limite lipsesc ([null, null]) sau valoarea este null, se returnează 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

Verifică dacă valoarea este 0, '', false sau null.

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

isNumeric(mixed $value): bool

Verifică dacă valoarea este un număr sau un număr scris într-un șir de caractere.

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

Verifică dacă valoarea este un număr întreg sau un număr întreg scris într-un șir de caractere.

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

Verifică dacă valoarea este un identificator valid din punct de vedere sintactic în PHP, de exemplu pentru nume de clase, metode, funcții etc.

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

isBuiltinType(string $type): bool

Determină dacă $type este un tip încorporat în PHP. În caz contrar, este numele clasei.

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

isTypeDeclaration(string $type): bool

Verifică dacă declarația de tip este corectă din punct de vedere sintactic.

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

Determină dacă $type este unul dintre tipurile interne self, parent, static.

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

isUnicode(mixed $value): bool

Verifică dacă valoarea este un șir UTF-8 valid.

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

isUrl(mixed $value): bool

Verifică dacă valoarea este o adresă URL validă.

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

Verifică dacă valoarea este o adresă URI validă, adică, de fapt, un șir care începe cu o schemă validă din punct de vedere sintactic.

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

Nette Documentation Preview