Գրեթե բոլոր ինտերակտիվ վեբ հավելվածները պետք է վավերացնեն մուտքագրումը: Օրինակ, գրանցման ձևը, հավանաբար, հաստատման համար կպահանջի գաղտնաբառ: Գուցե էլփոստի հասցեն պետք է եզակի լինի: Նախապատմության ստուգումը կարող է ծանր գործընթաց լինել: Բարեբախտաբար, ոչ Laravel-ում: Validator դասը տրամադրում է վավերացման օգնականների զարմանալի հավաքածու՝ հնարավորինս հեշտացնելով տվյալների վավերացումը: Դիտարկենք օրինակ.

Ստանալով տվյալների զանգվածի վավերացման համար.

$input = Մուտքագրեք::all();

Տվյալների վավերացման կանոնների սահմանում.

$rules = array("name" => "պահանջվում է|max:50", "email" => "պահանջվում է|էլ.փոստ|եզակի:users",);

Վալիդատորի օրինակի ստեղծում և տվյալների վավերացում.

$validation = Validator::make($input, $rules); if ($validation->fails()) ( վերադարձնել $validation->errors; )

Եթե ​​կա գույք սխալներդուք մուտք եք ստանում հաղորդագրությունների հավաքիչ, որը թույլ է տալիս հեշտությամբ ստեղծել ձեր սեփական սխալի հաղորդագրությունները: Իհարկե, բոլոր վավերացման կանոնները լռելյայն ունեն սխալի հաղորդագրություններ: Ստանդարտ սխալի հաղորդագրությունները մուտքագրված են language/en/validation.php.

Այժմ դուք ծանոթ եք Validator դասի օգտագործման հիմնական կանոններին: Դուք պատրաստ եք ուսումնասիրել և սովորել ձեր տվյալները ստուգելու համար օգտագործվող կանոնները:

Վավերացման կանոններ

Պարտադիր տվյալներ

Պահանջվող ոչ դատարկ պարամետրի արժեքի ստուգում.

"name" => "պահանջվում է"

Ալֆա, ալֆա թվային և ալֆա գծիկ

Միայն տառերի ստուգում.

"name" => "ալֆա"

Միայն տառերի և թվերի ստուգում.

"username" => "alpha_num"

Ստուգեք միայն տառերը, թվերը, գծիկները և ընդգծումները.

"username" => "alpha_dash"

Չափը

Ստուգելով լարային հատկանիշի տողի չափը կամ թվային հատկանիշի արժեքների միջակայքը.

"name" => "size:10"

Մի շարք արժեքների ստուգում.

"payment" => "10.50-ի միջև"

Նշում:Նվազագույնը և առավելագույնը ներառված են տեսականու մեջ:

Նվազագույն հատկանիշի չափի ստուգում.

"payment" => "min:10"

Առավելագույն հատկանիշի չափի ստուգում.

"payment" => "max:50"

Թվային տեսակներ

Ստուգում, թե արդյոք հատկանիշը թվային տեսակ է.

«վճարում» => «թվային»

Ստուգում, թե արդյոք հատկանիշը ամբողջ թվային տիպ է.

"payment" => "ամբողջ թիվ"

Երևույթներ և բացառումներ

Ստուգելով հատկանիշը արժեքների զանգվածում ներառելու համար.

"size" => "in:small, միջին, մեծ"

Ստուգելով հատկանիշը արժեքների զանգվածից բացառելու համար.

"language" => "not_in:cobol,assembler"

Հաստատում

Կանոն հաստատվել էստուգում է, որ կա համապատասխան * հատկանիշ_հաստատում * տվյալ հատկանիշի համար:

Հաստատման հատկանիշի ստուգում.

"password" => "հաստատված"

Այս օրինակում Validator-ը ստուգում է, որ պարամետրը գաղտնաբառըբավարարում է պայմանները գաղտնաբառի հաստատումվավերացման զանգվածից:

Ընդունում

Կանոն ընդունվածստուգում է պարամետրը արժեքի համար այոկամ 1 . Այս կանոնը ստուգում է պարտադիր վանդակների տեղադրումը, ինչպիսին է, օրինակ, «Ծառայության պայմանները» վանդակը:

Ընդունման ստուգում.

"terms" => "ընդունված է"

Համապատասխանություններ և տարբերություններ

Ստուգելով, որ հատկանիշը նույնն է, ինչ համեմատվող մյուս հատկանիշը.

"token1" => "նույնը:token2"

Ստուգելով, որ հատկանիշը այլ արժեք ունի.

"password" => "different:old_password",

Կանոնավոր արտահայտություններ

Կանոն համընկնումստուգում է հատկանիշը՝ կանոնավոր արտահայտությանը համապատասխանելու համար:

Կանոնավոր արտահայտության բավարարվածության ստուգում.

"username" => "համապատասխանում:/+/";

Եզակիություն և գոյություն

Տվյալների բազայում եզակիության պարամետրի ստուգում.

"email" => "unique:users"

Այս օրինակում պարամետրը էլստուգվել է աղյուսակում եզակիության համար օգտվողներ. Պետք է ստուգե՞լ այս սյունակից այլ սյունակի հատկանիշի եզակիությունը: Ոչ մի խնդիր:

Նշելով մեկ այլ սյունակ՝ ստուգելու համար.

"email" => "unique:users,email_address"

Հաճախ գրառումը թարմացնելիս ձեզ հարկավոր է օգտագործել եզակի կանոն, բայց բացառել գրառումը թարմացնելը: Օրինակ, դուք ցանկանում եք թույլ տալ օգտվողներին փոխել իրենց էլփոստի հասցեները: Բայց երբ կանոնը գործում է եզակի, դուք պետք է բաց թողնեք այս օգտվողին՝ երևակայական վավերացման սխալ առաջացնելու համար: Դա պարզ է.

Անտեսելով նշված ID-ն.

"email" => "unique:users,email_address,10"

Նշված տվյալների բազայում հատկանիշի առկայության ստուգում.

"state" => "exists:states"

Նշելով սյունակի անվանումը գոյություն ունեցող կանոնի համար.

"state" => "exists:states, հապավում"

Ամսաթվեր

Ստուգելով, որ ամսաթվի պարամետրն ունի արժեք մինչև...:

"birthdate" => "before:1986-28-05";

Ստուգելով, որ ամսաթվի պարամետրն ունի արժեք… հետո:

"birthdate" => "after:1986-28-05";

Նշում:Փորձաքննություն նախքանԵվ հետոօգտագործում է PHP ֆունկցիան strtotime.

Էլփոստի հասցեներ

Ստուգելով, որ պարամետրը էլեկտրոնային փոստի հասցե է.

"address" => "email"

Նշում:Այս կանոնը օգտագործում է PHP-ի ներկառուցված մեթոդը filter_var.

URL-ներ

Ստուգելով, որ պարամետրը URL է.

"link" => "url"

Ստուգելով, որ պարամետրը ակտիվ URL է.

"link" => "active_url"

Նշում:Կանոն active_urlօգտագործում է checkdnsrստուգելու, արդյոք URL-ն ակտիվ է:

Ներբեռնումներ

Կանոններ մնջախաղերստուգեք, որ ներբեռնված ֆայլը համապատասխանում է MIME տեսակին: Այս կանոնը օգտագործում է PHP Fileinfo ընդլայնումը ֆայլի բովանդակությունը ստուգելու և դրա տեսակը որոշելու համար: Ֆայլի ցանկացած ընդլայնում, որը վերաբերում է այս կանոնին, սահմանվում է config/mimes.php.

Ստուգում, թե արդյոք ֆայլը պատկանում է որոշակի տեսակի.

"picture" => "mimes:jpg,gif"

Նշում:Ստուգելիս հիշեք օգտագործել Input::file() կամ Input::all():

Ստուգելով, որ ֆայլը պատկեր է.

"picture" => "պատկեր"

Ֆայլի չափի ստուգում.

"picture" => "image|max:100"

Խնդրեք սխալի հաղորդագրություն

Laravel-ը թույլ է տալիս կարգավորել սխալի հաղորդագրությունները՝ օգտագործելով մի պարզ դաս, որը կոչվում է սխալների հավաքիչ: Զանգահարելու մեթոդներից հետո անցնում էկամ ձախողվում էՎավերացնողի օրինակ, դուք կարող եք մուտք գործել սխալ՝ օգտագործելով սեփականությունը սխալներ. Սխալների կոլեկցիոներն ունի սխալ հաղորդագրություններ հարցումների պարզ գործառույթներ.

Որոշել, որ հատկանիշն ունի սխալի հաղորդագրություն.

if ($validation->errors->has("email")) ( // Էլփոստի հատկանիշը սխալներ ունի... )

Հարցրեք առաջին սխալի հաղորդագրությունը հատկանիշի համար.

echo $validation->errors-> first("email");

Հնարավոր է, որ անհրաժեշտ լինի ձեր սխալի հաղորդագրությունը փաթաթել HTML պիտակներով: Ոչ մի խնդիր. :message place-holder-ը կանչելիս նշեք ձևաչափը որպես մեթոդի երկրորդ պարամետր։

Սխալի հաղորդագրության ձևաչափում.

echo $validation->errors-> first("email", "");

Ստանալով բոլոր սխալի հաղորդագրությունները հատկանիշի համար.

$messages = $validation->errors->get("email");

Բոլոր սխալ հաղորդագրությունների ձևաչափումը հատկանիշի համար.

$messages = $validation->errors->get("email", "");

Բոլոր ատրիբուտների համար սխալի բոլոր հաղորդագրությունների ստացում.

$messages = $validation->errors->all();

Բոլոր ատրիբուտների համար բոլոր սխալ հաղորդագրությունների ձևաչափում.

$messages = $validation->errors->all("");

Անցում վավերացում

Վավերացումն ավարտելուց հետո ձեզ անհրաժեշտ է պարզ միջոց՝ դիտման մեջ սխալները ցուցադրելու համար: Laravel-ը դա շատ հեշտ է դարձնում: Եկեք նայենք բնորոշ սցենարին. Սա կարող է սահմանվել երկու ձևով.

Route::get("register", function() ( return View::make("user.register"); )); Երթուղի::post(«գրանցել», ֆունկցիա() ($rules = array(...); $validation = Validator::make(Input::all(), $rules); if ($validation->fails( )) ( return Redirect::to("register")->with_errors($validation); ) ));

Հիանալի Այսպիսով, մենք ունենք երկու պարզ երթուղի գրանցման ձևի համար: Մեկը կարգավորելու համար ձևի ցուցադրումը, և մեկը կարգավորելու ձևի մուտքագրումը: POST երթուղում մենք որոշ ստուգումներ ենք կատարում մուտքագրման ժամանակ: Եթե ​​ստուգումը ձախողվի, մենք ձեզ հետ կուղարկենք գրանցման ձև՝ նշելով սխալները և վերջիններս ցուցադրելով ձևի մեջ:

Բայց նկատի ունեցեք, որ մենք բացահայտորեն չենք կապում սխալները թիրախի հետ մեր GET երթուղում. Այնուամենայնիվ, սխալի փոփոխականը հասանելի կլինի տեսքում: Laravel-ը խելամտորեն հայտնաբերում է, թե արդյոք նիստում սխալներ կան, և եթե այո, ապա կցում է հաղորդագրություններ դիտմանը: Եթե ​​սխալներ չկան, սխալի հաղորդագրության դատարկ բեռնարկղը դեռ կցված կլինի տեսքին: Սխալի հաղորդագրության կոնտեյները միշտ հասանելի կլինի տեսադաշտում: Մենք սիրում ենք հեշտացնել ձեր կյանքը:

Պատվերով սխալի հաղորդագրություններ

Ցանկանու՞մ եք օգտագործել ձեր սեփական սխալի հաղորդագրությունը: Դուք նույնիսկ կարող եք օգտագործել հատուկ սխալի հաղորդագրություններ տվյալ հատկանիշի և կանոնի համար: Ամեն դեպքում, Validator դասը հեշտացնում է դա:

Ձեր սեփական սխալի հաղորդագրությունների զանգվածի ստեղծում Validator-ի համար.

$messages = array("required" => "The:attribute դաշտը պարտադիր է.",); $validation = Validator::make(Input::get(), $rules, $messages);

Հիանալի Այժմ մեր հատուկ հաղորդագրությունները միշտ կօգտագործվեն ստուգման ընթացքում: Բայց ինչպիսի արտահայտություն :հատկանիշմեր հաղորդագրության մեջ։ Ձեր կյանքը հեշտացնելու համար Validator դասը փոխարինում է :հատկանիշայն հատկանիշին, որի մուտքագրումն առաջացրել է սխալ: Այն նույնիսկ կհեռացնի ընդգծումը հատկանիշի անունից: Կարող եք նաև օգտագործել :այլ, : չափ, :min, : մաքս, Եվ :արժեքներտեղապահեր՝ ձեր սխալի հաղորդագրությունները ստեղծելու համար:

Պատվերով սխալի հաղորդագրությունների օրինակներ.

$messages = array("same" => "The:attribute and:other-ը պետք է համապատասխանի.", "size" => "The:attribute-ը պետք է լինի հենց:size.", "between" => "The:հատկանիշը պետք է լինի. միջև:min - :max.", "in" => ":հատկանիշը պետք է լինի հետևյալ տեսակներից մեկը՝ :values",);

Ի՞նչ անել, եթե անհրաժեշտ է սահմանել պահանջվող հաղորդագրություն, բայց միայն էլփոստի հատկանիշի համար: Ոչ մի խնդիր. Պարզապես նշեք հաղորդագրությունը օգտագործելով հատկանիշ_կանոնանվանումը:

Հատուկ հատկանիշի համար հաղորդագրության սահմանում.

$messages = array("email_required" => "Մենք պետք է իմանանք Ձեր էլ. փոստի հասցեն!",);

Այս օրինակում հատուկ սխալի հաղորդագրությունը կօգտագործվի միայն էլփոստի հատկանիշի համար, հակառակ դեպքում կօգտագործվեն ստանդարտ հաղորդագրություններ:

Միևնույն ժամանակ, եթե դուք օգտագործում եք շատ ձեր սեփական սխալի հաղորդագրությունները, կոդի մեջ դրանք բոլորը նշելը կարող է այն դարձնել ծանր և անհարմար: Այդ պատճառով լեզվական ֆայլում հնարավոր է սահմանել ձեր սեփական զանգվածը.

Լեզվի ֆայլին ձեր սեփական զանգված ավելացնելը.

"custom" => array("email_required" => "Մենք պետք է իմանանք ձեր էլ. փոստի հասցեն!",)

Սեփական վավերացման կանոններ

Laravel-ը տրամադրում է մի շարք հզոր վավերացման կանոններ: Այնուամենայնիվ, դուք կարող եք ստեղծել ձեր սեփականը: Վավերացման կանոններ ստեղծելու երկու պարզ եղանակ կա. Երկուսն էլ հուսալի են օգտագործման համար: Ձեզ մնում է միայն ընտրել այն, որն ավելի հարմար է ձեր նախագծին:

Ձեր սեփական վավերացման կանոնի գրանցում.

Վավերացնող::register(«հիանալի», ֆունկցիա ($ հատկանիշ, $value, $parameters) ( վերադարձ $value == «wesome"; }); !}

Այս օրինակում մենք գրանցել ենք վավերացման նոր կանոններ Validator դասի համար: Այս կանոնը վերցնում է երեք պարամետր. Առաջինը ստուգվող հատկանիշի անունն է, երկրորդը ստուգվող հատկանիշի արժեքն է, իսկ երրորդը այն պարամետրերի զանգվածն է, որոնք նշված են կանոնի համար:

Ահա թե ինչ տեսք ունի ձեր կանոնների կանչը.

$rules = array ("username" => "պահանջվում է|հրաշալի",);

Իհարկե, դուք պետք է սահմանեք սխալ հաղորդագրություն նոր կանոնի համար: Դուք կարող եք դա անել կամ զանգվածի հատուկ հաղորդագրություններում.

$messages = array("wesome" => "Հատկանիշի արժեքը պետք է լինի հիանալի!",); $validator = Validator::make(Input::get(), $rules, $messages);

կամ կանոնի համար մուտքագրում ավելացնելով language/en/validation.php:

"wesome" => "Հատկանիշի արժեքը պետք է լինի հիանալի!",

Ինչպես նշվեց վերևում, դուք նույնիսկ կարող եք նշել և ստանալ պարամետրերի ցանկ մաքսային կանոնով.

// Կանոն կառուցելիս... $rules = array("username" => "required|wesome:yes",); // Կանոնում... Validator::register("wesome", function($attribute, $value, $parameters) ( return $value == $parameters; )

Այս օրինակում ձեր վավերացման կանոնի արգումենտների պարամետրը կստանա մեկ տարր պարունակող զանգված՝ «այո»:

Հարմարեցված վավերացման կանոններ ստեղծելու և պահելու մեկ այլ միջոց է Validator դասի ընդլայնումը: Ավելին, Laravel-ի անվանատարածքների շնորհիվ այս դասը կարող է ընդլայնվել: Դրանով դուք ստեղծում եք վավերացնողի նոր տարբերակ, որն ունի նախկինում առկա բոլոր հնարավորությունները՝ համակցված նոր հավելումներով: Դուք նույնիսկ կարող եք ընտրել փոխարինել որոշ կանխադրված մեթոդներ, եթե ցանկանում եք: Դիտարկենք օրինակ.

Նախ, ստեղծեք դաս Վավերացնողորը ժառանգում է դասը Laravel\Validatorև տեղադրել այն հավելված/գրադարաններ:

Ձեր սեփական դասի սահմանում.

Հիմա եկեք ավելացնենք մեր «սքանչելի» կանոնը և սահմանենք այն նոր դասում.

Նոր կանոնի ավելացում.

Նկատի ունեցեք, որ validate_awesom մեթոդն անվանվել է ըստ անվանման կոնվենցիայի: Նրանք. «Awesome» կանոնի համար մեթոդը պետք է անվանվի «validate_awesome»: Սա Validator դասի երկարաձգման բազմաթիվ եղանակներից մեկն է: Validator դասը պարզապես պահանջում է «true» կամ «false» արժեքը վերադարձնել: Այսքանը:

Հիշեք, որ դուք դեռ պետք է ստեղծեք հատուկ հաղորդագրություն ձեր ստեղծած վավերացման կանոնների համար: Դա անելու մեթոդը նույնպես անկախ է նրանից, թե ինչպես եք սահմանում կանոնները:

Վեբ հավելվածներ ստեղծելիս կարևոր է լրջորեն վերաբերվել անվտանգությանը, հատկապես, երբ գործ ունես օգտատերերից տվյալներ ստանալու հետ:

Անվտանգության ընդհանուր կանոնն է՝ ոչ ոքի չվստահել, այնպես որ դուք չեք կարող ապավինել օգտվողներին՝ միշտ ճիշտ արժեքները ձևաթղթերում մուտքագրելու համար: Օրինակ՝ դաշտում ճիշտ էլփոստի հասցեն մուտքագրելու փոխարեն օգտատերը կարող է մուտքագրել սխալ հասցե կամ նույնիսկ որոշ վնասակար տվյալներ:

Երբ խոսքը վերաբերում է օգտվողի տվյալների վավերացմանը, դա կարող է կատարվել կամ հաճախորդի կողմից (վեբ բրաուզերում) կամ սերվերի կողմից:

Նախկինում հաճախորդի կողմից վավերացումը կարող էր իրականացվել միայն JavaScript-ի միջոցով: Բայց ամեն ինչ փոխվել է (կամ գրեթե փոխվել է), քանի որ HTML5-ի օգնությամբ վավերացումը կարելի է կատարել բրաուզերում՝ առանց JavaScript-ում բարդ վավերացման սկրիպտներ գրելու անհրաժեշտության։

Ձևի վավերացում HTML5-ի միջոցով

HTML5-ն ապահովում է բավականին ամուր մեխանիզմ՝ հիմնված հետևյալ պիտակների ատրիբուտների վրա տեսակը, օրինակը և պահանջը: Այս նոր ատրիբուտներով դուք կարող եք զննարկիչում բեռնաթափել տվյալների վավերացման որոշ գործառույթներ:

Եկեք նայենք այս հատկանիշներին՝ հասկանալու համար, թե ինչպես կարող են դրանք օգնել ձևի վավերացման հարցում:

տեսակի հատկանիշ

Այս հատկանիշը ցույց է տալիս, թե որ մուտքային դաշտը պետք է ցուցադրվի տվյալների մշակման համար, օրինակ՝ ծանոթ դաշտը

Որոշ մուտքային դաշտեր արդեն տրամադրում են վավերացման ստանդարտ մեթոդներ՝ առանց լրացուցիչ կոդ գրելու անհրաժեշտության: Օրինակ, ստուգում է դաշտը՝ համոզվելու համար, որ մուտքագրված արժեքը համապատասխանում է վավեր էլ. հասցեի ձևանմուշին: Եթե ​​դաշտում սխալ նիշ է մուտքագրվել, ձևը չի կարող ներկայացվել մինչև արժեքը չշտկվի:

Փորձեք խաղալ էլփոստի դաշտի արժեքների հետ ստորև ներկայացված ցուցադրությունում:

Կան նաև այլ ստանդարտ դաշտերի տեսակներ, օրինակ , Եվ համապատասխանաբար համարների, URL-ների և հեռախոսահամարների վավերացման համար:

Նշում. Հեռախոսահամարի ձևաչափերը տարբեր են երկրից երկիր՝ հեռախոսահամարների թվանշանների և ձևաչափերի տարբերությունների պատճառով: Արդյունքում, ճշգրտումը չի սահմանում հեռախոսահամարները ստուգելու ալգորիթմ, ուստի գրելու պահին այս հատկությունը վատ է աջակցվում բրաուզերների կողմից:

Բարեբախտաբար, հեռախոսահամարի վավերացումը կարող է իրականացվել օգտագործելով օրինաչափություն հատկանիշը, որը որպես փաստարկ ընդունում է կանոնավոր արտահայտություն, որը մենք կանդրադառնանք հաջորդիվ:

օրինաչափության հատկանիշ

Կաղապարի հատկանիշը, հավանաբար, կստիպի շատ ծրագրավորողների ցատկել ուրախությունից: Այս հատկանիշն ընդունում է կանոնավոր արտահայտություն (նման է JavaScript-ի կանոնավոր արտահայտության ձևաչափին), որը կօգտագործվի դաշտում մուտքագրված տվյալների ճշգրտությունը ստուգելու համար:

Կանոնավոր արտահայտությունները լեզու են, որն օգտագործվում է տեքստը վերլուծելու և շահարկելու համար: Դրանք հաճախ օգտագործվում են գտնելու և փոխարինելու բարդ գործողությունների, ինչպես նաև մուտքագրված տվյալների ճշգրտությունը ստուգելու համար:

Այսօր կանոնավոր արտահայտությունները ներառված են ծրագրավորման ամենատարածված լեզուներում, ինչպես նաև շատ սկրիպտային լեզուներում, խմբագրիչներում, հավելվածներում, տվյալների բազաներում և հրամանի տողերի կոմունալ ծառայություններում:

Կանոնավոր արտահայտությունները (RegEX) հզոր, հակիրճ և ճկուն գործիք են տեքստի տողերին համապատասխանեցնելու համար, ինչպիսիք են առանձին նիշերը, բառերը կամ նիշերի նախշերը:

Որպես օրինաչափության հատկանիշի արժեք փոխանցելով կանոնավոր արտահայտություն՝ կարող եք նշել, թե ինչ արժեքներ են ընդունելի տվյալ մուտքագրման դաշտի համար, ինչպես նաև տեղեկացնել օգտատիրոջը սխալների մասին:

Դիտարկենք կանոնավոր արտահայտությունների օգտագործման մի քանի օրինակ՝ մուտքագրման դաշտերի արժեքը հաստատելու համար:

Հեռախոսահամարներ

Ինչպես նշվեց ավելի վաղ, հեռախոսային դաշտի տեսակը լիովին չի աջակցվում բրաուզերների կողմից՝ տարբեր երկրներում հեռախոսահամարների ձևաչափերի անհամապատասխանությունների պատճառով:

Օրինակ, որոշ երկրներում հեռախոսահամարների ձևաչափը ներկայացված է որպես xxxx-xxx-xxxx, իսկ հեռախոսահամարն ինքնին նման կլինի. 0803-555-8205 .

Այս օրինաչափության կանոնավոր արտահայտությունը հետևյալն է. ^\d(4)-\d(3)-\d(4)$: Կոդով սա կարելի է գրել այսպես.

Հեռախոսահամար:

Ալֆան-թվային արժեքներ

պահանջվող հատկանիշ

Սա բուլյան հատկանիշ է, որն օգտագործվում է ցույց տալու համար, որ ձևը ներկայացնելու համար պետք է լրացվի տվյալ դաշտի արժեքը: Երբ դուք ավելացնում եք այս հատկանիշը դաշտում, զննարկիչը օգտվողից կպահանջի լրացնել այս դաշտը նախքան ձևը ներկայացնելը:

Սա մեզ փրկում է JavaScript-ի միջոցով դաշտի վավերացումն իրականացնելուց, որը կարող է որոշ ժամանակ խնայել ծրագրավորողներին:

Օրինակ: կամ (XHTML համատեղելիության համար)

Բոլոր ցուցադրությունները, որոնք դուք տեսել եք վերևում, օգտագործում են պահանջվող հատկանիշը, այնպես որ կարող եք փորձել այն՝ փորձելով ուղարկել ձևը առանց որևէ դաշտ լրացնելու:

Եզրակացություն

Բրաուզերի աջակցությունը ձևի վավերացման համար բավականին լավ է, և ավելի հին բրաուզերների համար կարող եք օգտագործել polyfills:

Հարկ է նշել, որ միայն բրաուզերի կողմից վավերացման վրա հույս դնելը վտանգավոր է, քանի որ այս ստուգումները հեշտությամբ կարող են շրջանցվել հարձակվողների կամ բոտերի կողմից:

Ոչ բոլոր բրաուզերներն են աջակցում HTML5-ին, և ձեր սկրիպտին ուղարկված բոլոր տվյալները չեն ստացվում ձեր ձևից: Սա նշանակում է, որ օգտատերից տվյալները վերջնականապես ընդունելուց առաջ անհրաժեշտ է ստուգել դրանց ճշգրտությունը սերվերի կողմից։

Այստեղ այս գրառման մեջ մենք պատրաստվում ենք տեսնել, թե ինչպես հաստատել հեռախոսահամարը PHP-ում: Շատ իրավիճակներում վեբ մշակողները պետք է հաստատեն հեռախոսահամարը, որը ներկայացվում է ձևաթղթի միջոցով:

Այսպիսով, այս դեպքերում մենք պետք է հաստատենք, որ ներկայացված հեռախոսահամարը վավեր կառուցվածքով կամ օրինակով է:

Հեռախոսահամարի վավերացումը PHP-ում դժվար գործ չէ: Մենք պատրաստվում ենք դա անել պարզ և հեշտ ձևով:

Մենք բոլորս գիտենք, որ հեռախոսահամարը սովորաբար 10 նիշանոց թիվ է: Բայց կան բազմաթիվ բացառիկ դեպքեր, և այդ պատճառով բավական չէ միայն ստուգել, ​​թե արդյոք թիվը 10 երկարությամբ ամբողջ թիվ է:

Երբեմն օգտատերը կարող է համարը ներկայացնել երկրի կոդով կամ երբեմն «+» նշանը երկրի կոդը առաջ: Այսպիսով, այն կարող է թվալ ավելի բարդ առաջադրանք, որը պետք է վավերացնել:

Բայց, մի անհանգստացեք: Այստեղ դուք կստանաք պատրաստի օգտագործման PHP ֆունկցիա, որը պարունակում է ընդամենը մի քանի տող կոդ:

Այստեղ այս գրառման մեջ մենք պատրաստվում ենք ձեզ ցույց տալ օրինակելի կոդը, որը կկատարի մեր խնդիրը:

Մենք պատրաստվում ենք ստեղծել մի ֆունկցիա, որը կարող է օգտագործվել բջջային համարը վավերացնելու համար: Ստորև ներկայացված է ֆունկցիայի տվյալ կոդը.

Գործառույթ validate_phone_number($phone) ( // Թույլատրել +, - և . հեռախոսահամարում $filtered_phone_number = filter_var($phone, FILTER_SANITIZE_NUMBER_INT); // Հեռացնել «-»-ը $phone_to_check = str_replace("-", "", $: ֆիլտրացված_հեռախոսի_համար); // Ստուգեք համարի երկարությունը // Սա կարող է հարմարեցվել, եթե ցանկանում եք հեռախոսահամար որոշակի երկրից, եթե (strlen($phone_to_check)< 10 || strlen($phone_to_check) >14) ( վերադարձնել կեղծ; ) else (վերադարձնել ճիշտ;))

Վերոնշյալ գործառույթը որպես պարամետր կընդունի հեռախոսահամարը: Ֆունկցիայի ներսում մենք հանել ենք բոլոր անօրինական նիշերը թվից, որպեսզի այն ընդունի միայն «+», «-» և «»: օգտագործելով FILTER_SANITIZE_NUMBER_INT զտիչը: Դե, կարող եք նկատել, հեռախոսահամարը կարող է գրված լինել այս ձևաչափով` +91-523-452-5555 շատ դեպքերում: Այդ իսկ պատճառով հեռախոսահամարում թույլատրել ենք «+» և «-»:

Այնուհետև մենք հեռացրել ենք «-»-ը հեռախոսահամարից՝ օգտագործելով str_replace PHP ֆունկցիան:

Դրանից հետո մենք ստուգել ենք երկարությունը և վերադարձնում ենք true կամ false՝ կախված երկարությունից: Դուք կարող եք նկատել, որ երկարությունը պետք է լինի 10-ից 14-ի միջև: Դա պայմանավորված է նրանով, որ ընդհանուր առմամբ թիվը 10 նիշ է, իսկ երկրի կոդով այն կարող է լինել մինչև 14:

Այժմ ստորև ներկայացված է այն գործառույթի օգտագործումը, որը մենք նոր ենք ստեղծել.

$phone = "+91-444-444-5555"; if (validate_phone_number($phone) == ճշմարիտ) (Էխո «Հեռախոսահամարը վավեր է»;) else (echo «Անվավեր հեռախոսահամար»;)

Վերոնշյալ կոդը կվերադարձնի «Հեռախոսահամարը վավեր է», քանի որ այն վերադարձնում է ճշմարիտ: Եթե ​​դա կեղծ է, ապա այն կվերադարձնի «Անվավեր հեռախոսահամար»:

Այսպիսով, ինչպես էր դա: Մենք հենց նոր տեսանք բջջային համարի վավերացումը PHP-ում:

Ձեզ դուր եկավ այս գրառումը: Խնդրում եմ, տեղեկացրեք ինձ, եթե ցանկանում եք կոդի որևէ բարելավում PHP-ի միջոցով հեռախոսահամարը վավերացնելու համար:

Նախորդ հոդվածում ես խոստացել էի գրել իմ գրադարանի համեմատությունը այլ հասանելի լուծումների հետ, ուստի այսօր մենք կդիտարկենք վավերացումը՝ օգտագործելով Aura.Filter, Respect Validation, Sirius Validation և Valitron:

Եկեք պատկերացնենք, որ մենք ունենք մշակման փուլում գտնվող որոշակի հանրային ծառայություն, որը պահանջում է օգտվողներից գրանցվել բոլոր գործառույթների լիարժեք հասանելիության համար: Այսպիսով, գրանցման ձևը կպարունակի հետևյալ դաշտերը.

1. Անուն.Պետք է պարունակի ուղիղ երկու բառ, որտեղ առաջինը օգտագործողի անունն է, իսկ երկրորդը` ազգանունը:
2. մուտք.Եթե ​​արժեքը փոխանցվում է, այն պետք է պարունակի միայն լատինատառ, գծիկներ և ընդգծումներ:
3. էլ.Պետք է պարունակի վավեր էլփոստի հասցե:
4. գաղտնաբառը։Պետք է սահմանվի և լինի ոչ ավելի, քան 64 նիշ:
5. համաձայնեցին.Տիպիկ վանդակ, որը օգտատերը պետք է ստուգի` հաստատելու համար, որ ընդունում է ծառայության պայմանները:

Այսպիսով, մենք ունենք հինգ դաշտ, որոնք օգտվողը պետք է լրացնի, որպեսզի գրանցվի մեր երևակայական ծառայության մեջ: Եկեք պատկերացնենք, որ որպես մուտքագրում ստացել ենք բոլորովին անվավեր տվյալներ.

$data = [ "name" => "Albert", // Պետք է լինի երկու բառ "login" => "@lbert", // "Արգելված" նիշ @ "email" => "ինչ-որ բան սխալ է", / / ​​Պետք է լինի լինել էլփոստի «գաղտնաբառ» =>

Aura.Filter

Aura.Filter-ի միջոցով վավերացումը սկսվում է ֆիլտրի գործարանից: Մենք պետք է ստեղծենք այսպես կոչված «առարկայական ֆիլտր», քանի որ մենք կվավերացնենք զանգվածը, այլ ոչ թե անհատական ​​արժեք:

Կանոնների սահմանում

օգտագործել Aura\Filter\FilterFactory; $filter = (նոր FilterFactory)->newSubjectFilter(); $filter->validate("name") ->isNotBlank() ->is("two_words") ->setMessage("Անունը պետք է լինի երկու բառ"); $filter->validate("login") ->isBlankOr("alnum") ->setMessage("Եթե դուք մուտք եք նշում, այն պետք է պարունակի միայն լատինական նիշեր"); $filter->validate("email") ->isNotBlank() ->is("email") ->setMessage("Խնդրում ենք մուտքագրել վավեր էլ. հասցե"); $filter->validate("password") ->isNotBlank() ->is("strlenMax", 64) ->setMessage("Խնդրում ենք գրել Ձեր գաղտնաբառը"); $filter->validate("համաձայնեցված") ->is("callback", function($subject, $field) ( return $subject->($field) === true; ))->setMessage("Ձեզ անհրաժեշտ է համաձայնեք ծառայության պայմաններին»);

Ինչպես տեսնում եք, կանոնների նկարագրությունը բավականին պարզ է. Aura.Filter-ը տրամադրում է օգտակար կանոնների մի ամբողջ շարք, և դրանցից մի քանիսն օգտագործվել են վերը նշված օրինակում.

1. isNotBlank մեթոդը:Նշում է, որ դաշտը չի կարող ունենալ զրոյական արժեք:
2. շրջան.Այս կանոնը թույլ է տալիս միայն լատինական տառեր:
3. էլ.Եվ դա այնքան էլ պարզ է :)
4. strlenMax.Նշում է, որ դաշտը չի կարող գերազանցել is մեթոդի երկրորդ արգումենտով սահմանված երկարությունը:
5. ետ Զանգիր.Կանոնների այս տեսակը նման է Kontrolio-ի փակմանը: Այն թույլ է տալիս սահմանել կանոն փակման տեսքով: Այս փակման համար Aura.Filter-ը փոխանցում է «առարկան», մեր տվյալների զանգվածը ձևից և դաշտ, այս դեպքում համաձայնեցված:

Դուք հավանաբար նկատել եք, որ ես չեմ նշել երկու_բառերի կանոնը։ Բնականաբար, Aura.Filter-ում նման կանոն չկա, ուստի պետք է ստեղծել: Ինչպես ասվում է փաստաթղթերում, դա արվում է կանոնի համար առանձին դասի միջոցով.

/** * Կանոն, որը վավերացնում է օգտվողի անունը: * Օգտվողի անունը բաղկացած է երկու բառից՝ անուն և ազգանուն՝ բաժանված մեկ բացատով: */ class UserNameRule ( /** * Վավերացնում է օգտվողի անունը: * * @param օբյեկտ|զանգված $subject * @param string $field * @param int $max * * @return bool */ public ֆունկցիա __invoke($subject, $field , $max = null) ( $value = $subject->($field); if (! is_scalar($value)) ( return false; ) return (bool) preg_match("/^+\s+$/u", $արժեք); ))

Երկրորդ քայլը ֆիլտրի գործարանին տեղեկացնելն է մեր նոր կանոնի մասին: Դա արվում է առաջին արգումենտը որպես կանոնների զանգված փոխանցելով ֆիլտրի գործարան.

Հաջորդ քայլը Aura.Filter-ին տեղեկացնելն է, որ մենք ստեղծել ենք նոր կանոն և ցանկանում ենք օգտագործել այն: Դա արվում է գործարանի առաջին փաստարկին մի շարք կանոններ փոխանցելով.

օգտագործել Aura\Filter\FilterFactory; $rules = [ "two_word" => ֆունկցիա() ( վերադարձնել նոր UserNameRule; ) ]; $ֆիլտր = (նոր FilterFactory($կանոններ))->newSubjectFilter();

Այժմ մեր երկու_բառերի կանոնը կարող է օգտագործվել այնպես, ինչպես ցանկացած այլ ստանդարտ կանոն:

Հետադարձ կապ

Ինչպես հիշում եք, մուտքային տվյալները, որոնք մենք վավերացնում ենք, լիովին անվավեր են, քանի որ յուրաքանչյուր դաշտ պարունակում է սխալ արժեք կամ ընդհանրապես չի պարունակում այն: Հետևաբար, ենթադրվում է, որ վավերացման արդյունքում մենք կստանանք սխալներ և դրանց վերաբերյալ համապատասխան հաղորդագրություններ։

Մենք վավերացնում ենք Aura.Filter-ով հետևյալ կերպ.

$valid = $filter->apply($data); եթե (! $վավեր) ( $failures = $filter->getFailures(); $messages = $failures->getMessages();)

IN $messagesզանգված է գրվում, ուստի հաղորդագրությունները ցուցադրելու համար մեզ անհրաժեշտ է երկու ներդիր՝

$errors) ( foreach ($errors as $error) ( printf("", $error); ) ) ?>

Հարգանք Վավերացում

Երկրորդ գրադարանը, որը ես օգտագործել եմ համեմատության մեջ, համեմատաբար հայտնի լուծում է, որը կոչվում է Respect Validation: Քանի որ մարդիկ վստահում են նրան, կարծում եմ՝ այնտեղ տեսնելու բան կա։

Փորձի մաքրության համար գրադարանները համեմատելիս կօգտագործենք սկզբում սահմանված նույն տվյալների հավաքածուն.

օգտագործել Respect\Validation\Validator որպես v; $data = [ "name" => "Albert", // Պետք է լինի երկու բառ "login" => "@lbert", // "Արգելված" նիշ @ "email" => "ինչ-որ բան սխալ է", / / ​​Պետք է լինի եղիր էլ.

Կանոնների սահմանում

Ինչպես Aura.Filter-ի դեպքում, մեզ անհրաժեշտ է օգտանունի վավերացման մեր սեփական կանոնը, ուստի եկեք սկսենք այնտեղից.

անվանատարածք MyNamespace; օգտագործել Respect\Validation\Rules\AbstractRule; class UserNameRule-ն ընդլայնում է AbstractRule-ը ( հանրային ֆունկցիայի վավերացում ($input) ( վերադարձ (bool) preg_match("/^+\s+$/u", $input); ) )

Արտաքին կանոնների API-ն գրեթե նույնական է Aura.Filter-ին, օգտագործվում է միայն մեթոդը վավերացնել ()կախարդանքի փոխարեն __invoke ().Ինձ թվում էր, որ այս API-ն ավելի պարզ և հասկանալի էր: Դե, դա ավելի մոտ է Controlio-ին :)

Ես դրա մասին որևէ նշում չգտա փաստաթղթերում, սակայն, բացի բուն կանոնից, դրա համար անհրաժեշտ է ստեղծել ձեր սեփական բացառության տեսակը: Բացառության դասի անվանումը պետք է բաղկացած լինի կանոնների դասի անունից և հետֆիքսից Բացառություն.

օգտագործել Respect\Validation\Exceptions\NestedValidationException; դասի UserNameRuleException ընդլայնում է NestedValidationException (//)

Դե, վերջապես մենք կարող ենք հաստատել մեր տվյալները: Նախ, մենք մեր նոր կանոնը փոխանցում ենք վավերացնողին, որպեսզի նա իմանա այդ մասին, և մենք կարողանանք օգտագործել այն ապագայում: Respect Validation-ում դա արվում է մեթոդը կանչելով հետ ()անվանատարածքի փոխանցումով, որտեղ գտնվում են ոչ ստանդարտ կանոնները:

v:: with("MyNamespace\\");

Այժմ բոլոր ոչ ստանդարտ կանոնները, որոնք գտնվում են անունների տարածքում MyNamespace, «կճանաչվի» վավերացնողի կողմից: Հաջորդ քայլը անհրաժեշտ կանոնների նկարագրությունն ու վավերացումն է:

v::attribute("name", v::userNameRule()) ->attribute("login", v::alnum("-_")) ->attribute("email", v::email()) -> հատկանիշ ("գաղտնաբառ", v::notEmpty()->stringType()->length(null, 64)) -> հատկանիշ("համաձայնել", v::trueVal()) ->հաստատել((օբյեկտ) $տվյալներ);

Ուշադրություն դարձրեք, թե ինչպես ենք մենք կիրառում մեր կանոնը հատկանիշի նկատմամբ Անուն. Այստեղ կանոնների դասի անվանումը վերածվել է վավերացնող մեթոդի անվանման։ Մնացած կանոնները, ընդհանուր առմամբ, ինտուիտիվ են:

Արժե առանձին նշել, թե ինչու ենք մենք տրամադրում զանգվածը $տվյալներօբյեկտին. Փաստն այն է, որ Respect Validation-ը որպես մուտքային ընդունում է ոչ թե զանգված, այլ օբյեկտներ: Սա պետք է հաշվի առնել այս գրադարանից օգտվելիս մշակելիս:

Հետադարձ կապ

Ի տարբերություն Aura.Filter-ի, Respect վավերացնողը բացառություն է անում, երբ վավերացումը ձախողվում է: Եվ այս բացառությունը պարունակում է վավերացման սխալի հաղորդագրություններ: Հետևաբար, հենց ցույց տված օրինակը պետք է գրվի հետևյալ կերպ.

try ( v::with("RespectValidationExample\\"); v::attribute("name", v::userNameRule()) ->attribute("login", v::alnum("-_")) - >attribute("email", v::email()) ->attribute("password", v::notEmpty()->stringType()->length(null, 64)) ->attribute("agreed", v::trueVal()) ->հաստատել((օբյեկտ) $data); ) catch (NestedValidationException $ex) ($messages = $ex->getMessages();)

Օգտագործելով getMessages (), մենք կստանանք բոլոր հաղորդագրությունների հարթ զանգված, որոնք վավերացնողը հավաքել է վավերացման գործընթացում: Զանգվածը թափելով՝ մենք ստանում ենք այսպիսի բան.

array(5) ( => string(29) “Data validation not for %s” => string(60) “մուտքը պետք է պարունակի միայն տառեր (a-z), թվանշաններ (0–9) և “-_”” => տող (25) «էլփոստը պետք է լինի վավեր էլ. փոստ» => տող (26) «գաղտնաբառը չպետք է դատարկ լինի» => տող (32) «Հատկանիշը համաձայնեցված պետք է լինի» )

Դուք կարող եք փոխել հաղորդագրությունները ձեր սեփականը: Միգուցե ես ինչ-որ կերպ սխալ եմ հասկացել այս գրադարանը, բայց այս գործընթացն ինձ այնքան էլ ակնհայտ չէր թվում. դուք պետք է օգտագործեք մեթոդը. findMessages ()մշակված բացառության վրա, որտեղ հաղորդագրությունները սահմանում եք ոչ թե ատրիբուտների, այլ կանոնների համար:

$ex->findMessages([ "userNameRule" => "Օգտվողի անունը պետք է բաղկացած լինի երկու բառից.", "alnum" => "Մեզ դուր չի գալիս ձեր մուտքը.", "email" => "Դուք ակնհայտորեն չեք ցանկանում. ուզում եք մեզ տալ ձեր էլ.փոստը։", "notEmpty" => "Դե, որտեղ է ձեր գաղտնաբառը?", "agreed" => "Ափսոս, որ համաձայն չեք" ]);

Չգիտեմ ինչն է սխալ, բայց մի երկու բան դեռ չեմ հասկանում։ Սա այն է, ինչ մենք ստանում ենք կանոնները վերը նշված ձևով սահմանելով.

array(5) ( => string(40) «Օգտվողի անունը պետք է լինի երկու բառ»: => string(31) «Մեզ դուր չի գալիս ձեր մուտքը»: => string (25) «էլ. փոստը պետք է լինի վավեր էլ. փոստ» = > string (5) «Դե, որտեղ է ձեր գաղտնաբառը»: => string (9) «Ափսոս, որ համաձայն չեք»:

Ինչպես տեսնում եք, էլփոստի դաշտի հաղորդագրությունը չի կիրառվել, մնացել է ստանդարտը։ Բայց 4-րդ ինդեքսում հաղորդագրությունը հակառակն է: Եվ սա չնայած նրան, որ ես օգտագործել եմ ոչ թե կանոնի, այլ դաշտի անվանումը։ Մինչդեռ եթե ես օգտագործեի կանոնի անունը (trueVal), իմ հաղորդագրությունը ինչ-որ տեղ կկորեր: Այս գրադարանի փորձառու օգտվողների մեկնաբանությունները շատ ողջունելի են:

Սիրիուսի վավերացում

Լավ, եկեք անցնենք հաջորդ գրադարանին և տեսնենք, թե ինչպես է այն կատարում նմանատիպ առաջադրանքները:

Կանոնների սահմանում

Եվս մեկ անգամ մենք պետք է սահմանենք օգտանունի կանոն: Մենք այն կգրենք այսպես.

class UserNameRule extends AbstractRule ( // Սխալների հաղորդագրությունները const MESSAGE = «Օգտվողի անունը պետք է լինի երկու բառ»: const LABELED_MESSAGE = «(պիտակը) պետք է լինի երկու բառ»: (bool) preg_match ("/^+\s+$/u", $value); ) )

Խնդրում ենք նկատի ունենալ մոտեցումների տարբերությունը արդեն քննարկված գրադարանների համեմատ: Մենք սահմանում ենք երկու տեսակի հաղորդագրություններ հաստատուններում, այլ ոչ թե օգտագործում ենք հատկություններ, մեթոդներ կամ կանոնների փաստարկներ:

Հիմա եկեք նկարագրենք վավերացման տրամաբանությունը.

$validator = նոր Validator; $validator ->add("name", "required | MyApp\Validation\Rule\UserNameRule") ->add("login", "required | alphanumhyphen", null, "Login-ը կարող է պարունակել միայն լատինական տառեր, գծիկներ և ընդգծումներ: ") ->add("email", "required | email", null, "Խնդրում ենք մուտքագրել ճիշտ էլ. փոստ.") ->add("password", "required | maxlength(64)", null, "Ձեր գաղտնաբառ, պարոն:») ->add(«համաձայն եմ», «պարտադիր | հավասար(true)», null, «Ինչու չհամաձայնեցիր»);

Ինչպես տեսնում եք, կանոնների հավաքածուն շատ պարզ է և ընթեռնելի: Նկարագրության համար մենք օգտագործում ենք անուններ, որոնք առանձնացված են հորիզոնական ձողերով: Այս մոտեցումը նման է Laravel-ում և Kontrolio-ում օգտագործվածին:

Չորրորդ մեթոդի փաստարկ ավելացնել ()նկարագրում է վավերացման սխալի հաղորդագրությունը, որն օգտագործում է Sirius-ը, եթե վավերացումը ձախողվի: Ինչու՞ մենք չավելացրինք հաղորդագրություն մեր նոր կանոնի համար: UsernameRule?

$validator->add("name", "պահանջվում է | MyApp\Validation\Rule\UserNameRule")

Դա պայմանավորված է նրանով, որ հաղորդագրություններն արդեն նկարագրված են դասի հաստատուններում.

class UserNameRule-ն ընդլայնում է AbstractRule ( // Սխալների հաղորդագրությունները const MESSAGE = «Օգտվողի անունը պետք է լինի երկու բառ»:

Մեկ այլ տարբերակ է օգտագործել հենց վավերացնողի addMessage() մեթոդը.

$validator->addMessage("email", "Խնդրում ենք մուտքագրել վավեր էլ. փոստ");

Խնդրում ենք նկատի ունենալ, որ մաքսային կանոնները նույնացվում են իրենց դասի լրիվ անունով, մինչդեռ Kontrolio-ում կարող եք նշել alias/alias:

Հետադարձ կապ

Վավերացում կատարելու համար մենք կանչում ենք վավերացման մեթոդը վավերացնել (), տվյալներ փոխանցելով դրան.

$data = [ "name" => "Albert", // Պետք է լինի երկու բառ "login" => "@lbert", // "Արգելված" նիշ @ "email" => "ինչ-որ բան սխալ է", / / ​​Պետք է լինի լինի էլ. $validator->validate($data);

Ի տարբերություն Respect-ի՝ Սիրիուսը բացառություն չի գցի, այլ պարզապես կվերադառնա կեղծ. Վավերացման սխալի հաղորդագրությունները կարելի է ստանալ վավերացնող մեթոդի միջոցով getMessages (). Այն վերադարձնում է ատրիբուտներով խմբավորված սխալներ, ուստի մեզ անհրաժեշտ է երկու foreach հանգույց՝ սխալները անցնելու համար.

foreach ($validator->getMessages() որպես $attribute => $messages) ( foreach ($messages որպես $message) ( echo $message->getTemplate() . "\n"; ) )

Այստեղ $message-ը դասի օբյեկտ է Sirius\Validation\ErrorMessage, որն ունի մեթոդ getTemplate (), վերադարձնելով հենց այն հաղորդագրությունը, որը մեզ անհրաժեշտ է:

Վալիտրոն

Կանոնների սահմանում

Առաջին տարբերությունը. նոր կանոն ավելացնելու համար հարկավոր չէ առանձին դաս ստեղծել: Դուք կարող եք պարզապես օգտագործել փակումը, որը վերադարձնում է բուլյան արդյունք:

Valitron-ում մաքսային կանոններ ավելացնելու համար կա ստատիկ մեթոդ addRule(), որտեղ առաջին երկու արգումենտները պահանջվում են, իսկ երրորդը պարտադիր չէ։ Ինձ դուր եկավ այս մեթոդը, քանի որ այն ցույց է տալիս կանոնի նույնացուցիչը, տրամաբանությունը և սխալի հաղորդագրությունը մեկ տեղում:

օգտագործել Valitron\Validator; Validator::addRule("two_word", ֆունկցիա ($field, $value) ("return (bool) preg_match("/^+\s+$/u", $value); ), "Օգտագործողի անունը պետք է կազմված լինի ճշգրիտ. երկու բառ »);

Երկրորդ տարբերությունն այն է, թե ինչպես են կանոնները կիրառվում ատրիբուտների նկատմամբ: Նախորդ բոլոր դեպքերում մենք տեսանք, որ հատկանիշը, այսպես ասած, առաջնային բան է։

Վալիտրոնը գնաց այլ ճանապարհով և առաջին հերթին դրեց վավերացման կանոնները: Կանոնները նկարագրելով՝ դուք կարծես ատրիբուտներ եք կիրառում այս կանոնների նկատմամբ, և ոչ հակառակը:

$validator = new Validator($data); $validator ->rule("two_word", "name")->label("") ->rule("պահանջվում է", [ "name", "login", "email", "password", "Agreed"] ) -> կանոն ("slug", "login") ->rule ("email", "email") ->rule ("ընդունված", "համաձայնեցված");

Ինչպես երևում է օրինակից, մեթոդում կանոն ()Մենք նախ գրում ենք կանոնի անունը, և միայն դրանից հետո նշում ենք այն ատրիբուտները, որոնք պետք է համապատասխանեն այս կանոնին: Ավելի հստակ օրինակ է պահանջվող կանոնը, որը ցույց է տալիս, թե ինչպես են ատրիբուտները «պատկանում» այդ կանոնին։

Valitron-ը (ինչպես մյուս լուծումները, որոնք մենք վերանայել ենք) տրամադրում է ստանդարտ սխալի հաղորդագրություններ: Եթե ​​դուք պարզապես օգտագործեք դրանք, կտեսնեք, որ յուրաքանչյուր հաղորդագրություն սկսվում է համապատասխան հատկանիշի անունով:

Valitron-ը փոխարինում է ատրիբուտների անունները հաղորդագրության տեքստում, նույնիսկ երբ օգտագործվում են ոչ ստանդարտ սխալի հաղորդագրություններ: Ահա թե ինչու մենք օգտագործեցինք label() մեթոդը՝ դատարկ տողով, որպեսզի հեռացնենք հատկանիշի անունը։

$validator->rule("two_word", "name")->label("")

Հետադարձ կապ

Հատկապես վավերացման հարցում, Valitron գրադարանի API-ն գործնականում չի տարբերվում նրանից, ինչ մենք արդեն տեսել ենք հոդվածում: Վավերացում կատարելու համար մենք կանչում ենք վավերացման մեթոդ վավերացնել ():

$validator->validate();

Վավերացման սխալի հաղորդագրությունները կարելի է ստանալ՝ օգտագործելով մեթոդը ստանալ Սխալներ ():

$validator->errors();

Այստեղ հաղորդագրությունները խմբավորված են ըստ ատրիբուտների, ինչպես Sirius Validation-ում, բացառությամբ, որ հաղորդագրության համար առանձին դաս չկա, և մենք ստանում ենք սովորական բազմաչափ զանգված:

foreach ($validator->errors() as $attribute => $messages) ( foreach ($messages որպես $message) ( echo $message . "\n"; ) )

վերահսկողություն

Եվ վերջապես, այսօրվա վերջին գրադարանը իմ սեփական մշակումն է, որը կոչվում է Kontrolio:

Կանոնների սահմանում

Կրկին հինգերորդ անգամ մենք կստեղծենք օգտվողի անվան վավերացման կանոն: Ամեն ինչ համեմատաբար պարզ է և ստանդարտ.

անվանատարածք MyProject\Validation\Rules; օգտագործել Kontrolio\Rules\AbstractRule; TwoWords դասը ընդլայնում է Kontrolio\Rules\AbstractRule ( հանրային ֆունկցիան isValid($input = null) ( return (bool) preg_match("/^+\s+$/u", $input); ) )

Այժմ մենք ստեղծում ենք գործարան և դրանում կանոն ենք գրանցում՝ օգտագործելով մեթոդը երկարացնել ():

անվանատարածք MyProject; օգտագործել Kontrolio\Factory; օգտագործել MyProject\Validation\Rules\TwoWords; $factory = Kontrolio\Factory::getInstance()->extend();

Կանոնը գրանցելուց հետո մենք կարող ենք օգտագործել այն, այդ թվում՝ անունով՝ two_words։ Եկեք ստեղծենք վավերացուցիչ.

$data = [ "name" => "Albert", // Պետք է լինի երկու բառ "login" => "@lbert", // "Արգելված" նիշ @ "email" => "ինչ-որ բան սխալ է", / / ​​Պետք է լինի եղիր էլ. $rules = [ "name" => "two_word", "login" => "երբեմն|alphadash", "email" => "email", "password" => "length:1.64", "agreed" = > " ընդունված» ]; $messages = [ "name" => "Օգտվողի անունը պետք է բաղկացած լինի երկու բառից.", "login" => "Մեզ դուր չի գալիս ձեր մուտքը.", "email" => "Ակնհայտ է, որ չեք ցանկանում տալ. մեզ քո էլ.փոստը .", "password" => "Դե, որտեղ է քո գաղտնաբառը?", "agreed" => "Ափսոս, որ համաձայն չես." ]; $validator = $factory->make($data, $rules, $messages);

Մենք նկարագրեցինք կանոնները՝ օգտագործելով շարահյուսություն, որը նման է Laravel-ում օգտագործվածին, թեև կարող էինք օգտագործել ավելի մանրամասն տարբերակ.

$rules = [ "name" => new TwoWords, "login" => , "email" => new Email, "password" => new Length(1, 64), "agreed" => new Accepted ];

Հետադարձ կապ

Վավերացումը սկսվում է նույն մեթոդով վավերացնել ():

$validator->validate();

Այժմ մենք կարող ենք սխալի հաղորդագրություններ ստանալ՝ օգտագործելով մեթոդներից մեկը ստանալ Սխալներ ()կամ getErrorsList (). Առաջին մեթոդը թույլ է տալիս ավելի բարդ սխալի ելք, մինչդեռ երկրորդը վերադարձնում է հարթ զանգված: Օգտագործելով ստանալ Սխալներ ()մենք կարող ենք հաղորդագրություններ արտածել այսպես.

$messages): ?>

Եվ հետ getErrorsList ()Դուք կարող եք ստեղծել հաղորդագրությունների ավելի պարզ ցուցակ.

getErrorsList(); ?>

Ներքեւի գիծ

Այս հոդվածում ես ցույց տվեցի հետևյալ գրադարանների օգտագործման օրինակները.

1. Aura.Filter
2. Հարգանք Վավերացում
3. Սիրիուսի վավերացում
4. Վալիտրոն
5. վերահսկողություն

«Իրական աշխարհի օրինակը» կարող է չափազանց պարզ թվալ: Պետք է համաձայնեմ, քանի որ, իրոք, գրադարանային որոշ հնարավորություններ դուրս են մնացել հոդվածից։ Սկզբունքորեն, եթե ձեզ հետաքրքրում է, կարող եք ինքներդ ուսումնասիրել դրանց առանձնահատկությունները։

Գրադարաններից յուրաքանչյուրն առաջարկում է իր առանձնահատկությունները և ունի իր մութ կողմերը, ուստի, կարծում եմ, ճաշակի և մարտահրավերի խնդիր է ընտրել մեկը:

Շնորհակալություն կարդալու համար: Կատարեք ճիշտ ընտրություն.

Պիտակներ. Ավելացնել պիտակներ

Շատ կարևոր է, որ ձեր ձևի մուտքագրումը վավերացվի նախքան ձևաթղթի ներկայացման տվյալները հետագա մշակման համար վերցնելը: Երբ ձևի մեջ շատ դաշտեր կան, PHP վավերացման սցենարը չափազանց բարդ է դառնում: Ավելին, քանի որ դուք կատարում եք նույն կամ նմանատիպ վավերացում ձեր պատրաստած ձևերի մեծ մասի համար, պարզապես չափից շատ կրկնօրինակ ջանքեր են ծախսվում ձևերի վավերացման վրա:

Այս ընդհանուր PHP ձևի վավերացման սցենարի մասին

Այս ընդհանուր PHP ձևի վավերացման սցենարը շատ հեշտ է դարձնում վավերացումներ ավելացնել ձեր ձևին:

Մենք ստեղծում և կապում ենք «վավերացման նկարագրիչների» մի շարք ձևի յուրաքանչյուր տարրի հետ: «Վավերացման նկարագրիչը» տող է, որը նշում է կատարվող վավերացման տեսակը: Օրինակ, «req» նշանակում է պարտադիր, «ալֆա» նշանակում է թույլատրել միայն այբբենական նիշերը և այլն:

Ձևի յուրաքանչյուր դաշտ կարող է ունենալ զրո, մեկ կամ մի քանի վավերացում: Օրինակ, մուտքագրումը չպետք է դատարկ լինի, պետք է լինի 25 նիշից պակաս, պետք է լինի ալֆա-թվային և այլն:

Դուք կարող եք կապել մի շարք վավերացման նկարագրիչներ յուրաքանչյուր մուտքագրման դաշտի համար ձևի մեջ:

Ներբեռնեք PHP ձևի վավերացման սցենարը

Դուք կարող եք ներբեռնել PHP ձևի վավերացման սցենարը ստորև.
Zip ֆայլը պարունակում է ձևի վավերացման սցենար formvalidator.php, փաստաթղթեր և օգտագործման նմուշներ:

Օգտագործելով PHP ձևի վավերացման սցենարը

1. Ներառեք formvalidator.php-ը ձեր ձևամշակման սցենարում
require_once «formvalidator.php»
2. Ստեղծեք FormValidator օբյեկտ և ավելացրեք ձևի վավերացման նկարագրիչներ:
$validator = new FormValidator(); $validator->addValidation("Name","req","Խնդրում ենք լրացնել անունը"); $validator->addValidation("Email","email", "Email-ի մուտքագրումը պետք է լինի վավեր էլփոստի արժեք"); $validator->addValidation("Email","req","Խնդրում ենք լրացնել Email");

Առաջին արգումենտը ձևի մուտքագրման դաշտի անվանումն է: Երկրորդ արգումենտը վավերացման նկարագրիչն է, որը ցույց է տալիս պահանջվող վավերացման տեսակը: Երրորդ արգումենտը սխալի հաղորդագրությունն է, որը պետք է ցուցադրվի, եթե վավերացումը ձախողվի:

3. Վավերացրեք ձևը` կանչելով ValidateForm() ֆունկցիան
if(!$validator->ValidateForm()) ( echo " Վավերացման սխալներ."; $error_hash = $validator->GetErrors(); foreach ($error_hash որպես $inpname => $inp_err) (echo "

$inpname՝ $inp_err

\n";))

Օրինակ

Ստորև բերված օրինակը ավելի պարզ կդարձնի գաղափարը

addValidation ("Անուն", "req", "Խնդրում ենք լրացնել անունը"); $validator->addValidation("Email","email", "Email-ի մուտքագրումը պետք է լինի վավեր էլփոստի արժեք"); $validator->addValidation("Email","req","Խնդրում ենք լրացնել Email"); if($validator->ValidateForm()) (echo "

Վավերացման հաջողություն:

"; $show_form=false; ) else (echo" Վավերացման սխալներ."; $error_hash = $validator->GetErrors(); foreach ($error_hash որպես $inpname => $inp_err) (echo "

$inpname՝ $inp_err

\n"; ) ) ) if(true == $show_form) (?>

Անուն: Էլ.

Անհատական ​​վավերացման ավելացում

Եթե ​​ցանկանում եք ավելացնել հատուկ վավերացում, որը նախատեսված չէ վավերացման նկարագրիչների կողմից, կարող եք դա անել: Ահա քայլերը.

1. Ստեղծեք դաս մաքսային վավերացման համար և անտեսեք DoValidate() ֆունկցիան

class MyValidator-ը ընդլայնում է CustomValidator ( ֆունկցիան DoValidate(&$formars,&$error_hash) ( if(stristr($formars["Comments"],"http://")) ( $error_hash["Comments"]="Չի թույլատրվում URL-ներ մեկնաբանություններում"; վերադարձնել կեղծ; ) վերադարձնել ճիշտ; ))

2. Ավելացրեք հատուկ վավերացման օբյեկտը

$validator = new FormValidator(); $validator->addValidation("Name","req","Խնդրում ենք լրացնել անունը"); $validator->addValidation("Email","email", "Email-ի մուտքագրումը պետք է լինի վավեր էլփոստի արժեք"); $validator->addValidation("Email","req","Խնդրում ենք լրացնել Email"); $custom_validator = նոր MyValidator(); $validator->AddCustomValidator($custom_validator);

Հարմարեցված վավերացման գործառույթը ավտոմատ կերպով կկանչվի այլ վավերացումներից հետո:

Վավերացման նկարագրիչների աղյուսակ

Ահա բոլոր վավերացման նկարագրիչների ցանկը.

Վավերացման նկարագրիչ	Օգտագործումը
պահանջ	Դաշտը չպետք է դատարկ լինի
maxlen=???	առավելագույնը ստուգում է մուտքագրված տվյալների երկարությունը: Օրինակ, եթե առավելագույն թույլատրելի չափը 25 է, վավերացման նկարագրությունը տվեք որպես «maxlen=25»:
մինլեն=???	ստուգում է մուտքագրված տողի երկարությունը պահանջվող նվազագույնին: օրինակ «minlen=5»
շրջան	Ստուգեք տվյալները, եթե դրանք պարունակում են այլ նիշեր, բացի այբբենական կամ թվային նիշերից
alnum_s	Թույլ է տալիս միայն այբբենական, թվային և բացատ նիշեր
թիվ	Ստուգեք թվային տվյալները
ալֆա	Ստուգեք այբբենական տվյալները:
ալֆա_ներ	Ստուգեք այբբենական տվյալները և բաց թողեք:
էլ	Դաշտը էլփոստի դաշտ է և ստուգեք տվյալների վավերականությունը:
lt=??? պակաս =???	Ստուգեք, որ տվյալները պակաս են փոխանցված արժեքից: Վավեր է միայն թվային դաշտերի համար: օրինակ. եթե արժեքը պետք է լինի 1000-ից փոքր, ապա վավերացման նկարագրությունը տվեք «lt=1000»
gt=??? ավելի մեծ =???	Ստուգեք, որ տվյալները ավելի մեծ են, քան փոխանցված արժեքը: Վավեր է միայն թվային դաշտերի համար: օրինակ. եթե արժեքը պետք է լինի 10-ից մեծ, ապա վավերացման նկարագրությունը տվեք որպես «gt=10»
regexp=???	Ստուգեք կանոնավոր արտահայտությամբ, որ արժեքը պետք է համապատասխանի կանոնավոր արտահայտությանը: օրինակ՝ «regexp=^(1.20)$»-ը թույլ է տալիս մինչև 20 այբբենական նիշ:
չընտրել=??	Այս վավերացման նկարագրիչը նախատեսված է ընտրված մուտքային տարրերի (ցուցակների) համար: Սովորաբար ընտրված ցուցակի վանդակները կունենան մեկ տարր՝ ասելով «Ընտրեք մեկը»: Օգտագործողը պետք է ընտրի այս տարբերակից այլ տարբերակ: Եթե արժեքըայս տարբերակի «Ընտրեք մեկը» է, վավերացման նկարագրությունը պետք է լինի «dontselect=Ընտրեք մեկը»:
dontselectchk	Այս վավերացման նկարագրիչը նախատեսված է վանդակների համար: Օգտագործողը չպետք է ընտրի նշված վանդակը: Տրամադրել արժեքըվանդակի փոխարեն ?? Օրինակ՝ dontselectchk=on
shouldselchk	Այս վավերացման նկարագրիչը նախատեսված է վանդակների համար: Օգտագործողը պետք է ընտրի նշված վանդակը: Նշեք վանդակի արժեքը ??-ի փոխարեն: Օրինակ, shouldselchk=on
dontselectradio	Այս վավերացման նկարագրիչը ռադիո կոճակների համար է: Օգտագործողը չպետք է ընտրի տվյալ ռադիոկոճակը։ Նշեք ռադիոկոճակի արժեքը ??-ի փոխարեն: Օրինակ, dontselectradio=NO
ընտրական ռադիո	Այս վավերացման նկարագրիչը ռադիո կոճակների համար է: Օգտագործողը պետք է ընտրի տվյալ ռադիոկոճակը: Նշեք ռադիոկոճակի արժեքը ??-ի փոխարեն: Օրինակ՝ selectradio=այո
սելմին=??	Ընտրեք վանդակի առնվազն n թվով վանդակ: Օրինակ՝ selmin=3
միայնակ	Պարտադիր է դարձնում ռադիոյի խումբը: Օգտագործողը պետք է ընտրի առնվազն մեկ տարր ռադիոխմբից:
eqelmnt=???	համեմատեք ձևի երկու տարր և համոզվեք, որ արժեքները նույնն են, օրինակ՝ «գաղտնաբառ» և «հաստատել գաղտնաբառը»: Փոխարինեք ??? մյուս մուտքային տարրի անվան հետ: Օրինակ՝ eqelmnt=confirm_pwd