Walidatory wartości

Potrzebujesz szybko i łatwo sprawdzić, czy zmienna zawiera np. poprawny adres e-mail? To właśnie tam przydaje się Nette\Utils\Validators, statyczna klasa z przydatnymi funkcjami do sprawdzania poprawności wartości.

Instalacja:

composer require nette/utils

Wszystkie przykłady zakładają, że alias został utworzony:

use Nette\Utils\Validators;

Podstawowe zastosowanie

Klasa posiada szereg metod sprawdzających wartości, takich jak isList(), isUnicode(), isEmail(), isUrl (), itp. do wykorzystania w Twoim kodzie:

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

Może również sprawdzić, czy wartość jest oczekiwanym typem, który jest ciągiem, w którym opcje są oddzielone przez | slash. Możemy więc łatwo sprawdzić wiele typów używając if():

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

Ale daje nam również możliwość stworzenia systemu, w którym musimy napisać oczekiwania jako ciągi (na przykład w adnotacjach lub konfiguracji), a następnie zweryfikować wartości przeciwko nim.

Możemy również umieścić na oczekiwanych typach żądanie assert(), które rzuca wyjątek, jeśli nie jest spełnione.

Przewidywane rodzaje

Oczekiwane typy tworzą ciąg składający się z jednego lub więcej wariantów oddzielonych pionowym paskiem |, podobně jako se zapisují typy v PHP (např. 'int|string|bool'). Akceptowany jest również zapis zerowy ?int.

Tablica, w której wszystkie elementy są określonego typu, jest zapisywana jako int[].

Po niektórych typach może następować dwukropek i długość :length lub zakres :[min]..[max], np. string:10 (ciąg 10 bajtów), float:10.. (liczba 10 lub więcej), array:..10 (tablica do dziesięciu elementów) lub list:10..20 (lista od 10 do 20 elementów), lub wyrażenie regularne u pattern:[0-9]+.

Przegląd rodzajów i zasad:

PHP types
array można określić zakres dla liczby elementów
bool  
float można określić zakres dla wartości
int można określić zakres wartości
null  
object  
resource  
scalar int float bool string
string można określić zakres długości w bajtach      
callable        
iterable        
mixed        
pseudo-typów      
list tablica indeksowana, można określić zakres dla liczby elementów      
none wartość pusta: '', null, false      
number int float  
numeric liczba wraz z reprezentacją tekstową      
numericint liczba całkowita wraz z reprezentacją tekstową      
unicode UTF-8 ciąg, można określić zakres długości w znakach      
Klasa postaci (nie może być pustym ciągiem) .      
alnum wszystkie znaki są alfanumeryczne      
alpha wszystkie znaki to litery [A-Za-z]      
digit wszystkie znaki są cyframi      
lower wszystkie znaki są małymi literami [a-z]      
space wszystkie znaki są spacjami      
upper wszystkie znaki są wielkie [A-Z]      
xdigit wszystkie znaki są cyframi szesnastkowymi [0-9A-Fa-f]      
sprawdzanie składni        
pattern wyrażenie regularne, które musi pasować do całego łańcucha      
email E-mail      
identifier identyfikator PHP      
url URL      
uri URI      
uwierzytelnienie środowiska        
class jest istniejącą klasą      
interface to istniejący interfejs      
directory to istniejący katalog      
file to istniejący plik      

Asercja

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

Sprawdza, czy wartość jest jednym z oczekiwanych typów oddzielonych gwiazdką. Jeśli nie, rzuca wyjątek Nette\Utils\AssertionException. Słowo variable w tekście wyjątku może być zastąpione innym parametrem $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

Sprawdza, czy element pod kluczem $key w polu $array jest jednym z oczekiwanych typów oddzielonych odwrotnym ukośnikiem. Jeśli nie, rzuca wyjątek Nette\Utils\AssertionException. Ciąg item '%' in array w tekście wyjątku można zastąpić innym parametrem $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.

Walidatory

is($value, string $expected)bool

Sprawdza, czy wartość jest jednym z oczekiwanych typów oddzielonych gwiazdką.

Validators::is(1, 'int|float');  // true
Validators::is(23, 'int:0..10'); // false
Validators::is('Nette Framework', 'string:15');     // true, délka je 15 bytů
Validators::is('Nette Framework', 'string:8..');    // true
Validators::is('Nette Framework', 'string:30..40'); // false

isEmail(mixed $value): bool

Sprawdza, czy podana wartość jest prawidłowym adresem e-mail. Nie sprawdza, czy domena faktycznie istnieje, sprawdzana jest tylko składnia. Funkcja ta uwzględnia również przyszłe TLD, które mogą być w unicode.

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

isInRange(mixed $value, array $range)bool

Sprawdza czy wartość jest w podanym zakresie [min, max]gdzie górna lub dolna granica może być pominięta (null). Można porównywać liczby, ciągi znaków i obiekty DateTime.

Jeśli brakuje obu granic ([null, null]) lub wartość jest null, zwraca 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

Sprawdza, czy wartość to 0, '', false lub null.

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

isNumeric(mixed $value): bool

Sprawdza, czy wartość jest liczbą lub liczbą zapisaną w łańcuchu.

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

Sprawdza, czy wartość jest liczbą całkowitą lub liczbą zapisaną w łańcuchu.

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

Sprawdza czy wartość jest poprawnym składniowo identyfikatorem w PHP, na przykład dla nazw klas, metod, funkcji itp.

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

isBuiltinType(string $type)bool

Sprawdza, czy $type jest wbudowanym typem PHP. W przeciwnym razie jest to nazwa klasy.

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

isTypeDeclaration(string $type)bool

Sprawdza, czy podana deklaracja typu jest poprawna składniowo.

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

Sprawdza, czy $type jest jednym z typów wewnętrznych self, parent, static.

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

isUnicode(mixed $value): bool

Sprawdza, czy wartość jest prawidłowym ciągiem znaków UTF-8.

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

isUrl(mixed $value): bool

Sprawdza, czy wartość jest prawidłowym adresem URL.

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

Sprawdza, czy wartość jest prawidłowym adresem URI, który w rzeczywistości jest ciągiem rozpoczynającym się od poprawnego składniowo schematu.

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