Ծրագրավորման յուրաքանչյուր լեզու ունի ենթածրագրեր: C-ում դրանք կոչվում են ֆունկցիաներ, անսամբլի լեզվով դրանք կոչվում են ենթածրագրեր, իսկ Պասկալում գոյություն ունեն նույնիսկ երկու տեսակի ենթածրագրեր՝ պրոցեդուրաներ և ֆունկցիաներ։
Ենթակարգը ծրագրի հատուկ նախագծված հատվածն է, որը կարող է հասանելի լինել ծրագրի ցանկացած կետից: Ենթածրագրերը մեծապես պարզեցնում են ծրագրավորողների կյանքը՝ բարելավելով ելակետային կոդի ընթեռնելիությունը, ինչպես նաև նվազեցնելով այն, քանի որ առանձին կոդերի հատվածները մի քանի անգամ գրելու կարիք չունեն։
PHP-ում այս ռեժիմները օգտագործողի կողմից սահմանված գործառույթներ են:
Բացի PHP-ի ներկառուցված գործառույթներից, հաճախ անհրաժեշտություն է առաջանում ստեղծել հատուկ գործառույթներ, որոնք կատարում են հատուկ առաջադրանքներ:
Հատուկ գործառույթների ստեղծում
Օգտատիրոջ կողմից սահմանված գործառույթը կարող է հայտարարվել ծրագրի (սկրիպտի) ցանկացած մասում, մինչև այն առաջին անգամ օգտագործվի: Եվ որևէ նախնական հայտարարության կարիք չկա, ինչպես ծրագրավորման այլ լեզուներում, մասնավորապես, C-ում: PHP-ում կիրառվող մոտեցման առավելությունները հետևյալն են.
Հասնելով օգտագործողի կողմից սահմանված ֆունկցիայի սահմանմանը, թարգմանիչը կստուգի սահմանման ճիշտությունը և ֆունկցիայի սահմանումը կվերածի ներքին ներկայացման, բայց ինքը չի թարգմանի կոդը: Եվ ճիշտ է, ինչու հեռարձակման կոդ, որը կարող է ընդհանրապես չօգտագործվել: Ֆունկցիաների հայտարարագրման շարահյուսությունը հետևյալն է.
ֆունկցիայի անվանումը (արգումենտ1[=արժեք1],...,արգումենտ1[=արժեք1])
{
մարմնի_ֆունկցիա
}
Գործառույթի հռչակագիրը սկսվում է ֆունկցիայի բառով ֆունկցիան, ապա հաջորդում է ֆունկցիայի անունը, ֆունկցիայի անունից հետո փակագծերում արգումենտների ցանկ է։ Ֆունկցիոնալ մարմինը փակված է գանգուր փակագծերի մեջ և կարող է պարունակել ցանկացած թվով հայտարարություններ:
Գործառույթների անունների պահանջները.
- Ֆունկցիաների անունները կարող են պարունակել ռուսերեն տառեր, սակայն խորհուրդ չի տրվում տալ ռուսերեն տառերից բաղկացած գործառույթների անուններ.
- Ֆունկցիաների անունները չպետք է պարունակեն բացատներ.
- Օգտատիրոջ կողմից սահմանված յուրաքանչյուր ֆունկցիայի անունը պետք է եզակի լինի: Միևնույն ժամանակ, հարկ է հիշել, որ գործառույթներ հայտարարելիս և դրանց մուտք գործելիս գործը հաշվի չի առնվում։ Այսինքն, օրինակ, funct() և FUNCT() ֆունկցիաները ունեն նույն անունները.
- Գործառույթներին կարող են տրվել նույն անունները, ինչ փոփոխականները, բայց առանց անունների սկզբում $ նշանի։
Օգտագործողի կողմից սահմանված գործառույթներով վերադարձված արժեքների տեսակները կարող են լինել ցանկացած տեսակի: Օգտատիրոջ գործառույթների արդյունքը հիմնական ծրագրին (սկրիպտ) փոխանցելու համար օգտագործվում է կոնստրուկցիան վերադարձ. Եթե ֆունկցիան ոչինչ չի վերադարձնում, ապա կոնստրուկտը վերադարձմի նշեք. Դիզայն վերադարձկարող է վերադարձնել ցանկացած բան, ներառյալ զանգվածները:
Ահա մաքսային գործառույթների օգտագործման օրինակներ:
Անկախ նրանից, թե որքան ենք մենք օգտագործում PHP, որոշ գործառույթներ դեռ հայտնվում են, որոնց մասին մենք երբեք չենք էլ լսել: Դրանցից մի քանիսը մեզ շատ օգտակար կլինեն։ Ես ստեղծել եմ օգտակար գործառույթների փոքր ցուցակ, որոնք պետք է լինեն յուրաքանչյուր PHP ծրագրավորողի զինանոցում։
1. Փոփոխական թվով արգումենտներով ֆունկցիաների ստեղծում
Ամենայն հավանականությամբ, դուք արդեն գիտեք, որ PHP-ն թույլ է տալիս մեզ ստեղծել գործառույթներ կամընտիր արգումենտներով։ Այժմ ես ցույց կտամ մի ֆունկցիա, որի դեպքում արգումենտների թիվը կարող է տարբեր լինել դեպքից դեպք:
Բայց նախ, եկեք հիշենք, թե ինչպես ենք մենք ստեղծում գործառույթներ սովորական ձևով.
// ֆունկցիա երկու կամընտիր պարամետրերով function foo($arg1 = "", $arg2 = "") ( echo "arg1: $arg1\n"; echo "arg2: $arg2\n"; ) foo("բարև", «աշխարհ»); /* դուրս կգա՝ arg1: hello arg2: world */ foo(); /* դուրս կգա՝ arg1: arg2: */
Հիմա եկեք տեսնենք, թե ինչպես կարող եք գրել ֆունկցիա անսահմանափակ թվով արգումենտներով: Դա անելու համար կօգտագործվի func_get_args() մեթոդը՝
// մի նշեք արգումենտներ ֆունկցիան foo() ( // վերադարձնում է փոխանցված արգումենտների զանգված $args = func_get_args(); foreach ($args որպես $k => $v) ( echo «arg».($k+1) ." : $v\n" ) ) foo(); /* ոչինչ չի թողարկի */ foo("բարև"); /*-ը կտպագրի arg1՝ բարև */ foo("բարև", "աշխարհ", "կրկին"); /* տպելու է arg1:բարև arg2:աշխարհ arg3:կրկին */
2. Օգտագործեք Glob() ֆայլերը որոնելու համար
Հաճախ գործառույթների անունները խոսում են իրենց մասին: Նույնը չի կարելի ասել glob() ֆունկցիայի համար։
Առանց շատ մանրամասնելու, դրա ֆունկցիոնալությունը նման է scandir() մեթոդին: Այն թույլ է տալիս Ձեզ գտնել անհրաժեշտ ֆայլը՝ օգտագործելով ձևանմուշ.
// գտնել բոլոր php ֆայլերը $files = glob("*.php"); print_r ($ ֆայլեր); /* դուրս կգա՝ Array ( => phptest.php => pi.php => post_output.php => test.php) */
Մի քանի տեսակի ֆայլեր գտնելու համար հարկավոր է գրել այսպես.
// գտնել բոլոր php և txt ֆայլերը $files = glob("*.(php,txt)", GLOB_BRACE); print_r ($ ֆայլեր); /* ելք՝ զանգված ( => phptest.php => pi.php => post_output.php => test.php => log.txt => test.txt) */
Դուք կարող եք նաև նշել ուղին ձևանմուշում.
$files = glob("../images/a*.jpg"); print_r ($ ֆայլեր); /* ելք՝ զանգված ( => ../images/apple.jpg => ../images/art.jpg) */
Փաստաթղթի ամբողջական ուղին ստանալու համար օգտագործեք realpath() մեթոդը.
$files = glob("../images/a*.jpg"); // Կիրառել «realpath» ֆունկցիան զանգվածի յուրաքանչյուր տարրի վրա $files = array_map("realpath",$files); print_r ($ ֆայլեր); /* դուրս կգա՝ Array ( => C:\wamp\www\images\apple.jpg => C:\wamp\www\images\art.jpg) */
3. Տեղեկություններ օգտագործված հիշողության մասին
Եթե հետևեք ձեր սկրիպտների կողմից սպառված հիշողության քանակին, հավանաբար դրանք ավելի հաճախ կօպտիմալացնեք:
PHP-ն ունի հիշողության հետևելու հզոր գործիք: Բեռները կարող են տարբեր լինել սցենարի տարբեր մասերում: Ներկայումս օգտագործվող հիշողության արժեքը ստանալու համար մենք պետք է օգտագործենք memory_get_usage() մեթոդը: Օգտագործված հիշողության առավելագույն քանակը շտկելու համար օգտագործեք memory_get_peak_usage()
Echo "Initial. ".memory_get_usage()." բայթ \n"; /* Նախնական՝ 361400 բայթ */ // տալ փոքր բեռ ($i = 0; $i< 100000; $i++) { $array = md5($i); } // и ещё for ($i = 0; $i < 100000; $i++) { unset($array[$i]); } echo "Final: ".memory_get_usage()." bytes \n"; /* Final: 885912 bytes */ echo "Peak: ".memory_get_peak_usage()." bytes \n"; /* Peak: 13687072 bytes */
4. Պրոցեսորի տեղեկատվությունը
Դա անելու համար հարկավոր է օգտագործել getrusage() մեթոդը։ Բայց հիշեք, որ այս ֆունկցիան Windows-ում չի աշխատի:
Print_r(getrusage()); /* տպում է զանգված ( => 0 => 0 => 2 => 3 => 12692 => 764 => 3864 => 94 => 0 => 1 => 67 => 4 => 0 => 0 => 0 => 6269 => 0) */
Վերոնշյալ պատկերը պարզ կլինի նրանց համար, ովքեր ունեն համակարգի կառավարման փորձ: Մնացած բոլորի համար մենք առաջարկում ենք սղագրություն.
- ru_oublock՝ բլոկ գրելու գործողությունների քանակը
- ru_inblock՝ բլոկի ընթերցման գործողությունների քանակը
- ru_msgsnd. ուղարկված հաղորդագրությունների քանակը
- ru_msgrcv. ստացված հաղորդագրությունների քանակը
- ru_maxrss. չէջադրված հավաքածուի առավելագույն չափը
- ru_ixrss. ընդհանուր հիշողության ընդհանուր քանակը
- ru_idrss. չհամօգտագործված տվյալների ընդհանուր ծավալը
- ru_minflt. օգտագործված հիշողության էջերի քանակը
- ru_majflt. էջի բացակայող սխալների քանակը
- ru_nsignals. ստացված ազդանշանների քանակը
- ru_nvcsw. գործընթացի կողմից համատեքստի փոխարկիչների քանակը
- ru_nivcsw. համատեքստի հարկադիր անջատիչների քանակը
- ru_nswap. էջավորման ժամանակ սկավառակի մուտքերի քանակը
- ru_utime.tv_usec. գործառնական ժամանակը օգտագործողի ռեժիմում (միկրովայրկյաններ)
- ru_utime.tv_sec. գործառնական ժամանակը օգտագործողի ռեժիմում (վայրկյաններ)
- ru_stime.tv_usec. աշխատանքի ժամանակը արտոնյալ ռեժիմում (միկրովայրկյաններ)
- ru_stime.tv_sec. աշխատանքի ժամանակը արտոնյալ ռեժիմում (վայրկյաններ)
Որպեսզի պարզեք, թե ձեր պրոցեսորի ինչ ռեսուրսներ են օգտագործվում սկրիպտը, ձեզ անհրաժեշտ է «օգտագործողի ժամանակ» (օգտագործողի ժամանակ) և «համակարգի ժամանակ» (արտոնյալ ռեժիմի ժամանակ) արժեքը: Արդյունքը կարող եք ստանալ ինչպես վայրկյանների, այնպես էլ միկրովայրկյանների ընթացքում: Վայրկյանների ընդհանուր թիվը տասնորդական թվի փոխարկելու համար անհրաժեշտ է միկրովայրկյանների արժեքը բաժանել 1 միլիոնի և արժեքին ավելացնել վայրկյանների արժեքը:
Մի տեսակ շփոթեցնող է: Ահա մի օրինակ.
// հանգստանալ 3 վայրկյան քնել (3); $data = getrusage(); echo «Օգտվողի ժամանակը.». ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo «Համակարգի ժամանակ.». ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* տպում է Օգտագործողի ժամանակը՝ 0.011552 Համակարգի ժամանակը՝ 0 */
Թեև սցենարի գործարկումը տևեց մոտ 3 վայրկյան, պրոցեսորը շատ ծանրաբեռնված չէր: Փաստն այն է, որ երբ կոչվում է (քնել), սցենարը գործնականում չի սպառում պրոցեսորային ռեսուրսներ: Ընդհանուր առմամբ, կան բազմաթիվ առաջադրանքներ, որոնք զգալի ժամանակ են պահանջում, բայց չեն օգտագործում պրոցեսորը: Օրինակ՝ սպասել սկավառակի հետ կապված գործողությունների: Այսպիսով, դուք միշտ չէ, որ օգտագործում եք պրոցեսորի ժամանակը ձեր սցենարներում:
Ահա ևս մեկ օրինակ.
// քայլել 10 միլիոն անգամ ($i=0;$i<10000000;$i++) { } $data = getrusage(); echo "User time: ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo "System time: ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* выводит User time: 1.424592 System time: 0.004204 */
Սցենարը տևեց 1,4 վայրկյան պրոցեսորի ժամանակ: Այս դեպքում համակարգային զանգերի ժամանակները հիմնականում ցածր են:
Արտոնյալ ռեժիմի ժամանակը (System Time) այն ժամանակն է, որը պրոցեսորը ծախսում է ծրագրի անունից միջուկին ուղղված համակարգի հարցումները կատարելու համար: Օրինակ:
$start = microtime(true); // զանգահարել microtime ամեն 3 վայրկյան, while(microtime(true) - $start< 3) { } $data = getrusage(); echo "User time: ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo "System time: ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* выводит User time: 1.088171 System time: 1.675315 */
Այժմ համակարգի ժամանակը ծախսվել է շատ ավելի, քան նախորդ օրինակում։ Այս ամենը շնորհիվ microtime() մեթոդի, որն օգտագործում է համակարգի ռեսուրսները:
Այնուամենայնիվ, հարկ է նշել, որ ցուցադրված ժամանակը կարող է ճշգրիտ չլինել, քանի որ Տվյալ պահին պրոցեսորային ռեսուրսներն օգտագործվում են նաև այլ ծրագրերի կողմից, ինչը կարող է հանգեցնել աննշան սխալի:
5. Կախարդական հաստատուններ
PHP-ում կան բազմաթիվ կախարդական հաստատուններ, ինչպիսիք են ընթացիկ տողի համարը (__LINE__), ֆայլի ուղին (__FILE__), գրացուցակի ուղին (__DIR__), ֆունկցիայի անունը (__FUNCTION__), դասի անվանումը (__CLASS__), մեթոդի անունը (__METHOD__) և անունների տարածությունները ( __NAMESPACE__):
Մենք բոլորին չենք դիտարկելու։ Դիտարկենք ընդամենը մի զույգ.
// այս սկրիպտը կախված է ընթացիկ ֆայլի գտնվելու վայրից և // կարող է խնդիրներ առաջացնել, եթե օգտագործվի տարբեր դիրեկտորիաներից պահանջել_once("config/database.php"); // այս սկրիպտը խնդիրներ չի առաջացնի require_once(dirname(__FILE__) . "/config/database.php");
Օգտագործեք __LINE__ սկրիպտները վրիպազերծելիս՝
// կոդը // ... my_debug ("որոշ վրիպազերծման հաղորդագրություն", __LINE__); /* կցուցադրի 4-րդ տող. որոշ վրիպազերծման հաղորդագրություն */ // ավելի շատ կոդ // ... my_debug("other debug message", __LINE__); /*-ը կտպագրի տող 11. վրիպազերծման ևս մեկ հաղորդագրություն */ my_debug ֆունկցիան ($msg, $line) ( արձագանքում է «Line $line: $msg\n»; )
6. Եզակի ID-ների ստեղծում
Կան ժամանակներ, երբ դուք պետք է ստեղծեք յուրահատուկ տող: Ես բազմիցս տեսել եմ, որ md5() ֆունկցիան օգտագործվում է այս խնդիրը լուծելու համար.
// առաջացնում է պատահական տող echo md5(time() . mt_rand(1.1000000));
Բայց իրականում PHP-ն ունի հատուկ գործառույթ uniqid() այս նպատակների համար
// առաջացնում է պատահական տող echo uniqid(); /* տպելու է 4bd67c947233e */ // ևս մեկ անգամ echo uniqid(); /* տպելու է 4bd67c9472340 */
Անզեն աչքով կարելի է տեսնել, որ առաջին սիմվոլները, մեղմ ասած, նման են... Դա պայմանավորված է նրանով, որ այս մեթոդը օգտագործում է սերվերի ժամանակը սիմվոլներ ստեղծելու համար։ Սա նույնիսկ օգտակար է, քանի որ... Բոլոր գեներացված արժեքները ստացվում են այբբենական կարգով, ինչը հնարավորություն է տալիս արագ տեսակավորել դրանք:
Կրկնօրինակ ստանալու հնարավորությունները նվազեցնելու համար մենք կարող ենք ավելացնել նախածանց կամ օգտագործել երկրորդ պարամետր (ավելացնում է նիշերի քանակը).
// նախածանցով echo uniqid ("foo_"); /* կտպագրի foo_4bd67d6cd8b8f */ // երկրորդ պարամետրով echo uniqid("",true); /* տպելու է 4bd67d6cd8b926.12135106 */ // երկուսն էլ echo uniqid("bar_",true); /* դուրս կգա bar_4bd67da367b650.43684647 */
Այս մեթոդը ստեղծում է md5-ից փոքր տողեր՝ դրանով իսկ խնայելով տարածք:
7. Սերիալացում
Երբևէ ստիպված եղե՞լ եք բարդ տվյալներ պահել տվյալների բազայում կամ ֆայլում: Օբյեկտը տողի վերածելու համար PHP-ն տրամադրում է հատուկ ֆունկցիա։
Ընդհանուր առմամբ, գոյություն ունի այս մեթոդներից 2-ը՝ serialize() և unserialize()
// բարդ զանգված $myvar = զանգված («բարև», 42, զանգված (1», երկու»), «խնձոր»); // փոխարկել տողի $string = serialize($myvar); echo $string; /* տպելու է a:4:(i:0;s:5:"բարև";i:1;i:42;i:2;a:2:(i:0;i:1;i:1; s :3:"երկու";)i:3;s:5:"խնձոր";) */ // ստացիր սկզբնական արժեքը $newvar = unserialize($string); print_r ($ newvar); /* դուրս կգա Array ( => բարև => 42 => Array ( => 1 => երկու) => խնձոր) */
Այս գործառույթներն այսպես են աշխատում։ Այնուամենայնիվ, JSON-ի ժողովրդականության արագ աճի պատճառով PHP 5.2-ին ավելացվեցին 2 մեթոդներ json_encode() և json_decode(): Նրանց աշխատանքը նման է serialize():
// բարդ զանգված $myvar = զանգված ("բարև", 42, զանգված (1," երկու"), "խնձոր"); // փոխարկել տողի $string = json_encode ($myvar); echo $string; /*-ը կտպագրի ["բարև",42,"խնձոր"] */ // կվերականգնի սկզբնական արժեքը $newvar = json_decode($string); print_r ($ newvar); /* տպում է զանգված ( => բարև => 42 => զանգված ( => 1 => երկու) => խնձոր) */
Այս տարբերակը ավելի կոմպակտ է և համատեղելի այլ լեզուների հետ, ինչպիսիք են JavaScript-ը: Այնուամենայնիվ, շատ բարդ օբյեկտների հետ աշխատելիս տվյալների կորուստը կարող է առաջանալ:
8. Լարի սեղմում
Երբ մենք խոսում ենք սեղմման մասին, ZIP ֆորմատով արխիվային ֆայլերը անմիջապես մտքում են հայտնվում: PHP-ն ապահովում է երկար տողեր առանց որևէ ֆայլի սեղմելու հնարավորություն:
Հետևյալ օրինակը ցույց է տալիս, թե ինչպես են աշխատում gzcompress() և gzuncompress() ֆունկցիաները.
$string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc ut elit id mi ultricies adipiscing. Nulla facilisi. Praesent pulvinar, sapien vel feugiat vestibulum, nulla dui pretium orci, non ultricies elit remet lacus. , Consectetur adipiscing elit . $ սեղմված = gzcompress ($ string); echo «Բնօրինակ չափս. strlen($string)."\n"; /* դուրս կգա Բնօրինակի չափը՝ 800 */ echo «Compressed size:»: strlen($սեղմված)."\n"; /* դուրս կբերի Սեղմված չափը՝ 418 */ // վերադարձ $original = gzuncompress($compressed);
Մենք կարող ենք կրճատել տեքստի ծավալը 50%-ով։ Նույն նպատակների համար կարող եք օգտագործել gzencode() և gzdecode() մեթոդները, որոնք օգտագործում են այլ սեղմման ալգորիթմ:
9. Դուրս գալուց առաջ կատարիր
PHP-ն ունի register_shutdown_function() ֆունկցիա, որը թույլ կտա գործարկել որոշ կոդ նախքան սկրիպտը անջատելը:
Ենթադրենք, դուք ցանկանում եք պարզել որոշ տեղեկություններ... Սցենարի գործարկման ժամանակը.
// ստանալ մեկնարկի ժամը $start_time = microtime(true); // որոշ գործողություններ // ... // ցուցադրում է գործարկման ժամանակի արձագանքը «կատարումը կատարվեց.»: (microtime(true) - $start_time): «վայրկյաններ»;
Առաջին հայացքից սա կարող է չնչին գործ թվալ: Այս նպատակների համար դուք կարող եք տեղադրել կոդը ֆայլի վերջում: Այնուամենայնիվ, եթե exit() ֆունկցիան գործարկվի դրանից առաջ, այս կոդը երբեք չի աշխատի: Նաև այն չի աշխատի, եթե էջում սխալ լինի կամ օգտագործողը ընդհատի էջի բեռնումը (սեղմելով իր բրաուզերի համապատասխան կոճակը);
Register_shutdown_function() մեթոդն օգտագործելիս կոդը ցանկացած դեպքում կկատարվի.
$start_time = microtime(true); register_shutdown_function ("my_shutdown"); my_shutdown() ֆունկցիան (գլոբալ $start_time; echo "կատարումը տևեց. ". (microtime(true) - $start_time). "վայրկյան.";)
Եզրակացություն
PHP-ն մի ամբողջ մոլորակ է, որը երբեք չի դադարում զարմացնել մեզ իր բովանդակությամբ: Ի՞նչ կարծիքի եք այս գործառույթների մասին:
Օգտատիրոջ կողմից սահմանված գործառույթները ստեղծվում են՝ օգտագործելով ֆունկցիայի հիմնաբառը, որին հաջորդում է ֆունկցիայի անվանումը, նրա արգումենտների ցանկը (որոնք կարող են լինել զրո թվով) և բուն ֆունկցիայի մարմինը։ Գործառույթների նպատակը շատ լայն է. Եթե դուք պետք է մի քանի անգամ գործարկեք նույն կոդը, ապա այն պետք է տեղադրեք ձեր սեփական ֆունկցիայի մեջ և այնուհետև պարզապես զանգահարեք այնտեղ, որտեղ այն ձեզ անհրաժեշտ է: Ֆունկցիայի անունը պետք է սկսվի լատիներեն գրանշանով և կարող է պարունակել թվեր և փոքրատառ: Պայմանականորեն, PHP-ում ֆունկցիաների անունները սկսվում են փոքրատառերով, և եթե անունը օգտագործում է մեկից ավելի բառ, ապա յուրաքանչյուր նորը սկսվում է մեծատառով, անմիջապես կամ ընդգծումից հետո:
/** * Հայտարարել օգտվողի պարզ գործառույթ */ userFunction() ()
Եթե ֆունկցիայի մարմնում մեկից ավելի հրահանգ կա, ապա բոլոր հրահանգները պետք է տեղադրվեն գանգուր փակագծերի ներսում (): Եթե ֆունկցիան ունի միայն մեկ հայտարարություն, ապա գանգուր փակագծերը պարտադիր չեն: Բայց ես խորհուրդ եմ տալիս միշտ օգտագործել դրանք:
PHP-ն ունի ստանդարտ գործառույթներ, որոնց անունները չեք կարող օգտագործել ձեր անուններում: Եթե փորձեք ստեղծել date() կամ time() անվանումով ֆունկցիա, դուք կստանաք սխալի հաղորդագրություն գործառույթը վերացնելու փորձի մասին: PHP-ում գործառույթները կարող են հայտարարվել միայն մեկ անգամ: Գերակայող գործառույթներն արգելված են: Սովորաբար, գործառույթները սահմանվում են սկրիպտի հենց սկզբում (սովորաբար հիմնական սցենարի մեջ ներառված առանձին ֆայլերում) մինչև հիմնական սցենարի մեկնարկը։ Եկեք ստեղծենք օգտատիրոջ IP հասցեն էկրանին ցուցադրելու գործառույթ:
/** * Օգտագործողի IP հասցեն ցուցադրելու գործառույթ: * IP հասցեն վերցված է PHP սուպերգլոբալ զանգվածից $_SERVER *, որը պարունակում է կարևոր կապի և սերվերի տվյալներ */ userIP() ֆունկցիան ( տպել "
" . $_SERVER["REMOTE_ADDR"]:
"; }Ֆունկցիան սահմանված է. Այն կանչելու համար ճիշտ տեղում սկրիպտում բավական է նշել ֆունկցիայի անվանումը և փոխանցել անհրաժեշտ պարամետրերը (անհրաժեշտության դեպքում):
UserIP (); // Ցուցադրում է օգտագործողի IP հասցեն 127.0.0.1-ի նման
Փոփոխական շրջանակ
Ֆունկցիաների հետ աշխատելիս դուք պետք է սովորեք փոփոխական շրջանակի հայեցակարգը: Այն կայանում է նրանում, թե սկրիպտի որ տեղերում է հայտարարված փոփոխականներից որը կարող է օգտագործվել: Փոփոխականները, որոնք հայտարարվել են ֆունկցիայի ներսում, տեղական փոփոխականներ են: Դուք կարող եք մուտք գործել դրանք գործառույթի մարմնի ներսում, բայց դուք չեք կարող մուտք գործել դրանք գործառույթից դուրս: Ընդհակառակը, ֆունկցիայի մարմնից դուրս հայտարարված փոփոխականները հասանելի չեն հենց ֆունկցիայի ներսում: Բայց կան տվյալներ, որոնք հասանելի են սցենարի ցանկացած կետում:
Սուպերգլոբալ զանգվածներ
$_SERVER, $_SESSION, $_COOKIE և այլն սուպերգլոբալ զանգվածներ են: Նրանց տվյալները հասանելի են սցենարի ցանկացած կետում: Ահա դրանցից ընդամենը մի քանիսը.
- $_SERVER["REMOTE_ADDR"] — օգտվողի IP հասցե;
- $_SERVER["SERVER_NAME"] — սերվերի անունը;
- $_SERVER["DOCUMENT_ROOT"] - կայքի արմատական գրացուցակ;
- $_SERVER["REQUEST_URI"] - պահանջվող փաստաթղթի հասցեն:
Ֆունկցիայի փաստարկներ
Եթե ֆունկցիան պետք է մուտք ունենա իր մարմնից դուրս հայտարարված փոփոխական կամ հաստատուն տվյալներին, ապա այս տվյալները կարող են փոխանցվել նրան որպես փաստարկներ: Յուրաքանչյուր ֆունկցիա կարող է ընդունել ցանկացած քանակությամբ արգումենտ (պարամետր), ներառյալ զրո: Վերևի օրինակում մենք գործառույթին որևէ արգումենտ չենք փոխանցել: Դիտարկենք մեկ այլ օրինակ։
/** * Հայտարարեք հատուկ գործառույթ երկու կամայական արժեքներ գումարելու համար */ ֆունկցիայի գումարը ($value_1, $value_2) ( // Ֆունկցիան պետք է վերցնի 2 պահանջվող արգումենտ, տպեք $value_1 + $value_2; // Եվ ցուցադրեք գումարի գումարը այս փաստարկները ) $ green_apples = 10; // Մենք ունենք 10 կանաչ խնձոր $red_apples = 4; // Եվ կա նաև 4 կարմիր խնձոր // Մենք կարող ենք պարզել խնձորների ընդհանուր քանակը՝ կանչելով գումար() ֆունկցիան // գումար() ֆունկցիան պետք է վերցնի երկու արգումենտ, որոնք կլինեն խնձորների քանակը ($green_apples) , $red_apples); // Ցուցադրում է 14
Ֆունկցիայի կամընտիր պարամետրեր (կանխադրված պարամետրեր):
Ֆունկցիան կարող է ունենալ անսահմանափակ թվով արգումենտներ (պարամետրեր), որոնց թվում կարող են լինել ընտրովի (ներառյալ բոլորը): Ֆունկցիայի փաստարկը կամընտիր դարձնելու համար այն պետք է տրվի լռելյայն արժեք, երբ գործառույթը հայտարարվում է:
/** * Հայտարարել ֆունկցիա լռելյայն արժեքներով */ ֆունկցիայի գումարը ($value_1, $value_2, $value_3 = 0) (տպել $value_1 + $value_2 + $value_3; )
/** * Հաշվեք խնձորների ընդհանուր թիվը * Այս անգամ գումար() ֆունկցիան վերցնում է երեք արգումենտ, * բայց երրորդը կամընտիր է, քանի որ դրա արժեքը * սահմանվել է ֆունկցիայի հայտարարման ժամանակ, եթե չնշենք երրորդ * փաստարկ, այն կմնա հավասար զրոյի * / $geen_apples = 11; $ red_apples = 7; գումարը ($ green_apples, $ red_apples); // Ցուցադրում է 18 // Մենք հանկարծ մեր մառանում գտնում ենք ևս 10 դեղին խնձոր $yellow_apples = 10; // Եվ դրանք նույնպես պետք է հաշվի առնվեն գումարը ($green_apples, $red_apples, $yellow_apples); // Ցուցադրում է 28
Ուշադրություն դարձրեք, որ մենք նույն ֆունկցիան երկու անգամ կանչել ենք նույն սկրիպտում: Դա կարելի է անել այնքան անգամ, որքան ցանկանում եք: Ֆունկցիաների հետ աշխատելիս հիշեք մեկ կարևոր մանրամասն. եթե ֆունկցիայի արգումենտների մեջ կան չհայտարարված լռելյայն և հայտարարվածներ, ապա նախ պետք է նշվեն չհայտարարվածները (պարտադիր):
UserF ֆունկցիան ($v1, $v2 = 100, $v3) ( // Սա լավ չի տպի $v1 + $v2 + $v3; )
Արժեքի վերադարձ
Ֆունկցիաների հիմնական հատկանիշներից մեկը արդյունք վերադարձնելու նրանց կարողությունն է։ Միշտ չէ, որ սցենարում անհրաժեշտ է ինչ-որ բան անել ֆունկցիայի արդյունքով։ Ավելի հաճախ այն պարզապես պետք է պահպանվի և օգտագործվի սկրիպտի մեկ այլ վայրում՝ բոլորովին այլ նպատակներով: [?] իրականում ֆունկցիաները գրեթե երբեք չեն օգտագործվում էկրանին որոշակի արժեք ցուցադրելու համար:. Որպեսզի ֆունկցիան արժեք վերադարձնի սկրիպտի այն տեղը, որտեղից այն կանչվել է, դուք պետք է օգտագործեք վերադարձի դրույթը: Ցանկացած կոդ, որը հետևում է վերադարձի քաղվածքին, չի կատարվում (եթե վերադարձի քաղվածքն աշխատել է այնպես, ինչպես սպասվում էր):
/** * Հայտարարել հատուկ գործառույթ խնձորներ ավելացնելու համար * արժեքներից մեկը լռելյայն է: * Ֆունկցիան պարզապես ամփոփում է արգումենտների արժեքները և վերադարձնում * դրանք սկրիպտին՝ առանց դրանք էկրանին տպելու: */ ֆունկցիայի գումարը ($value_1, $value_2, $value_3 = 0) ( $result = $value_1 + $value_2 + $value_3; // Պարզապես ավելացրեք ֆունկցիայի արգումենտների արժեքները return $result; // Վերադարձեք արդյունքը սկրիպտին $result փոփոխականը տեղային է // և մասնավորապես դրա արժեքը հասանելի չի լինի ֆունկցիայի մարմնից դուրս) $green_apples = 9; // ունենք 9 կանաչ խնձոր $red_apples = 14; // Եվ ևս 14 կարմիր խնձոր // Ընդհանուր առմամբ ունենք... $total_green_red = գումար ($green_apples, $red_apples); // քանակությամբ () ֆունկցիայի վերադարձի քաղվածքը կվերադարձնի 23 արժեքը, // որը վերագրվելու է $total_green_red փոփոխականին // Նրանք մեզ բերեցին ևս 7 դեղին խնձոր $yellow_apples = 7; // Եվ հիմա մենք ունենք... $total_green_red_yellow = գումար ($green_apples, $red_apples, $yellow_apples); // Վերադարձրեք 30 արժեքը և գրեք այն փոփոխականում // $total_green_red_yellow $all = գումար($total_green_red, $total_green_red_yellow); // Վերադարձնում է արժեքը 53 // Ցուցադրում է կանաչներն ու կարմիրները ընդհանուր առմամբ - 23 տպում "
Կանաչ և կարմիր ընդհանուր - " . $total_green_red ."
«; // Կցուցադրվեն կանաչները, կարմիրները և դեղինները ընդհանուր առմամբ - 30 տպագիր»Կանաչ, կարմիր և դեղին ընդհանուր - " . $total_green_red_yellow . "
"; // Ցուցադրում է արժեքների գումարը - 53 տպագիր"Արժեքների գումարը « . $all .» է:
";Այսպիսով, ինչ է ֆունկցիանPHP?
Գործառույթ -Սա մինի ծրագիր է, որը կատարում է որոշ օգտակար գործողություններ և տալիս է ավարտուն արդյունք:
Եկեք նայենք դիագրամին.
Փորձենք գրել մինի ծրագիր՝ օգտագործելով պատրաստի ֆունկցիայի կաղապարը։
Պատրաստի ֆունկցիայի ձևանմուշ.
Ենթադրենք, պետք է գրել ֆունկցիա, որը կարող է հաշվարկել 5 և 2 թվերի գումարը։ Մենք նայում ենք ձևանմուշին և գրում.
Եկեք վերլուծենք կոդը.
suma() ֆունկցիան suma անունով ֆունկցիա է;
արձագանք 5 + 2; - ֆունկցիայի մարմնում մենք նշել ենք, որ 5 և 2 թվերը պետք է գումարվեն միասին (5 + 2);
սումա (); - զանգահարել գործառույթը: Գործառույթ կանչելը նշանակում է այն կատարել: Այսինքն՝ 5 + 2 խնդիրը պետք է լրացվի և տա 7-ի արդյունք։
Այժմ եկեք փորձենք քայլ առ քայլ դիտարկել գործառույթները:
PHP-ում ֆունկցիա ստեղծելու փուլերը
ԲեմԻ. Ֆունկցիայի ստեղծում
Հիշեք պատրաստի գործառույթի ձևանմուշը.
Այսպես է ստեղծվում ֆունկցիա PHP-ում։
Եկեք գրենք տեքստը» Ուրախ եմ ձեզ տեսնել բլոգի կայքում».
Պարզապես մի մոռացեք. մենք գրում ենք տեքստը օգտագործելով .
"; } ?>
Այժմ դուք պետք է զանգահարեք «site()» գործառույթը:
ԲեմII. Պատրաստի ֆունկցիայի միացումPHP
Ֆունկցիան ստեղծվել է և այժմ պետք է կատարվի: Ֆունկցիան գործարկելու և ցուցադրելու համար պարզապես նշեք «function name(); »
կայք ();
Այն այսպիսի տեսք կունենա.
Դուք կարող եք դա անել այսպես.
Մուտքագրեք հասցեն ձեր բրաուզերում.
Արդյունք:
PHP-ն գործում է արգումենտներով
Վերոնշյալ գործառույթներով բոլոր օրինակները առանց փաստարկների էին: Ես ձեզ կբացատրեմ, թե ինչ է փաստարկը ծածկագրում.
Այսպիսով, ես ստեղծեցի մի գործառույթ, որը կոչվում է «կայք»: Պարամետրերում (որտեղ փակագծերն են) ես գրել եմ երկու $a և $b փոփոխականներ՝ բաժանված ստորակետերով։
Գործառույթի կայք ($a, $b)
$a-ն և $b-ը երկու փաստարկներն են:
echo "$a + $b ="; – այստեղ ես ցուցադրեցի տեքստը մոնիտորի վրա: Արդյունք՝ 5 + 5 =
արձագանք $a + $b; – այստեղ ես նշեցի ֆունկցիային, որ $a և $b փոփոխականները պետք է գումարվեն միասին:
կայք (15, 5); - կոչվում է ֆունկցիա: Ուշադրություն. փակագծերում ես նշել եմ երկու արգումենտ (15, 5), որոնց սպասում են $a և $b փոփոխականները։ $a փոփոխականը կստանա առաջին արգումենտը՝ 15, $b՝ երկրորդ 5:
Նրանց համար, ովքեր չեն հասկանում, թե որտեղ է արգումենտը փոխարինվում և ինչ հերթականությամբ, ահա դիագրամը.
Այսպիսով, պատրաստի կոդը.