Téměř všechny interaktivní webové aplikace potřebují ověřovat vstup. Například registrační formulář bude pravděpodobně vyžadovat heslo pro potvrzení. Možná by e-mailová adresa měla být jedinečná. Prověřování pozadí může být těžkopádný proces. Naštěstí ne v Laravel. Třída Validator poskytuje úžasnou sadu validačních pomocníků, díky nimž je validace dat co nejjednodušší. Podívejme se na příklad:
Získání datového pole pro ověření:
$vstup = Input::all();Definování pravidel ověřování dat:
$rules = array("název" => "požadováno|max:50", "e-mail" => "požadováno|e-mail|unikátní:uživatelé",);Vytvoření instance Validator a ověření dat:
$validace = Validator::make($input, $pravidla); if ($validation->fails()) ( return $validation->errors; )Pokud existuje nemovitost chyby získáte přístup ke kolektoru zpráv, který vám umožní snadno vytvářet vlastní chybové zprávy. Všechna ověřovací pravidla mají samozřejmě ve výchozím nastavení chybové zprávy. Standardní chybové zprávy jsou in language/en/validation.php.
Nyní jste obeznámeni se základními pravidly pro používání třídy Validator. Jste připraveni prozkoumat a naučit se pravidla používaná k ověření vašich dat!
Pravidla ověřování
Povinné údaje
Kontrola požadované neprázdné hodnoty parametru:
"name" => "povinné"Alpha, Alpha Numeric a Alpha Dash
Kontrola pouze písmen:
"jméno" => "alfa"Kontrola pouze písmen a číslic:
"username" => "alpha_num"Zkontrolujte pouze písmena, čísla, pomlčky a podtržítka:
"username" => "alpha_dash"Velikost
Kontrola velikosti řetězce řetězcového atributu nebo rozsahu hodnot číselného atributu:
"name" => "size:10"Kontrola rozsahu hodnot:
"platba" => "mezi:10,50"Poznámka: V rozsahu je zahrnuto minimum a maximum.
Kontrola minimální velikosti atributu:
"platba" => "min:10"Kontrola maximální velikosti atributu:
"platba" => "max:50"Číselné typy
Kontrola, zda je atribut číselného typu:
"platba" => "číselná"Kontrola, zda je atribut celočíselného typu:
"platba" => "celé číslo"Výskyty a výluky
Kontrola atributu pro zahrnutí do pole hodnot:
"velikost" => "v:malém, středním, velkém"Kontrola atributu pro vyloučení z pole hodnot:
"language" => "not_in:cobol,assembler"potvrzení
Pravidlo potvrzeno zkontroluje, zda existuje odpovídající * atribut_confirmation * pro daný atribut.
Kontrola atributu pro potvrzení:
"heslo" => "potvrzeno"V tomto příkladu Validator zkontroluje, že parametr Heslo splňuje podmínky Potvrzení hesla z ověřovacího pole.
Přijetí
Pravidlo přijato kontroluje hodnotu parametru Ano nebo 1 . Toto pravidlo kontroluje instalaci povinných zaškrtávacích políček, jako je například zaškrtávací políčko „Podmínky služby“.
Přijímací kontrola:
"podmínky" => "přijato"Korespondence a rozdíly
Kontrola, zda je atribut stejný jako druhý porovnávaný atribut:
"token1" => "stejný:token2"Kontrola, zda má atribut jinou hodnotu:
"password" => "jiný:staré_heslo",Regulární výrazy
Pravidlo zápas zkontroluje, zda atribut odpovídá regulárnímu výrazu.
Kontrola spokojenosti s regulárním výrazem:
"username" => "match:/+/";Jedinečnost a existence
Kontrola jedinečnosti parametru v databázi:
"e-mail" => "unique:users"V tomto příkladu parametr e-mailem kontroluje jedinečnost v tabulce uživatelů. Potřebujete zkontrolovat jedinečnost atributu jiného sloupce, než je tento? Žádný problém:
Určení jiného sloupce ke kontrole:
"email" => "unique:users,email_address"Při aktualizaci záznamu budete často muset použít jedinečné pravidlo, ale vylučte aktualizovaný záznam. Chcete například umožnit uživatelům změnit jejich e-mailové adresy. Ale když pravidlo platí unikátní, musíte tohoto uživatele přeskočit, abyste nezpůsobili imaginární chybu ověření. Je to jednoduché:
Ignorování zadaného ID:
"email" => "unique:users,email_address,10"Kontrola přítomnosti atributu v zadané databázi:
"state" => "exists:states"Zadání názvu sloupce pro existující pravidlo:
"state" => "exists:states,zkratka"Termíny
Kontrola, zda má parametr datum hodnotu před...:
"datum narození" => "před:1986-28-05";Kontrola, zda má parametr datum hodnotu po...:
"datum narození" => "po:1986-28-05";Poznámka: Zkouška před A po používá funkci PHP strtotime.
Emailová adresa
Kontrola, zda je parametrem e-mailová adresa:
"adresa" => "e-mail"Poznámka: Toto pravidlo používá vestavěnou metodu PHP filtr_var.
URL
Kontrola, zda je parametr adresa URL:
"link" => "url"Kontrola, zda je parametr aktivní URL:
"link" => "active_url"Poznámka: Pravidlo aktivní_url používá checkdnsr zkontrolujte, zda je adresa URL aktivní.
Stahování
Pravidla mimy zkontrolujte, zda stažený soubor odpovídá typu MIME. Toto pravidlo používá rozšíření PHP Fileinfo ke kontrole obsahu souboru a určení jeho typu. Všechny přípony souborů, které se vztahují na toto pravidlo, jsou definovány v config/mimes.php.
Kontrola, zda soubor patří ke konkrétnímu typu:
"obrázek" => "mimes:jpg,gif"Poznámka: Při kontrole nezapomeňte použít Input::file() nebo Input::all().
Kontrola, zda je soubor obrázkem:
"obrázek" => "obrázek"Kontrola velikosti souboru:
"picture" => "image|max:100"Vyžádejte si chybovou zprávu
Laravel vám umožňuje zpracovávat chybové zprávy pomocí jednoduché třídy zvané kolektor chyb. Po volání metod projde nebo selže Instance Validator, můžete k chybě přistupovat pomocí vlastnosti chyby. Kolektor chyb má jednoduché funkce pro dotazování na chybové zprávy:
Určení, že atribut obsahuje chybovou zprávu:
if ($validation->errors->has("email")) ( // Atribut e-mail obsahuje chyby... )Dotaz na první chybovou zprávu pro atribut:
echo $validace->chyby->prvni("e-mail");Možná budete muset zabalit chybovou zprávu do značek HTML. Žádný problém. Při volání :message place-holder zadejte formát jako druhý parametr metody.
Formátování chybové zprávy:
echo $validation->errors->first("e-mail", "");Získání všech chybových zpráv pro atribut:
$messages = $validace->chyby->get("e-mail");Formátování všech chybových zpráv pro atribut:
$messages = $validace->chyby->get("e-mail", "");Získání všech chybových zpráv pro všechny atributy:
$messages = $validace->chyby->vse();Formátování všech chybových zpráv pro všechny atributy:
$messages = $validace->chyby->all("");Absolvování ověření
Jakmile provedete ověření, potřebujete jednoduchý způsob, jak zobrazit chyby v zobrazení. Laravel to velmi usnadňuje. Podívejme se na typický scénář. To lze definovat dvěma způsoby:
Route::get("register", function() ( return View::make("user.register"); )); Route::post("register", function() ( $rules = array(...); $validation = Validator::make(Input::all(), $rules); if ($validation->fails( )) ( return Redirect::to("register")->with_errors($validation); ) ));
Skvělý! Máme tedy dvě jednoduché cesty pro registrační formulář. Jeden pro zpracování zobrazení formuláře a jeden pro zpracování zadávání formuláře. V cestě POST provádíme nějaké kontroly na vstupu. Pokud se ověření nezdaří, přesměrujeme vás zpět na registrační formulář s uvedením chyb a jejich zobrazením ve formuláři.
Všimněte si však, že chyby explicitně nepřiřazujeme k cíli v naší trase GET. Chybová proměnná však bude k dispozici v pohledu. Laravel inteligentně detekuje, zda jsou v relaci chyby, a pokud ano, připojí zprávy k pohledu. Pokud nejsou žádné chyby, prázdný kontejner chybových zpráv bude stále připojen k pohledu. V zobrazení bude vždy k dispozici kontejner chybových zpráv. Rádi vám usnadňujeme život.
Vlastní chybové zprávy
Chcete použít vlastní chybovou zprávu? Můžete dokonce chtít použít vlastní chybové zprávy pro daný atribut a pravidlo. Ať tak či onak, třída Validator to usnadňuje.
Vytvoření pole vlastních chybových zpráv pro Validator:
$messages = array("required" => "Pole:attribute je povinné.",); $validace = Validátor::make(Input::get(), $pravidla, $zprávy);Skvělý! Nyní budou při ověřování vždy použity naše vlastní zprávy. Ale jaký výraz :atribut v naší zprávě. Abychom vám usnadnili život, nahrazuje třídu Validator :atribut na atribut, jehož vstup způsobil chybu. Dokonce odstraní podtržítko z názvu atributu. Můžete také použít :jiný, :velikost, :min, : max, A :hodnoty zástupné symboly pro vytváření chybových zpráv.
Příklady vlastních chybových zpráv:
$messages = array("same" => "The:atribute a:other se musí shodovat.", "size" => "The:atribute musí být přesně:size.", "between" => "The:attribute musí být mezi:min - :max.", "in" => "Atribut: musí být jednoho z následujících typů: :values",);Co když potřebujete definovat požadovanou zprávu, ale pouze pro atribut e-mailu? Žádný problém. Stačí zadat zprávu pomocí atribut_rule pojmenování:
Definování zprávy pro konkrétní atribut:
$messages = array("email_required" => "Potřebujeme znát vaši e-mailovou adresu!",);V tomto příkladu bude vlastní chybová zpráva použita pouze pro atribut email, jinak budou použity standardní zprávy.
Pokud zároveň používáte hodně vlastních chybových zpráv, uvedení všech v kódu může být těžkopádné a nepohodlné. Z tohoto důvodu je možné definovat vlastní pole v jazykovém souboru:
Přidání vlastního pole do jazykového souboru:
"custom" => array("email_required" => "Potřebujeme znát vaši e-mailovou adresu!",)Vlastní validační pravidla
Laravel poskytuje řadu účinných ověřovacích pravidel. Můžete si však vytvořit vlastní. Existují dva jednoduché způsoby, jak vytvořit ověřovací pravidla. Oba jsou spolehlivé při používání. Stačí si jen vybrat ten, který je pro váš projekt vhodnější.
Registrace vlastního ověřovacího pravidla:
Validator::register("awesome", function($attribute, $value, $parameters) ( return $value == "awesome"; }); !}V tomto příkladu jsme zaregistrovali nová ověřovací pravidla pro třídu Validator. Toto pravidlo má tři parametry. První je název kontrolovaného atributu, druhý je hodnota kontrolovaného atributu a třetí je pole parametrů, které byly pro pravidlo zadány.
Takto vypadá vaše volání pravidla:
$rules = array("username" => "povinné|úžasné",);
Pro nové pravidlo je samozřejmě potřeba definovat chybovou zprávu. Můžete to udělat buď ve speciálních zprávách pole:
$messages = array("awesome" => "Hodnota atributu musí být úžasná!",); $validator = Validator::make(Input::get(), $rules, $messages);
nebo přidáním položky pro pravidlo v language/en/validation.php:
"awesome" => "Hodnota atributu musí být úžasná!",
Jak bylo uvedeno výše, můžete dokonce zadat a získat seznam parametrů ve vlastním pravidle:
// Při vytváření pravidla... $rules = array("username" => "required|awesome:yes",); // V pravidle... Validator::register("awesome", function($attribute, $value, $parameters) ( return $value == $parameters; )
V tomto příkladu parametr arguments vašeho ověřovacího pravidla obdrží pole obsahující jeden prvek: "yes".
Dalším způsobem, jak vytvořit a uložit vlastní ověřovací pravidla, je rozšířit třídu Validator. Navíc díky jmenným prostorům v Laravelu se tato třída může sama rozšířit. Tím vytvoříte novou verzi validátoru, která má všechny dříve existující funkce kombinované s novými doplňky. Pokud chcete, můžete se dokonce rozhodnout nahradit některé z výchozích metod. Podívejme se na příklad:
Nejprve vytvořte třídu Validátor která zdědí třídu Laravel\Validator a umístěte jej aplikace/knihovny:
Definování vlastní třídy:
Nyní přidejte naše „úžasné“ pravidlo a definujte jej v nové třídě:Přidání nového pravidla:
Všimněte si, že metoda validate_awesom je pojmenována podle konvence pojmenování. Tito. pro pravidlo „awesome“ musí být metoda pojmenována „validate_awesome“. Toto je jeden z mnoha způsobů, jak rozšířit třídu Validator. Třída Validator jednoduše vyžaduje, aby byla vrácena hodnota "true" nebo "false". To je vše!Mějte na paměti, že stále musíte vytvořit vlastní zprávu pro ověřovací pravidla, která vytvoříte. Způsob, jak toho dosáhnout, je také nezávislý na tom, jak definujete pravidla!
Při vytváření webových aplikací je důležité brát bezpečnost vážně, zvláště když se musíte potýkat se získáváním dat od uživatelů.
Obecným bezpečnostním pravidlem je nedůvěřovat nikomu, takže se nemůžete spoléhat na to, že uživatelé budou do formulářů vždy zadávat správné hodnoty. Například místo správné e-mailové adresy do pole může uživatel zadat nesprávnou adresu nebo dokonce nějaká škodlivá data.
Pokud jde o ověřování uživatelských dat, lze to provést buď na straně klienta (ve webovém prohlížeči) nebo na straně serveru.
Dříve bylo možné ověření na straně klienta provádět pouze pomocí JavaScriptu. Vše se ale změnilo (nebo téměř změnilo), protože pomocí HTML5 lze validaci provádět v prohlížeči, bez nutnosti psát složité ověřovací skripty v JavaScriptu.
Ověření formuláře pomocí HTML5
HTML5 poskytuje poměrně robustní mechanismus založený na následujících atributech značek : typ , vzor a požadavek . S těmito novými atributy můžete přesunout některé funkce ověřování dat do prohlížeče.
Podívejme se na tyto atributy, abychom pochopili, jak mohou pomoci s ověřováním formuláře.
atribut typu
Tento atribut říká, které vstupní pole se má zobrazit pro zpracování dat, například známé pole
Některá vstupní pole již poskytují standardní metody ověření, aniž by bylo nutné psát další kód. Například, zkontroluje pole, aby se ujistil, že zadaná hodnota odpovídá šabloně platné e-mailové adresy. Pokud je do pole zadán nesprávný znak, nelze formulář odeslat, dokud nebude hodnota opravena.
Zkuste si pohrát s hodnotami pole e-mailu v ukázce níže.
Existují také další standardní typy polí, např , A pro ověřování čísel, adres URL a telefonních čísel.
Poznámka: Formáty telefonních čísel se v jednotlivých zemích liší kvůli rozdílům v počtu číslic v telefonních číslech a rozdílům ve formátech. V důsledku toho specifikace nedefinuje algoritmus pro kontrolu telefonních čísel, takže v době psaní tohoto článku je tato funkce v prohlížečích špatně podporována.
Naštěstí pro nás lze ověření telefonního čísla provést pomocí atributu pattern, který bere regulární výraz jako argument, na který se podíváme dále.
atribut vzoru
Atribut vzor pravděpodobně způsobí, že mnoho vývojářů front-endu poskočí radostí. Tento atribut přijímá regulární výraz (podobný formátu JavaScript regulárního výrazu), který bude použit ke kontrole správnosti údajů zadaných do pole.
Regulární výrazy jsou jazyk používaný k analýze a manipulaci s textem. Často se používají pro složité operace vyhledávání a nahrazování a také pro kontrolu správnosti zadaných údajů.
Dnes jsou regulární výrazy obsaženy ve většině oblíbených programovacích jazyků a také v mnoha skriptovacích jazycích, editorech, aplikacích, databázích a nástrojích příkazového řádku.
Regulární výrazy (RegEX) jsou výkonným, stručným a flexibilním nástrojem pro porovnávání řetězce textu, jako jsou jednotlivé znaky, slova nebo vzory znaků.
Předáním regulárního výrazu jako hodnoty atributu pattern můžete určit, jaké hodnoty jsou přijatelné pro dané vstupní pole, a také informovat uživatele o chybách.
Podívejme se na několik příkladů použití regulárních výrazů k ověření hodnoty vstupních polí.
Telefonní čísla
Jak již bylo zmíněno dříve, typ pole tel není plně podporován prohlížeči kvůli nekonzistencím ve formátech telefonních čísel v různých zemích.
Například v některých zemích je formát telefonních čísel reprezentován jako xxxx-xxx-xxxx a samotné telefonní číslo bude vypadat takto: 0803-555-8205 .
Regulární výraz, kterému tento vzor odpovídá, je: ^\d(4)-\d(3)-\d(4)$ . V kódu to lze zapsat takto:
Alfanumerické hodnoty
povinný atribut
Toto je booleovský atribut používaný k označení, že hodnota daného pole musí být vyplněna, aby bylo možné formulář odeslat. Když přidáte tento atribut do pole, prohlížeč bude vyžadovat, aby uživatel toto pole před odesláním formuláře vyplnil.
To nám ušetří implementaci ověřování pole pomocí JavaScriptu, což může vývojářům ušetřit čas.
Například: nebo (pro kompatibilitu s XHTML)
Všechny ukázky, které jste viděli výše, používají požadovaný atribut, takže si to můžete vyzkoušet tak, že se pokusíte odeslat formulář bez vyplňování jakýchkoli polí.
Závěr
Podpora prohlížeče pro ověřování formulářů je docela dobrá a pro starší prohlížeče můžete použít polyfilly.
Stojí za zmínku, že spoléhat se pouze na ověření na straně prohlížeče je nebezpečné, protože tyto kontroly mohou útočníci nebo roboti snadno obejít.
Ne všechny prohlížeče podporují HTML5 a ne všechna data odeslaná do vašeho skriptu pocházejí z vašeho formuláře. To znamená, že před konečným přijetím dat od uživatele je nutné zkontrolovat jejich správnost na straně serveru.
Zde v tomto příspěvku uvidíme, jak ověřit telefonní číslo v PHP. V mnoha situacích potřebují weboví vývojáři ověřit telefonní číslo odeslané prostřednictvím formuláře.
V těchto případech tedy musíme potvrdit, že zadané telefonní číslo je v platné struktuře nebo vzoru.
Ověření telefonního čísla v PHP není těžký úkol. Uděláme to jednoduchým a snadným způsobem.
Všichni víme, že telefonní číslo je obecně 10místné číslo. Může se ale vyskytnout mnoho výjimečných případů, a proto nestačí pouze zkontrolovat, zda je číslo celé číslo o délce 10.
Někdy může uživatel zadat číslo s kódem země nebo někdy se znakem „+“ před kódem země. Může to tedy vypadat jako složitější úkol na ověření.
Ale nebojte se. Zde získáte připravenou k použití funkci PHP, která obsahuje pouze několik řádků kódu.
Zde v tomto příspěvku vám ukážeme příklad kódu, který udělá náš úkol.
Vytvoříme funkci, kterou lze použít k ověření mobilního čísla. Níže je uveden kód funkce:
Funkce validate_phone_number($phone) ( // Povolit +, - a . v telefonním čísle $filtered_phone_number = filter_var($phone, FILTER_SANITIZE_NUMBER_INT); // Odebrat "-" z čísla $phone_to_check = str_replace("-", "", $ filter_phone_number); // Zkontrolujte délku čísla // Toto lze upravit, pokud chcete telefonní číslo z konkrétní země, pokud (strlen($phone_to_check)< 10 || strlen($phone_to_check) >14) ( return false; ) else ( return true; ) )
Výše uvedená funkce bude mít jako parametr telefonní číslo. Uvnitř funkce jsme z čísla odstranili všechny nepovolené znaky, takže přijímá pouze „+“, „-“ a „.“ pomocí filtru FILTER_SANITIZE_NUMBER_INT. Můžete si všimnout, že telefonní číslo může být napsáno v tomto formátu – v mnoha případech +91-523-452-5555. Proto jsme v telefonním čísle povolili „+“ a „-“.
Poté jsme pomocí PHP funkce str_replace odstranili „-“ z telefonního čísla.
Poté jsme zkontrolovali délku a vrátili hodnotu true nebo false v závislosti na délce. Můžete si všimnout, že délka by měla být mezi 10 až 14. Je to proto, že číslo má obecně 10 znaků a s kódem země to může být až 14.
Nyní níže je použití funkce, kterou jsme právě vytvořili:
$telefon = "+91-444-444-5555"; if (validate_phone_number($phone) == true) ( echo "Telefonní číslo je platné"; ) else ( echo "Neplatné telefonní číslo"; )
Výše uvedený kód vrátí „Telefonní číslo je platné“, protože vrátí hodnotu true. Pokud by to bylo nepravdivé, vrátilo by to „Neplatné telefonní číslo“.
Jak to tedy bylo? Právě jsme viděli ověření mobilního čísla v PHP.
Líbil se vám tento příspěvek? Dejte mi prosím vědět, pokud chcete nějaké vylepšení kódu pro ověření telefonního čísla pomocí PHP.
V minulém článku jsem slíbil, že napíšu srovnání vlastní knihovny s jinými dostupnými řešeními, takže se dnes podíváme na validaci pomocí Aura.Filter, Respect Validation, Sirius Validation a Valitron.
Představme si, že máme ve vývoji určitou veřejnou službu, která vyžaduje registraci uživatelů pro plný přístup ke všem funkcím. Registrační formulář tedy bude obsahovat následující pole:
- název. Musí obsahovat přesně dvě slova, kde první je křestní jméno uživatele a druhé je příjmení.
- přihlásit se. Pokud je hodnota předána, musí obsahovat pouze latinská písmena, pomlčky a podtržítka.
- e-mailem. Musí obsahovat platnou e-mailovou adresu.
- Heslo. Musí být nastaveno a nesmí být delší než 64 znaků.
- souhlasil. Typické zaškrtávací políčko, které musí uživatel zaškrtnout, aby potvrdil přijetí podmínek služby.
Máme tedy pět polí, která musí uživatel vyplnit, aby se mohl zaregistrovat do naší imaginární služby. Představme si, že jsme jako vstup obdrželi zcela neplatná data:
$data = [ "jméno" => "Albert", // Musí být dvě slova "login" => "@lbert", // "Zakázán" znak @ "e-mail" => "něco není v pořádku", / / Mělo by to být být e-mailové "heslo" =>
Aura.Filtr
Ověření pomocí Aura.Filter začíná továrnou na filtry. Musíme vytvořit takzvaný „filter předmětu“, protože budeme ověřovat pole, nikoli jednotlivou hodnotu.
Definování pravidel
použijte Aura\Filter\FilterFactory; $filter = (new FilterFactory)->newSubjectFilter(); $filter->validate("name") ->isNotBlank() ->is("dve_slova") ->setMessage("Jméno musí obsahovat dvě slova."); $filter->validate("login") ->isBlankOr("alnum") ->setMessage("Pokud zadáte přihlašovací jméno, musí obsahovat pouze latinské znaky."); $filter->validate("email") ->isNotBlank() ->is("e-mail") ->setMessage("Zadejte prosím platnou e-mailovou adresu."); $filter->validate("heslo") ->isNotBlank() ->is("strlenMax", 64) ->setMessage("Napište prosím své heslo."); $filter->validate("agreed") ->is("callback", function($subject, $field) ( return $subject->($field) === true; ))->setMessage("Potřebujete souhlas s podmínkami služby.");Jak vidíte, popis pravidel je celkem jednoduchý. Aura.Filter poskytuje celou sadu užitečných pravidel a některá z nich byla použita ve výše uvedeném příkladu:
- metoda isNotBlank. Určuje, že pole nemůže mít hodnotu null.
- alnum. Toto pravidlo povoluje pouze latinská písmena.
- e-mailem. A je to tak jasné :)
- strlenMax. Určuje, že pole nemůže přesáhnout délku určenou druhým argumentem metody is.
- zpětné volání. Tento typ pravidel je podobný uzávěrům od Kontrolio. Umožňuje definovat pravidlo ve formě uzávěrky. K tomuto uzavření předává Aura.Filter „předmět“, naše pole dat z formuláře a pole, v tomto případě odsouhlasené .
Pravděpodobně jste si všimli, že jsem nespecifikoval pravidlo dvou_slov. Přirozeně v Aura.Filter žádné takové pravidlo neexistuje, takže je musíme vytvořit. Jak říká dokumentace, toto se provádí pomocí samostatné třídy pro pravidlo:
/** * Pravidlo, které ověřuje uživatelské jméno. * Uživatelské jméno se skládá ze dvou slov: jména a příjmení, oddělených jednou mezerou. */ class UserNameRule ( /** * Ověřuje uživatelské jméno. * * @param object|array $subject * @param string $field * @param int $max * * @return bool */ public function __invoke($subject, $field , $max = null) ( $value = $subject->($field); if (! is_scalar($value)) ( return false; ) return (bool) preg_match("/^+\s+$/u", $value); ))
Druhým krokem je informovat továrnu na filtry o našem novém pravidle. To se provádí předáním prvního argumentu jako pole pravidel do továrny filtrů:
Dalším krokem je upozornit Aura.Filter, že jsme vytvořili nové pravidlo a chceme je použít. To se provádí předáním řady pravidel prvnímu argumentu továrny:
použijte Aura\Filter\FilterFactory; $rules = [ "dvě_slova" => function() ( return new UserNameRule; ) ]; $filtr = (new FilterFactory($rules))->newSubjectFilter();
Nyní lze naše pravidlo two_words použít stejným způsobem jako jakékoli jiné standardní pravidlo.
Zpětná vazba
Jak si pamatujete, příchozí data, která ověřujeme, jsou zcela neplatná, protože každé pole obsahuje nesprávnou hodnotu nebo ji neobsahuje vůbec. Proto se předpokládá, že v důsledku validace obdržíme chyby a odpovídající zprávy o nich.
Ověřujeme pomocí Aura.Filter následovně:
$platný = $filtr->použít($data); if (! $valid) ( $failures = $filter->getFailures(); $messages = $failures->getMessages(); )
V $messages se zapisuje pole, takže k zobrazení zpráv potřebujeme dvě vnořené foreach:
-
$errors) ( foreach ($errors jako $error) ( printf("", $error); ) ) ?>
Ověření respektu
Druhá knihovna, kterou jsem ve srovnání použil, je poměrně oblíbené řešení s názvem Respect Validation. Jelikož jí lidé důvěřují, myslím, že je tam co vidět.
Pro čistotu experimentu při porovnávání knihoven použijeme stejný soubor dat definovaný na začátku:
použijte Respect\Validation\Validator jako v; $data = [ "jméno" => "Albert", // Musí být dvě slova "login" => "@lbert", // "Zakázán" znak @ "e-mail" => "něco není v pořádku", / / Mělo by to být být zde e-mail "password" => "" // Heslo není vůbec zadáno // "agreed" není v poli, protože uživatel nezaškrtl políčko ];
Definování pravidel
Stejně jako u Aura.Filter potřebujeme vlastní ověřovací pravidlo pro uživatelské jméno, takže začněme tím:
jmenný prostor MyNamespace; použijte Respekt\Validation\Pravidla\AbstractRule; class UserNameRule rozšiřuje AbstractRule ( public function validate($input) ( return (bool) preg_match("/^+\s+$/u", $input); ) )
API externích pravidel je téměř totožné s Aura.Filter, používá se pouze metoda ověřit() místo magie __invoke(). Zdálo se mi toto API jednodušší a srozumitelnější. No, je to blíž Kontrolio :)
V dokumentaci jsem o tom nenašel žádnou zmínku, nicméně kromě samotného pravidla je pro něj potřeba vytvořit vlastní typ výjimky. Název třídy výjimky se musí skládat z názvu třídy pravidla a přípony Výjimka.
použijte Respect\Validation\Exceptions\NestedValidationException; class UserNameRuleException rozšiřuje NestedValidationException ( // )
No, konečně můžeme ověřit naše data. Nejprve předáme naše nové pravidlo validátoru, aby o něm věděl a my ho mohli použít v budoucnu. V Respect Validation se to provádí voláním metody s() s přenosem jmenného prostoru, ve kterém se nacházejí nestandardní pravidla.
v::with("MyNamespace\\");
Nyní jsou všechna nestandardní pravidla umístěna ve jmenném prostoru Můj jmenný prostor, bude validátorem „rozpoznán“. Dalším krokem je popsání nezbytných pravidel a provedení validace.
v::attribute("name", v::userNameRule()) ->attribute("login", v::alnum("-_")) ->attribute("e-mail", v::email()) ->attribute("password", v::notEmpty()->stringType()->length(null, 64)) ->attribute("agreed", v::trueVal()) ->assert((object) $data);
Všimněte si, jak aplikujeme naše pravidlo na atribut název. Zde byl název třídy pravidla transformován na název metody validátoru. Zbývající pravidla jsou obecně intuitivní.
Samostatně stojí za zmínku, proč poskytujeme pole $data k objektu. Faktem je, že Respect Validation přijímá jako vstup objekty, nikoli pole. To je třeba vzít v úvahu při vývoji pomocí této knihovny.
Zpětná vazba
Na rozdíl od Aura.Filter validátor Respect vyvolá výjimku, když se ověření nezdaří. A tato výjimka obsahuje chybové zprávy ověření. Proto by měl být právě ukázaný příklad zapsán následovně:
try ( v::with("RespectValidationExample\\"); v::attribute("name", v::userNameRule()) ->attribute("login", v::alnum("-_")) - >attribute("e-mail", v::email()) ->attribute("heslo", v::notEmpty()->stringType()->length(null, 64)) ->attribute("souhlasím", v::trueVal()) ->assert((objekt) $data); ) catch (NestedValidationException $ex) ( $messages = $ex->getMessages(); )
Použitím getMessages(), získáme ploché pole všech zpráv, které validátor shromáždil během procesu validace. Vyprázdněním pole získáme něco takového:
array(5) ( => string(29) “Ověření dat selhalo pro %s” => string(60) “přihlášení musí obsahovat pouze písmena (a–z), číslice (0–9) a “-_”” => řetězec (25) “email musí být platný email” => string(26) “heslo nesmí být prázdné” => string(32) “Atribut musí být přítomen” )
Zprávy můžete změnit na své vlastní. Možná jsem tuto knihovnu nějak špatně pochopil, ale tento proces se mi nezdál tak zřejmý: musíte použít metodu findMessages() na zpracovanou výjimku, kde nedefinujete zprávy pro atributy, ale pro pravidla.
$ex->findMessages([ "userNameRule" => "Uživatelské jméno se musí skládat ze dvou slov.", "alnum" => "Nelíbí se nám vaše přihlašovací údaje.", "email" => "Zjevně se vám nelíbí chcete nám dát svůj e-mail.", "notEmpty" => "No, kde je vaše heslo?", "souhlasil" => "Škoda, že nesouhlasíte." ]);
Nevím, co se děje, ale je tu pár věcí, kterým stále nerozumím. To je to, co získáme definováním pravidel výše uvedeným způsobem:
array(5) ( => string(40) “Uživatelské jméno musí obsahovat dvě slova.” => string(31) “Nelíbí se nám vaše přihlášení.” => string(25) “e-mail musí být platný email” = > string(5) “No, kde je tvoje heslo?” => string(9) “Škoda, že nesouhlasíš.” )
Jak vidíte, zpráva pro pole email nebyla aplikována, zůstala standardní. Ale zpráva na indexu 4 je opačná! A to přesto, že jsem nepoužil název pravidla, ale název pole. Zatímco kdybych použil název pravidla (trueVal), moje zpráva by se někde ztratila. Připomínky zkušených uživatelů této knihovny jsou velmi vítány.
Ověření Sirius
Dobře, přejdeme k další knihovně a uvidíme, jak zvládá podobné úkoly.
Definování pravidel
Ještě jednou musíme definovat pravidlo pro uživatelské jméno. Napíšeme to nějak takto:
class UserNameRule rozšiřuje AbstractRule ( // Error Messages const MESSAGE = "Uživatelské jméno musí obsahovat dvě slova."; const LABELED_MESSAGE = "(štítek) musí obsahovat dvě slova."; public function validate($value, $valueIdentifier = null ) ( return (bool) preg_match("/^+\s+$/u", $value); ) )
Vezměte prosím na vědomí rozdíl v přístupech ve srovnání s knihovnami, které již byly probrány. Spíše než pomocí vlastností, metod nebo argumentů pravidel definujeme dva druhy zpráv v konstantách.
Nyní popišme logiku ověření:
$validator = nový Validátor; $validator ->add("jméno", "povinné | MojeAplikace\Validace\Pravidlo\UserNameRule") ->add("login", "povinné | alphanumhyphen", null, "Přihlášení může obsahovat pouze latinská písmena, pomlčky a podtržítka. ") ->add("e-mail", "vyžadováno | e-mail", null, "Zadejte prosím správný e-mail.") ->add("heslo", "požadováno | maxlength(64)", null, "Váš heslo, pane.") ->add("souhlasím", "požadováno | rovná se(pravda)", null, "Proč jste nesouhlasil?");
Jak vidíte, sada pravidel je velmi jednoduchá a čitelná. Pro popis používáme názvy oddělené vodorovnými pruhy. Tento přístup je podobný jako v Laravel a Kontrolio.
Argument čtvrté metody přidat() popisuje chybovou zprávu ověření, kterou Sirius použije, pokud ověření selže. Proč jsme nepřidali zprávu pro naše nové pravidlo? UserNameRule?
$validator->add("name", "required | MyApp\Validation\Rule\UserNameRule")
Je to proto, že zprávy jsou již popsány v konstantách třídy:
class UserNameRule rozšiřuje AbstractRule ( // Chybové zprávy const MESSAGE = "Uživatelské jméno musí obsahovat dvě slova."; ...
Další možností je použít metodu addMessage() samotného validátoru:
$validator->addMessage("e-mail", "Zadejte prosím platný e-mail.");
Vezměte prosím na vědomí, že vlastní pravidla jsou identifikována úplným názvem jejich třídy, zatímco v Kontrolio můžete zadat alias/alias.
Zpětná vazba
Pro provedení validace voláme metodu validátoru ověřit(), předávání dat do něj:
$data = [ "jméno" => "Albert", // Musí být dvě slova "login" => "@lbert", // "Zakázán" znak @ "e-mail" => "něco není v pořádku", / / Mělo by to být být zde e-mail "password" => "" // Heslo není vůbec zadáno // "agreed" není v poli, protože uživatel nezaškrtl políčko ]; $validator->validate($data);
Na rozdíl od Respektu Sirius nevyhodí výjimku, ale jednoduše se vrátí Nepravdivé. Pomocí metody validátoru lze přijímat chybové zprávy ověření getMessages(). Vrací chyby seskupené podle atributů, takže potřebujeme dvě smyčky foreach, abychom chyby prošli:
foreach ($validator->getMessages() jako $attribute => $messages) ( foreach ($messages jako $message) ( echo $message->getTemplate() . "\n"; ) )
Zde je $message objekt třídy Sirius\Validation\ErrorMessage, která má metodu getTemplate(), vracíme přesně tu zprávu, kterou potřebujeme.
Valitron
Definování pravidel
První rozdíl: pro přidání nového pravidla nemusíte vytvářet samostatnou třídu. Můžete jednoduše použít uzávěr, který vrátí booleovský výsledek.
Pro přidání vlastních pravidel ve Valitronu existuje statická metoda addRule(), ve kterém jsou první dva argumenty povinné a třetí je volitelný. Tato metoda se mi líbila, protože zobrazuje identifikátor pravidla, logiku a chybovou zprávu na jednom místě.
použijte Valitron\Validator; Validator::addRule("dvě_slova", function($field, $value) (return (bool) preg_match("/^+\s+$/u", $value); ), "Uživatelské jméno se musí skládat přesně z dvě slova ");
Druhý rozdíl je v tom, jak jsou pravidla aplikována na atributy. Ve všech předchozích případech jsme viděli, že atribut je jakoby primární věcí.
Valitron se vydal jinou cestou a na první místo dal ověřovací pravidla. Při popisu pravidel se zdá, že na tato pravidla aplikujete atributy a ne naopak.
$validator = new Validator($data); $validator ->rule("dvě_slova", "jméno")->label("") ->rule("požadováno", [ "jméno", "login", "e-mail", "heslo", "souhlaseno" ] ) ->rule("slug", "login") ->rule("e-mail", "e-mail") ->rule("accepted", "agreed");
Jak je vidět z příkladu, v metodě pravidlo() Nejprve napíšeme název pravidla a teprve poté uvedeme atributy, které musí tomuto pravidlu odpovídat. Explicitnějším příkladem je povinné pravidlo, které ukazuje, jak atributy „patří“ k tomuto pravidlu.
Valitron (stejně jako jiná řešení, která jsme zkontrolovali) poskytuje standardní chybová hlášení. Pokud je jen použijete, uvidíte, že každá zpráva začíná názvem odpovídajícího atributu.
Valitron nahrazuje názvy atributů do textu zprávy i při použití nestandardních chybových zpráv. Proto jsme k odstranění názvu atributu použili metodu label() s prázdným řetězcem.
$validator->rule("dvě_slova", "jméno")->label("")
Zpětná vazba
Konkrétně pokud jde o validaci, API knihovny Valitron se prakticky neliší od toho, co jsme již viděli v článku. Pro provedení validace voláme metodu validátoru ověřit():
$validator->validate();
Pomocí této metody lze získat chybová hlášení ověření getErrors():
$validator->errors();
Zprávy jsou zde seskupeny podle atributů stejným způsobem jako v Sirius Validation, s tím rozdílem, že pro zprávu neexistuje žádná samostatná třída a dostáváme běžné vícerozměrné pole.
foreach ($validator->errors() jako $attribute => $messages) ( foreach ($messages jako $message) ( echo $message . "\n"; ) )
řízení
A nakonec poslední knihovnou pro dnešek je můj vlastní vývoj s názvem Kontrolio.
Definování pravidel
Opět, již popáté, vytvoříme ověřovací pravidlo pro uživatelské jméno. Vše je poměrně jednoduché a standardní:
jmenný prostor MůjProjekt\Validace\Pravidla; použijte Kontrolio\Rules\AbstractRule; class TwoWords rozšiřuje Kontrolio\Rules\AbstractRule ( veřejná funkce isValid($input = null) ( return (bool) preg_match("/^+\s+$/u", $input); ) )
Nyní vytvoříme továrnu a pomocí metody v ní zaregistrujeme pravidlo rozšířit():
jmenný prostor MyProject; použijte Kontrolio\Factory; použijte MyProject\Validation\Rules\TwoWords; $factory = Kontrolio\Factory::getInstance()->extend();
Po zaregistrování pravidla jej můžeme používat, a to i podle názvu – dvě_slova. Vytvoříme validátor:
$data = [ "jméno" => "Albert", // Musí být dvě slova "login" => "@lbert", // "Zakázán" znak @ "e-mail" => "něco není v pořádku", / / Mělo by to být být zde e-mail "password" => "" // Heslo není vůbec zadáno // "agreed" není v poli, protože uživatel nezaškrtl políčko ]; $rules = [ "jméno" => "dvě_slova", "přihlášení" => "někdy|alphadash", "e-mail" => "e-mail", "heslo" => "délka:1,64", "souhlasím" = > " přijat"]; $messages = [ "name" => "Uživatelské jméno se musí skládat ze dvou slov.", "login" => "Nelíbí se nám vaše přihlašovací jméno.", "email" => "Zjevně nechcete dát nám váš email .", "heslo" => "No, kde máš heslo?", "souhlas" => "Škoda, že nesouhlasíš." ]; $validator = $factory->make($data, $pravidla, $messages);
Pravidla jsme popsali pomocí syntaxe podobné syntaxi použité v Laravelu, i když jsme mohli použít podrobnější verzi:
$rules = [ "jméno" => nová dvě slova, "přihlášení" => , "e-mail" => nový e-mail, "heslo" => nová Délka(1, 64), "souhlas" => nový Přijato ];
Zpětná vazba
Validace se spustí stejným způsobem ověřit():
$validator->validate();
Nyní můžeme pomocí jedné z metod získat chybové zprávy getErrors() nebo getErrorsList(). První metoda umožňuje složitější chybový výstup, zatímco druhá vrací ploché pole. Použitím getErrors() můžeme vypsat zprávy něco takového:
-
$messages): ?>
-
A s getErrorsList() Můžete si vytvořit jednodušší seznam zpráv:
getErrorsList(); ?>
Sečteno a podtrženo
V tomto článku jsem ukázal příklady použití následujících knihoven:
- Aura.Filtr
- Ověření respektu
- Ověření Sirius
- Valitron
- řízení
„Příklad ze skutečného světa“ se může zdát příliš jednoduchý. Musím souhlasit, protože některé funkce knihovny byly z článku skutečně vynechány. V zásadě platí, že pokud máte zájem, můžete si jejich vlastnosti prostudovat sami.
Každá z knihoven nabízí své vlastní funkce a má své stinné stránky, takže si myslím, že je otázkou vkusu a výzvy, kterou si vybrat.
Děkuji za přečtení. Vyberte si správně.
Štítky: Přidat štítky
Je velmi důležité nechat si ověřit vstup do formuláře před tím, než odešlete data z formuláře k dalšímu zpracování. Pokud je ve formuláři mnoho polí, stane se ověřovací skript PHP příliš složitým. Navíc, protože provádíte stejné nebo podobné ověřování pro většinu formulářů, které vytváříte, je vynaloženo příliš mnoho duplicitního úsilí na ověřování formulářů.
O tomto obecném skriptu pro ověření formuláře PHP
Tento obecný skript pro validaci formulářů PHP velmi usnadňuje přidávání ověření do formuláře.
Ke každému prvku ve formuláři vytváříme a přidružujeme sadu „ověřovacích deskriptorů“. „Deskriptor ověření“ je řetězec určující typ ověření, které má být provedeno. Například „req“ znamená povinné, „alfa“ znamená povolit pouze abecední znaky a tak dále.
Každé pole ve formuláři může mít nula, jedno nebo více ověření. Vstup by například neměl být prázdný, měl by mít méně než 25 znaků, měl by být alfanumerický atd.
Ke každému vstupnímu poli ve formuláři můžete přiřadit sadu ověřovacích deskriptorů.
Stáhněte si skript pro ověření formuláře PHP
Níže si můžete stáhnout skript pro ověření formuláře PHP:
Soubor zip obsahuje skript pro ověření formuláře formvalidator.php, dokumentaci a ukázky použití.
Použití skriptu pro ověření formuláře PHP
- Zahrňte formvalidator.php do skriptu pro zpracování formuláře require_once "formvalidator.php"
- Vytvořte objekt FormValidator a přidejte deskriptory ověření formuláře. $validator = new FormValidator(); $validator->addValidation("Name","req","Vyplňte prosím jméno"); $validator->addValidation("E-mail","email", "Vstup pro e-mail by měl být platný e-mail"); $validator->addValidation("E-mail","req","Vyplňte prosím e-mail");
- Ověřte formulář voláním funkce ValidateForm(). if(!$validator->ValidateForm()) ( echo " Chyby ověření:"; $error_hash = $validator->GetErrors(); foreach($error_hash jako $inpname => $inp_err) ( echo "
První argument je název vstupního pole ve formuláři. Druhým argumentem je deskriptor validace, který říká typ požadované validace. Třetím argumentem je chybová zpráva, která se zobrazí, pokud se ověření nezdaří.
$inpname: $inp_err
\n" ;))Příklad
Níže uvedený příklad objasní myšlenku
addValidation("Jméno","req","Vyplňte prosím jméno"); $validator->addValidation("E-mail","email", "Vstup pro e-mail by měl být platný e-mail"); $validator->addValidation("E-mail","req","Vyplňte prosím e-mail"); if($validator->ValidateForm()) ( echo "
Úspěch ověření!
"; $show_form=false; ) else ( echo " Chyby ověření:"; $error_hash = $validator->GetErrors(); foreach($error_hash jako $inpname => $inp_err) ( echo "$inpname: $inp_err
\n"; ) ) ) if(true == $show_form) ( ?>Přidání vlastního ověření
Pokud chcete přidat vlastní ověření, které není poskytováno deskriptory ověření, můžete tak učinit. Zde jsou kroky:
- Vytvořte třídu pro vlastní ověření a přepište funkci DoValidate().
- Přidejte objekt vlastního ověření
class MyValidator rozšiřuje CustomValidator ( funkce DoValidate(&$formars,&$error_hash) ( if(stristr($formars["Comments"],"http://")) ( $error_hash["Comments"]="Žádné adresy URL nejsou povoleny v komentářích"; return false; ) return true; ) )
$validator = new FormValidator(); $validator->addValidation("Name","req","Vyplňte prosím jméno"); $validator->addValidation("E-mail","email", "Vstup pro e-mail by měl být platný e-mail"); $validator->addValidation("E-mail","req","Vyplňte prosím e-mail"); $custom_validator = new MyValidator(); $validator->AddCustomValidator($custom_validator);
Funkce uživatelského ověření bude volána automaticky po jiných ověřeních.
Tabulka validačních deskriptorů
Zde je seznam všech validačních deskriptorů:
| Deskriptor ověření | Používání |
| req | Pole by nemělo být prázdné |
| maxlen=??? | zkontroluje délku zadávaných údajů na maximum. Pokud je například maximální povolená velikost 25, uveďte deskriptor ověření jako „maxlen=25“. |
| minlen=??? | zkontroluje délku zadaného řetězce na požadované minimum. příklad „minlen=5“ |
| alnum | Zkontrolujte, zda data neobsahují jiné znaky než abecední nebo číselné znaky |
| alnum_s | Povoluje pouze abecední, číselné a mezerové znaky |
| č | Zkontrolujte číselná data |
| alfa | Zkontrolujte abecední údaje. |
| alfa_s | Zkontrolujte abecední údaje a povolte mezery. |
| e-mailem | Pole je pole e-mailu a ověřuje platnost údajů. |
| lt=??? méně než =??? | Ověřte, že data jsou nižší než předaná hodnota. Platí pouze pro číselná pole. příklad: pokud by hodnota měla být menší než 1000, uveďte popis ověření jako „lt=1000“ |
| gt=??? větší než =??? | Ověřte, že data jsou větší než předaná hodnota. Platí pouze pro číselná pole. příklad: pokud by hodnota měla být větší než 10, uveďte popis ověření jako „gt=10“ |
| regexp=??? | Pomocí regulárního výrazu zkontrolujte, zda by hodnota měla odpovídat regulárnímu výrazu. příklad: „regexp=^(1.20)$“ povoluje až 20 abecedních znaků. |
| dontselect=?? | Tento deskriptor ověření je pro výběr vstupních položek (seznamů) Normálně budou mít výběrová seznamová pole jednu položku s nápisem ‚Vyberte jednu‘. Uživatel by měl vybrat jinou možnost než tuto. Pokud hodnota této možnosti je ‚Vybrat jednu‘, popis ověření by měl být „dontselect=Vyberte jednu“ |
| dontselectchk | Tento deskriptor ověření je pro zaškrtávací políčka. Uživatel by neměl zaškrtnout dané políčko. Poskytněte hodnota zaškrtávacího políčka místo ?? Například dontselectchk=on |
| shouldselchk | Tento deskriptor ověření je pro zaškrtávací políčka. Uživatel by měl zaškrtnout dané zaškrtávací políčko. Zadejte hodnotu zaškrtávacího políčka namísto ?? Například shouldselchk=on |
| nevybírejte rádio | Tento deskriptor ověření je pro přepínací tlačítka. Uživatel by neměl vybrat daný přepínač. Zadejte hodnotu přepínače namísto ?? Například dontselectradio=NO |
| výběrové rádio | Tento deskriptor ověření je pro přepínací tlačítka. Uživatel by měl vybrat daný přepínač. Zadejte hodnotu přepínače namísto ?? Například selectradio=yes |
| selmin=?? | Vyberte alespoň n počet zaškrtávacích políček ze skupiny zaškrtávacích políček. Například: selmin=3 |
| osamocený | Nastaví rádiovou skupinu jako povinnou. Uživatel by měl vybrat alespoň jednu položku ze skupiny rádia. |
| eqelmnt=??? | porovnejte dva prvky ve formuláři a ujistěte se, že hodnoty jsou stejné, například „heslo“ a „potvrzení hesla“. Nahradit ??? se jménem druhého vstupního prvku. Například: eqelmnt=confirm_pwd |
