Դատարկեք php-ի մի քանի փոփոխականներ: Սովորեք օգտագործել PHP դատարկ() ֆունկցիան

PHP-ում FALSE և NULL արժեքները և դրանց հետ կապված արժեքները տարբերվում են այն բանից, թե դրանք սովորաբար այլ լեզուներով են և ունեն իրենց ոչ ակնհայտ հատկանիշները:
Հոդվածում քննարկվում են այս հատկանիշները:
Սկսնակների համար սա կարող է օգտակար լինել փորձառու ընթերցողների համար ամբողջական պատկերը տեսնելու համար.

FALSE է Եթե հայտարարություններում

Համաձայն PHP-ի փաստաթղթերի՝ հետևյալ արժեքները ՖԱԼՍ են բուլյանին ձուլելուց հետո.

• բուլյան արժեքը ինքնին FALSE է
• դատարկ տող ("") և "0" տողը:
• դատարկ զանգված (զանգված) – array().
• զրոյական անդամ փոփոխականներով օբյեկտ (միայն PHP 4, այս հոդվածում ներառված չէ)
• հատուկ NULL արժեք (ներառյալ չսահմանված փոփոխականները)
• SimpleXML օբյեկտներ (այս հոդվածում ներառված չեն)

Սա նշանակում է, որ եթե այդպիսի արժեքները փոխանցվեն պայմանին.
եթե (…) արձագանքել «1»; այլ կերպ արձագանքել «0»;
ապա կտպվի «0» տողը:

Եթե ​​փոփոխականի արժեքը սահմանված չէ (չսահմանված), ապա կարող է տրվել նաև նախազգուշացում: Հիշեցնենք, որ պայմանի նախազգուշացումը կարելի է հեռացնել փոփոխականից առաջ @ գրելով։

Օրինակ:

Եթե ​​(@$undefVar) (…)
Բայց @-ը պետք է օգտագործել միայն ծայրահեղ դեպքերում, երբ լավ եք մտածել և այլ հարմար տարբերակներ չկան։ Տես isset() ֆունկցիան։

is_null() ֆունկցիան և լեզուն կառուցում են isset() և դատարկ()

is_null()-ը վերադարձնում է TRUE միայն այն փոփոխականների համար, որոնց չի վերագրվում որևէ արժեք կամ որոնց վերագրվում է NULL արժեքը:
isset()-ը վերադարձնում է մեկ առ մեկ բուլյան արժեքներ՝ համեմատած is_null()-ի հետ:
Եթե ​​փոփոխականին արժեք չի վերագրվում, ապա is_null()-ը թողարկում է նաև «Undefined variable» նախազգուշացում՝ ի տարբերություն isset(-ի), որը որևէ նախազգուշացում չի տալիս։
Հիշեցնենք, որ փոփոխականի արժեքը հեռացնելու համար կարող եք օգտագործել unset() ֆունկցիան։ Այս նպատակով կարող եք նաև նշանակել NULL արժեքը, որպեսզի խուսափեք կոմպիլյատորի նախազգուշացումներից, երբ փորձում եք կարդալ փոփոխականի արժեքը:

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

Լարի ներկայացում

Եկեք նայենք կեղծ հաստատունների լարային ներկայացմանը:
Օրինակ, կապակցումը արժեքները փոխակերպում է հետևյալ տողերի, որոնք ներկայացված են ստորև բերված աղյուսակում.

Լարերի փոխակերպման թեման ավելի մանրամասն նկարագրված է պաշտոնական կայքում՝ «Փոխակերպում տողի» պարբերության մեջ։

Համեմատության օպերատորներ

Անցնենք համեմատական ​​օպերատորներին:
Բոլոր false արժեքները վերադառնում են ճշմարիտ, ինչպես և սպասվում էր, երբ համեմատվում են FALSE-ի հետ՝ օգտագործելով «==» օպերատորը:
Բայց այստեղ չպետք է ապավինեք անցողիկությանը, երբ համեմատում եք կեղծ լարային հաստատունները միմյանց հետ:
Ահա կեղծ արժեքները համեմատելու ամբողջական աղյուսակ (գումարած նշանակում է աղյուսակի տարրեր, որոնք «!=» օպերատորի միջոցով համեմատելիս վերադարձնում են իրական արժեք.

$undef – փոփոխական, որին արժեք չի տրվել

Աղյուսակից կարելի է մի քանի հաճելի եզրակացություններ անել.
1. Եթե մենք գիտենք, որ մենք օգտագործում ենք միայն տողեր, ապա մենք կարող ենք ապահով համեմատել դրանք և չանհանգստանալ, որ «»-ը (դատարկ տողը) հավասար կլինի «0»-ի։
2. Զանգվածները երբեք հավասար չեն տողերի, ամբողջ թվերի կամ իրական թվերի:

Քանի որ տարբեր կեղծ հաստատունների տեսակները տարբեր են, դրանք տարբերելու համար կարող են օգտագործվել օպերատորների զույգ === և !==:
=== օպերատորը վերադարձնում է false բոլոր զույգ կեղծ արժեքների համար:
Վերադարձնում է իրական արժեքը միայն այն արգումենտների համար, որոնցից մեկին վերագրվում է NULL արժեքը, իսկ երկրորդին` ոչ մի արժեք:

Տարբերությունը NULL արժեքով և չսահմանված փոփոխականների միջև

=== օպերատորը թույլ է տալիս տարբերել բոլոր կեղծ արժեքները, բացառությամբ NULL արժեք ունեցող փոփոխականների այն փոփոխականներից, որոնց արժեք չի հատկացվել:

Նման փոփոխականները կարելի է տարբերել՝ օգտագործելով get_defined_vars() ֆունկցիան։

Եթե ​​Ձեզ անհրաժեշտ է որոշել, թե արդյոք արժեք է նշանակվել $var փոփոխականին, ապա դա անելու համար կարող է օգտագործվել հետևյալ կոդի հատվածը.
if (array_key_exists("var", get_defined_vars())) (echo "var is սահմանված"; // $var նշանակված է NULL ) else (echo "var is NOT սահմանված"; // $var սահմանված չէ կամ կարգավորված չէ ($ var) կոչվում էր)

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

Միշտ պետք է հիշել, որ PHP-ում երկու կեղծ արժեքներ կարող են հավասար չլինել միմյանց, և այն փոփոխականները, որոնք առաջին հայացքից տարբեր են թվում, համեմատելիս կարող են նույնը լինել: Նման անակնկալներից խուսափելու համար կարող եք օգտագործել === և !== օպերատորները:

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

Ժամանակակից ծրագրավորումը երկար ժամանակ հաջողությամբ շահարկում է անտիպ փոփոխականները: Փոփոխականի տեսակը հնարավոր չէ նախապես նշել և կարող է փոփոխվել ծրագրի կատարման ընթացքում:

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

Դատարկի ու չեղածի մասին

PHP դատարկ() ֆունկցիան isset() ֆունկցիայի հակառակն է և ունի օգտագործման հատուկ առանձնահատկություններ: Եթե ​​փոփոխական չկա, ապա առաջին ֆունկցիան դրական է արձագանքում և դրա արդյունքը ճշմարիտ է, իսկ երկրորդը՝ բացասական, այսինքն՝ նրա արժեքը կլինի false։

Ըստ սահմանման, isset()-ը նախատեսված է փոփոխականի առկայությունը ստուգելու համար: Կարևոր չէ, թե ինչ և ինչպես է նշանակվել փոփոխականը, գլխավորն այն է, որ այն գոյություն ունի և չի ոչնչացվում unset() ֆունկցիայի կողմից: Isset() ֆունկցիայի արդյունքը կլինի դրական՝ true: Կարևոր է հիշել, որ եթե $iVar = 0; ապա isset($iVar)-ը կլինի ճշմարիտ, բայց դատարկ($iVar) նույնպես ճշմարիտ կլինի:

Առաջին դեպքում արդյունքը նշանակում է, որ փոփոխականը գոյություն ունի, երկրորդ դեպքում՝ փոփոխականը դատարկ է, այսինքն՝ «0» արժեքը ցանկացած ձևով, լինի դա տող («0»), թե թիվ (կոտորակային - 0.0 կամ ամբողջ թիվը՝ 0) նույնն է՝ դատարկ ($iVar) ճիշտ կլինի:

Անվտանգության և հսկողության մասին

Պրակտիկան ցույց է տալիս, որ անտիպ լեզուները շատ ավելի մեծ ազատություն են տալիս ծրագրավորողին, բայց ենթադրենք, որ նրա վերաբերմունքը ալգորիթմի վրա աշխատելու նկատմամբ ավելի պատասխանատու է:

PHP-ն առաջարկում է ժամանակակից շարահյուսություն, որն աջակցում է հաստատված իմաստաբանությանը, ունի քիչ սխալներ, բայց պահանջում է զգույշ ուշադրություն: Օրինակ, ցանկացած ֆունկցիա կանչելու համար պահանջվում են որոշակի քանակի պարամետրեր:

Ֆունկցիան կանչելիս ամենևին էլ պարտադիր չէ փոխանցել բոլոր պարամետրերը, կարող եք փոխանցել միայն դրանց մի զգալի մասը. «Պետք է» ֆունկցիան ստուգի բոլոր պարամետրերի առկայությունը և առկայությունը։ Նրանք, որոնք բացակայում են կամ ունեն սխալ արժեքներ, պետք է վերականգնվեն նորմալ վիճակում և նշանակվեն պահանջվող արժեքները:

Այս համատեքստում PHP դատարկ() ֆունկցիան էական է: Արտահայտություն:

$a = «1;2» + 20

$a փոփոխականին կնշանակի 21 արժեքը, քանի որ արտահայտության առաջին մասը կներկայացվի որպես 1, իսկ երկրորդը կլինի 20։

Արդյունքը կլինի տիպի համար, և PHP ֆունկցիան դատարկ ($a) կունենա արդյունք՝ false, այսինքն՝ $a փոփոխականը դատարկ չէ։

Այս համատեքստում ունենալով գործառույթ.

funcTest ($a = 0, $b = 20)

Զանգահարելիս.

$res = funcTest ($aVal, $bVal)

կունենա ցանկալին, այսինքն՝ ֆունկցիայի արդյունքը։ Եվ երբ կոչվում է.

• $res = funcTest ($aVal. $bVal)

Ֆունկցիայի մարմինը պարունակում է միայն մեկ պարամետր՝ «$aVal . $bVal» արժեքով և, ամենայն հավանականությամբ, այս պարամետրը կմեկնաբանվի որպես նիշերի տող:

PHP դատարկ() օբյեկտների և զանգվածների համար

Լեզվի շարահյուսությունն ունի բավարար քանակությամբ կոնստրուկտներ և գործառույթներ առարկաների և զանգվածների հետ աշխատելու համար, բայց դրանց գոյության և արժեքի առկայության ստուգման տեսանկյունից, փոփոխականներից առանձնահատուկ տարբերություններ չկան:

PHP դատարկ (զանգված) - համարժեք է դատարկ (պարզ փոփոխական) կանչելուն: Այնուամենայնիվ, կան շատ կարևոր նկատառումներ օբյեկտների վերաբերյալ: Ինչ վերաբերում է օբյեկտի (isset) առկայության ստուգմանը, ապա հարցը դժվար թե իմաստ ունենա։ Ինչ վերաբերում է PHP դատարկ() ֆունկցիային, ապա դրա օգտագործման նպատակահարմարությունը մնում է կասկածելի։

Օբյեկտ-կողմնորոշված ​​ծրագրավորման տրամաբանության համաձայն՝ օբյեկտն ունի իր բովանդակությունը և մեթոդների իր փաթեթը: Միայն օբյեկտն ինքը կարող է ասել՝ դատարկ է, թե դատարկ չէ, բայց ոչ երրորդ կողմի ֆունկցիա, նույնիսկ եթե այն լեզվի շարահյուսության մաս է։

Օբյեկտը և նրա ֆունկցիան դատարկ ()

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

Ո՞ր մակարդակում պետք է այստեղ օգտագործեմ PHP դատարկ օբյեկտի ֆունկցիան: «Կադրային» մակարդակում ամեն ինչ կա, եթե նույնիսկ մեկ աշխատող չկա։ «Աշխատակից» մակարդակում օբյեկտն արդեն գոյություն ունի, նույնիսկ եթե այն ամբողջությամբ լցված չէ: Ոչ ամբողջությամբ լցված օբյեկտը կարող է դասակարգվել որպես դատարկ օբյեկտ: Կադրերի սեղանին դրանից ոչ մի օգուտ չկա։

Կախված ձեր ծրագրավորման ոճից, PHP-ի դատարկ() և isset() ֆունկցիաները շատ կարևոր են անվտանգ և հուսալի ալգորիթմ ստեղծելու համար, սակայն օբյեկտների համար դեռ ավելի լավ է ունենալ դատարկ()-ի տարբերակ, որը սահմանված է իր բովանդակությամբ:

փոփոխական տող (12)

Ես ունեմ isNotEmpty ֆունկցիա, որը վերադարձնում է true, եթե տողը դատարկ չէ, և false, եթե տողը դատարկ է: Պարզեցի, որ դատարկ տող անցնելու դեպքում չի ստացվում։

Գործառույթը isNotEmpty($input) ($strTemp = $input; $strTemp = trim($strTemp); if(strTemp != "") //Փորձել է նաև սա "if(strlen($strTemp) > 0)" (վերադարձնել ճշմարիտ ) վերադարձնել կեղծ ;

Տողը ստուգվում է՝ օգտագործելով isNotEmpty՝

If(isNotEmpty($userinput["phoneNumber"])) ( //հաստատել հեռախոսահամարը) else (echo "Հեռախոսահամարը մուտքագրված չէ
"; }

Եթե ​​տողը դատարկ է, այլապես չի կատարվում, ես չեմ հասկանում, թե ինչու, ինչ-որ մեկը կարո՞ղ է մի փոքր լույս սփռել դրա վրա, խնդրում եմ:

Պատասխանները

եթե ունեք դաշտ, որը կոչվում է serial_number և ցանկանում եք ստուգել դատարկ տարածքի առկայությունը

$serial_number = trim ($_POST); $q="ընտրել * ապրանքից, որտեղ user_id="$_SESSION""; $rs=mysql_query ($q); while($row=mysql_fetch_assoc($rs))( if(դատարկ($_POST["արդուկներ"]))($irons=$row["product1"];)

Այս կերպ դուք կարող եք կրկնել բոլոր օղակների միջով մեկ այլ դատարկ ֆունկցիա ունեցող օղակում

Դե, պատասխանելու փոխարեն (կարծում եմ, դուք արդեն լուծել եք ձեր խնդիրը), ես ձեզ խորհուրդ կտամ.

Ես չգիտեմ բոլորի մասին, բայց ես անձամբ շատ եմ նյարդայնանում, երբ տեսնում եմ նման բան.

Եթե ​​(<>) ( return true; ) return false;

սա պահանջում է էլեգանտ «վերադարձ» (<>); « Խնդրում ենք միշտ նայեք ձեր կոդը և հեռացնեք այս տրամաբանությունը: Համար յուրաքանչյուրըՁեզ անհրաժեշտ չէ IF հայտարարությունը:

Ես պարզապես գրում եմ իմ սեփական is_string ֆունկցիան՝ տեսակները ստուգելու համար, իսկ strlen՝ երկարությունը:

Գործառույթ ცარიელიStr($str) ( վերադարձ is_string($str) && strlen($str) === 0;) տպել դատարկ Str("") ? "դատարկ" : "դատարկ չէ"; // դատարկ

ԽՄԲԱԳՐԵԼ. Դուք կարող եք նաև օգտագործել կրճատման ֆունկցիան՝ ստուգելու համար, թե արդյոք տողը չի պարունակում:

Is_string($str) && strlen(trim($str)) === 0;

PHP-ն ունի ներկառուցված ֆունկցիա, որը կոչվում է vala() Թեստը կատարվում է՝ մուտքագրելով if(empty($string))(...) php.net հղում՝ php դատարկ:

Դուք ունեք պատասխանը, բայց ձեր դեպքում կարող եք օգտագործել

Վերադարձեք դատարկ ($input);

Վերադարձնել is_string($input);

Պարզ խնդիր. Փոփոխություն:

Եթե ​​(strTemp! = "")

Եթե ​​($strTemp != "")

Թերևս կարող եք նաև փոխել այն հետևյալի.

Եթե ​​($strTemp !== "")

Քանի որ != ""-ը կվերադարձնի ճշմարիտ, եթե դուք անցնեք 0 թվային թիվը և մի քանի այլ դեպքեր PHP-ի ավտոմատ տիպի փոխակերպման պատճառով:

Հիշեք նաև, որ PHP-ն արդեն ունի դատարկ() ֆունկցիա:

PHP-ն դատարկ տողը գնահատում է false, այնպես որ կարող եք պարզապես օգտագործել.

If (trim($userinput["phoneNumber"])) ( // վավերացնել հեռախոսահամարը ) else (echo «Հեռախոսահամարը մուտքագրված չէ
"; }

Ես միշտ օգտագործում եմ regex դատարկ տողի առկայությունը ստուգելու համար, որը թվագրվում է CGI/Perl-ի, ինչպես նաև Javascript-ի ժամանակներից, այնպես որ, ինչու ոչ, օրինակ, PHP (թեև չփորձարկված)

Վերադարձնել preg_match ("/\S/", $input);

Որտեղ \S-ը ներկայացնում է ցանկացած նիշ առանց բացատների

Պարզապես օգտագործեք strlen() ֆունկցիան

Եթե ​​(strlen($s)) ( // դատարկ չէ)

Վերջերս նույն հարցը տվեցի ինքս ինձ.
Կան մի քանի հնարավոր լուծումներ, ահա 3 վավեր լուծումներ.

• s.indexOf(մեկնարկիչ) === 0
• s.substr(0, starter.length) === մեկնարկիչ
• s.lastIndexOf(սկիզբ, 0) === 0 (ավելացվել է Մարկ Բայերի պատասխանը դիտելուց հետո)

օգտագործելով հանգույց.

Ֆունկցիան startsWith(s, starter) ( (var i = 0,cur_c; i) համար< starter.length; i++) { cur_c = starter[i]; if (s[i] !== starter[i]) { return false; } } return true; }

Ես չեմ հանդիպել վերջին լուծմանը, որը ներառում է օղակի օգտագործումը:
Զարմանալիորեն, այս լուծումը զգալիորեն գերազանցում է առաջին 3-ին:
Ահա jsperf թեստը, որը ես անցա այս եզրակացության գալու համար՝ http://jsperf.com/startswith2/2

ps: ecmascript 6 (ներդաշնակություն) ներկայացնում է իր սեփական startsWith մեթոդը լարերի համար:
Մտածեք, թե որքան ժամանակ կխնայվեր, եթե մտածեին առաջին տարբերակում ներառել այս այդքան անհրաժեշտ մեթոդը:

Թարմացնել

Նկատի ունեցեք, որ Սթիվը ներառել է 2 օղակի օպտիմալացում, երկուսից առաջինը ցույց տվեց ավելի լավ կատարում, այնպես որ ես կտեղադրեմ այդ կոդը ստորև.

Ֆունկցիան startsWith2(str, նախածանց) (եթե (str.length< prefix.length) return false; for (var i = prefix.length - 1; (i >= 0) && (str[i] === նախածանց[i]); --i) շարունակել; վերադառնալ i< 0; }

PHP-ում FALSE և NULL արժեքները և դրանց հետ կապված արժեքները տարբերվում են այն բանից, թե դրանք սովորաբար այլ լեզուներով են և ունեն իրենց ոչ ակնհայտ հատկանիշները:
Հոդվածում քննարկվում են այս հատկանիշները:
Սկսնակների համար սա կարող է օգտակար լինել փորձառու ընթերցողների համար ամբողջական պատկերը տեսնելու համար.

FALSE է Եթե հայտարարություններում

Համաձայն PHP-ի փաստաթղթերի՝ հետևյալ արժեքները ՖԱԼՍ են բուլյանին ձուլելուց հետո.

• բուլյան արժեքը ինքնին FALSE է
• դատարկ տող ("") և "0" տողը:
• դատարկ զանգված (զանգված) – array().
• զրոյական անդամ փոփոխականներով օբյեկտ (միայն PHP 4, այս հոդվածում ներառված չէ)
• հատուկ NULL արժեք (ներառյալ չսահմանված փոփոխականները)
• SimpleXML օբյեկտներ (այս հոդվածում ներառված չեն)

Սա նշանակում է, որ եթե այդպիսի արժեքները փոխանցվեն պայմանին.
եթե (…) արձագանքել «1»; այլ կերպ արձագանքել «0»;
ապա կտպվի «0» տողը:

Եթե ​​փոփոխականի արժեքը սահմանված չէ (չսահմանված), ապա կարող է տրվել նաև նախազգուշացում: Հիշեցնենք, որ պայմանի նախազգուշացումը կարելի է հեռացնել փոփոխականից առաջ @ գրելով։

Օրինակ:

Եթե ​​(@$undefVar) (…)
Բայց @-ը պետք է օգտագործել միայն ծայրահեղ դեպքերում, երբ լավ եք մտածել և այլ հարմար տարբերակներ չկան։ Տես isset() ֆունկցիան։

is_null() ֆունկցիան և լեզուն կառուցում են isset() և դատարկ()

is_null()-ը վերադարձնում է TRUE միայն այն փոփոխականների համար, որոնց չի վերագրվում որևէ արժեք կամ որոնց վերագրվում է NULL արժեքը:
isset()-ը վերադարձնում է մեկ առ մեկ բուլյան արժեքներ՝ համեմատած is_null()-ի հետ:
Եթե ​​փոփոխականին արժեք չի վերագրվում, ապա is_null()-ը թողարկում է նաև «Undefined variable» նախազգուշացում՝ ի տարբերություն isset(-ի), որը որևէ նախազգուշացում չի տալիս։
Հիշեցնենք, որ փոփոխականի արժեքը հեռացնելու համար կարող եք օգտագործել unset() ֆունկցիան։ Այս նպատակով կարող եք նաև նշանակել NULL արժեքը, որպեսզի խուսափեք կոմպիլյատորի նախազգուշացումներից, երբ փորձում եք կարդալ փոփոխականի արժեքը:

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

Լարի ներկայացում

Եկեք նայենք կեղծ հաստատունների լարային ներկայացմանը:
Օրինակ, կապակցումը արժեքները փոխակերպում է հետևյալ տողերի, որոնք ներկայացված են ստորև բերված աղյուսակում.

Լարերի փոխակերպման թեման ավելի մանրամասն նկարագրված է պաշտոնական կայքում՝ «Փոխակերպում տողի» պարբերության մեջ։

Համեմատության օպերատորներ

Անցնենք համեմատական ​​օպերատորներին:
Բոլոր false արժեքները վերադառնում են ճշմարիտ, ինչպես և սպասվում էր, երբ համեմատվում են FALSE-ի հետ՝ օգտագործելով «==» օպերատորը:
Բայց այստեղ չպետք է ապավինեք անցողիկությանը, երբ համեմատում եք կեղծ լարային հաստատունները միմյանց հետ:
Ահա կեղծ արժեքները համեմատելու ամբողջական աղյուսակ (գումարած նշանակում է աղյուսակի տարրեր, որոնք «!=» օպերատորի միջոցով համեմատելիս վերադարձնում են իրական արժեք.

$undef – փոփոխական, որին արժեք չի տրվել

Աղյուսակից կարելի է մի քանի հաճելի եզրակացություններ անել.
1. Եթե մենք գիտենք, որ մենք օգտագործում ենք միայն տողեր, ապա մենք կարող ենք ապահով համեմատել դրանք և չանհանգստանալ, որ «»-ը (դատարկ տողը) հավասար կլինի «0»-ի։
2. Զանգվածները երբեք հավասար չեն տողերի, ամբողջ թվերի կամ իրական թվերի:

Քանի որ տարբեր կեղծ հաստատունների տեսակները տարբեր են, դրանք տարբերելու համար կարող են օգտագործվել օպերատորների զույգ === և !==:
=== օպերատորը վերադարձնում է false բոլոր զույգ կեղծ արժեքների համար:
Վերադարձնում է իրական արժեքը միայն այն արգումենտների համար, որոնցից մեկին վերագրվում է NULL արժեքը, իսկ երկրորդին` ոչ մի արժեք:

Տարբերությունը NULL արժեքով և չսահմանված փոփոխականների միջև

=== օպերատորը թույլ է տալիս տարբերել բոլոր կեղծ արժեքները, բացառությամբ NULL արժեք ունեցող փոփոխականների այն փոփոխականներից, որոնց արժեք չի հատկացվել:

Նման փոփոխականները կարելի է տարբերել՝ օգտագործելով get_defined_vars() ֆունկցիան։

Եթե ​​Ձեզ անհրաժեշտ է որոշել, թե արդյոք արժեք է նշանակվել $var փոփոխականին, ապա դա անելու համար կարող է օգտագործվել հետևյալ կոդի հատվածը.
if (array_key_exists("var", get_defined_vars())) (echo "var is սահմանված"; // $var նշանակված է NULL ) else (echo "var is NOT սահմանված"; // $var սահմանված չէ կամ կարգավորված չէ ($ var) կոչվում էր)

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

Միշտ պետք է հիշել, որ PHP-ում երկու կեղծ արժեքներ կարող են հավասար չլինել միմյանց, և այն փոփոխականները, որոնք առաջին հայացքից տարբեր են թվում, համեմատելիս կարող են նույնը լինել: Նման անակնկալներից խուսափելու համար կարող եք օգտագործել === և !== օպերատորները:

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

Թեստավորումն իրականացվել է PHP 5.3.1-ի վրա:

Լրացուցիչ հղումներ

1. PHP տեսակի համեմատական ​​աղյուսակներ.
2. MySQl Null և Empty Strings PHP-ի համատեքստում:

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

Եթե ​​լարերի հետ աշխատելիս անհրաժեշտ է ստուգել, ​​թե արդյոք տողը դատարկ է, սկսնակ ծրագրավորողները սովորաբար օգտագործում են գործառույթը. strlen (). Այս ֆունկցիան բավականին արագ է, քանի որ այն չի կատարում որևէ հաշվարկ, այլ պարզապես վերադարձնում է տողի երկարության արդեն հայտնի արժեքը, որը հասանելի է zval-ում (PHP-ն օգտագործում է C կառուցվածք՝ փոփոխականները պահելու համար): Բայց այնուամենայնիվ, քանի որ strlen ()- սա գործառույթ է, այն մի փոքր դանդաղ է, քանի որ այն կանչելիս պահանջում է մի քանի գործողություններ, ինչպիսիք են փոքրատառի վերածելը և հեշ աղյուսակի որոնումը: Որոշ դեպքերում կարող եք ավելացնել ձեր կոդի կատարման արագությունը՝ օգտագործելով դատարկ ()..., Ինչպես նաեւ դատարկ ()Դուք դեռ կարող եք մի փոքր օպտիմալացնել այն:

Օրինակ բերենքՕրինակ ստուգելով պատկերի ուղին, ֆունկցիան ստուգում է՝ արդյոք ուղին դատարկ է, այնուհետև այն փոխարինում է այլ ճանապարհով, օրինակ՝ «images/noimage.jpg»:

Եվ այսպես, ամբողջ առաջադրանքը հանգում է նրան, որ ստուգվի, թե արդյոք տողի տիպի փոփոխականը դատարկ է: Փորձենք 4 եղանակ.

• if(strlen($img_path)>0)
• if ($img_path (0))
• if (դատարկ ($img_path))
• և ևս մեկ ճանապարհ վերջի համար:

Եվ այսպես, մենք առաջին ձևով կգրենք.

Check_image_path($img_path) ֆունկցիան ( if (strlen ($img_path ) >0 ) ( $img_path = "images/noimage.jpg" ; ) վերադարձնել $img_path ;)

Եկեք անցկացնենք թեստավորում, թեստի միջին ժամանակը տևեց 1.43795800209 վրկ.

Մտածելով դրա մասին մի փոքր ավելի... Դուք կարող եք անմիջապես մուտք գործել տողի առաջին նիշը, այլ ոչ թե ամբողջ տողը: Եթե ​​առաջին նիշն այնտեղ է, ապա տողը դատարկ չէ: Տողում առաջին նիշը համարակալված է «0»-ով:

Check_image_path($img_path) ֆունկցիան ( if ($img_path ( 0 ) ) ( $img_path = "images/noimage.jpg" ; ) վերադարձնել $img_path ; )

միջին թեստի ժամանակը 1.19431300163 վրկ., խաղացած ժամանակի 17%-ը

Եկեք հիմա փորձենք գրել դատարկ()-ի միջոցով.

Check_image_path($img_path) ֆունկցիան ( if (դատարկ ($img_path) ) ( $img_path = "images/noimage.jpg" ; ) վերադարձնել $img_path ;)

միջին թեստի ժամանակը 1.1341319084 վրկ., ժամանակի 5%-ը խաղացել է նախորդ օրինակից

Հիմա նայենք մեր վերևում գտնվող նախավերջին և վերջին օրինակին։ Տեսնենք, թե ինչպես կարելի է դա համատեղել: մտածիր... էլ ինչպե՞ս կարող ես օպտիմալացնել:

Check_image_path($img_path) ֆունկցիան ( if (դատարկ ($img_path ( 0 ) ) ) ( $img_path = "images/noimage.jpg" ; ) վերադարձնել $img_path ;)

միջին թեստի ժամանակը 1.07465314865 վրկ., և նորից մենք հաղթեցինք ժամանակի 5%-ում...

Ինչպե՞ս է այն աշխատում և ինչու է այն ավելի արագ: Եվ ահա $img_path (0)վերադարձնում է առաջին նիշը... և այնուհետև ֆունկցիան դատարկ ()ստուգում է դատարկ տողի առկայությունը... նախորդ օրինակից տարբերությունն այն է, որ ֆունկցիային փոխանցվում է միայն մեկ նիշ, և ոչ ամբողջ տողը: Այսպիսով, առաջին օրինակից մինչև վերջինը մենք հաղթեցինք 25% ժամանակ.