Php7 - PHP. գլոբալ ֆունկցիայի ներսում չի ցուցադրվում փոփոխական՝ Stack Overflow ռուսերեն: PHP փոփոխականների շրջանակը. Այն ամենը, ինչ ուզում էիք իմանալ, բայց վախենում էիք հարցնել Տպել գլոբալ php փոփոխականը ֆունկցիայից դուրս

Վերջին թարմացումը՝ 1/11/2015

Փոփոխականներ և գործառույթներ օգտագործելիս հաշվի առեք փոփոխականի շրջանակը: Շրջանակը սահմանում է տվյալ փոփոխականի գործողության շրջանակը և հասանելիությունը:

Տեղական փոփոխականներ

Տեղական փոփոխականները ստեղծվում են ֆունկցիայի ներսում: Նման փոփոխականներին կարելի է մուտք գործել միայն տվյալ ֆունկցիայի ներսում: Օրինակ:

Այս դեպքում get() ֆունկցիան սահմանում է $result տեղական փոփոխական: Իսկ ընդհանուր համատեքստից մենք չենք կարող մուտք գործել այն, այսինքն՝ գրել $a = $result; Դա հնարավոր չէ, քանի որ $result փոփոխականի շրջանակը սահմանափակված է get() ֆունկցիայով։ Այս ֆունկցիայից դուրս $result փոփոխականը գոյություն չունի։

Նույնը վերաբերում է ֆունկցիայի պարամետրերին. ֆունկցիայից դուրս $lowlimit և $highlimit պարամետրերը նույնպես գոյություն չունեն։

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

Ստատիկ փոփոխականներ

Ստատիկ փոփոխականները նման են տեղական փոփոխականներին: Նրանք տարբերվում են նրանով, որ ֆունկցիան ավարտելուց հետո դրանց արժեքը պահպանվում է։ Ամեն անգամ, երբ ֆունկցիան կանչվում է, այն օգտագործում է նախկինում պահված արժեքը: Օրինակ:

Նշելու համար, որ փոփոխականը լինելու է ստատիկ, դրան ավելացվում է ստատիկ հիմնաբառը: GetCounter(-ին) երեք անընդմեջ զանգերի դեպքում $counter փոփոխականը կավելացվի մեկով:

Եթե ​​$counter փոփոխականը սովորական ոչ ստատիկ փոփոխական լիներ, ապա getCounter()-ը կտպեր 1 ամեն անգամ, երբ այն կանչվեր։

Սովորաբար, ստատիկ փոփոխականները օգտագործվում են տարբեր հաշվիչներ ստեղծելու համար, ինչպես վերը նշված օրինակում:

Գլոբալ փոփոխականներ

Երբեմն դուք ցանկանում եք, որ փոփոխականը հասանելի լինի ամենուր, ամբողջ աշխարհում: Նման փոփոխականները կարող են պահպանել որոշ տվյալներ, որոնք ընդհանուր են ամբողջ ծրագրի համար: Գլոբալ փոփոխականներ սահմանելու համար օգտագործեք գլոբալ հիմնաբառը՝ 1

";) getGlobal(); echo $gvar; ?>

GetGlobal() ֆունկցիան կանչելուց հետո $gvar փոփոխականին կարելի է մուտք գործել ծրագրի ցանկացած մասից։

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

Բարև սիրելի բլոգի ընթերցողներ Կայքվրա! Մենք իմացանք, որ PHP-ում ֆունկցիա կա, սովորեցինք, թե ինչպես ստեղծել մեր սեփական ֆունկցիաները, փոխանցել արգումենտներ և կանչել դրանք կատարման: Շարունակելով PHP-ում ֆունկցիաների թեման՝ անհրաժեշտ է ընդգծել հետևյալը.

  • Ֆունկցիայի ներսում կարող եք օգտագործել ցանկացած PHP կոդ (ցիկլեր, պայմաններ, ցանկացած գործողություն), ներառյալ այլ գործառույթներ (ինչպես ներկառուցված, այնպես էլ հատուկ);
  • Ֆունկցիայի անվանումը պետք է սկսվի լատինատառ կամ ընդգծված տառով, որին հաջորդում է ցանկացած թվով լատինատառ, թվեր կամ ընդգծում.
  • Բոլոր գործառույթներն ունեն գլոբալ տիրույթ, ինչը նշանակում է, որ ցանկացած ֆունկցիա կարելի է կանչել ցանկացած վայրում, նույնիսկ եթե այդ ֆունկցիան սահմանված է մյուսի ներսում;
  • PHP-ն չի աջակցում ֆունկցիայի գերբեռնում, չկա նաև ստեղծված ֆունկցիան վերասահմանելու (փոխելու, ավելացնելու) կամ ջնջելու հնարավորություն.
  • Գործառույթներն օգտագործելուց առաջ պետք չէ սահմանել: Այսինքն, եթե դուք նախ զանգահարեք գործառույթ և միայն այն ժամանակ նկարագրեք այն ստորև բերված կոդով, դա չի ազդի կատարման վրա և չի առաջացնի սխալներ:

Պայմանական գործառույթներ

Մենք կարող ենք ստեղծել (սահմանել, նկարագրել) ֆունկցիա՝ կախված պայմանից։ Օրինակ:

//կոչվում է sayHi ֆունկցիան, այն կարելի է կանչել ցանկացած վայրում /*sayGoodbye ֆունկցիան չի կարող կանչվել այստեղ, քանի որ մենք դեռ չենք ստուգել պայմանը և չենք մտել if կոնստրուկցի ներսում*/ if($apply)( ֆունկցիա sayGoodbye())( echo «Ցտեսություն բոլորին:
"; } } /*հիմա մենք կարող ենք զանգահարել «Ցտեսություն*/
"; }

Արդյունք:

Եվ նայեք այս օրինակին.

/*և ահա թե ինչ կլինի, եթե այստեղ զանգահարեք ասեք հրաժեշտ*/հրաժեշտ տալ(); if($apply)( ֆունկցիա sayGoodbye())( echo «Ցտեսություն բոլորին:
"; ) ) գործառույթը sayHi())( echo "Բարև բոլորին:
"; }

Արդյունք:

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

Ներդրված գործառույթներ

Ներդրված ֆունկցիան այլ ֆունկցիայի ներսում հայտարարված ֆունկցիա է: Օրինակ:

/*Այստեղ չեք կարող զանգահարել sayGoodbye, քանի որ այն կհայտնվի միայն sayHi ֆունկցիան կանչելուց հետո*/ sayHi (); /*կանչեք sayHi ֆունկցիան, այն կարելի է կանչել ցանկացած վայրում*/ /*Այժմ մենք կարող ենք զանգահարել ասենք Ցտեսություն*/հրաժեշտ տալ(); ֆունկցիա sayHi()) (echo «Բարև բոլորին:
"; ֆունկցիա sayGoodbye())( echo "Bye all!
"; } }

Կրկին, առաջին անցման ժամանակ PHP թարգմանիչն ինքն իրեն նշում է, որ գտել է sayHi ֆունկցիայի նկարագրությունը, բայց չի մտնում նրա մարմնի ներսում, նա տեսնում է միայն անունը, և քանի որ թարգմանիչը չի մտնում sayHi մարմնի ներսում, այնուհետև նա չի պատկերացնում, թե ինչ ենք մենք սահմանում մեկ այլ ֆունկցիայի ներսում՝ ասենք, բարով:

Այնուհետև կոդը սկսում է գործարկել, մենք կանչում ենք sayHi, PHP թարգմանիչը պետք է մտնի sayHi ֆունկցիայի մարմին՝ այն գործարկելու համար և այնտեղ պատահաբար գտնում է մեկ այլ ֆունկցիայի նկարագրությունը՝ sayGoodbye, որից հետո sayGoodbye կարող է կանչվել ցանկացած վայրում, նույնքան անգամ։ Ինչպես կամենաս.

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

PHP-ում վերը նկարագրված տեխնիկան շատ հազվադեպ է օգտագործվում, դրանք ավելի հաճախ կարելի է տեսնել, օրինակ՝ JavaScript-ում։

Փոփոխական շրջանակ

PHP-ում կա ուղիղ երկու շրջանակ. համաշխարհայինԵվ տեղական. Ծրագրավորման յուրաքանչյուր լեզվի կառուցվածքը տարբեր է: Օրինակ, C++-ում նույնիսկ օղակներն ունեն իրենց սեփական (տեղական) շրջանակը: PHP-ում, ի դեպ, սա գլոբալ շրջանակ է։ Բայց այսօր մենք խոսում ենք գործառույթների մասին։

PHP-ում ֆունկցիաներն ունեն իրենց ներքին շրջանակը (տեղական), այսինքն՝ ֆունկցիայի ներսում գտնվող բոլոր փոփոխականները տեսանելի են միայն այս ֆունկցիայի ներսում։

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

Հարգելի փորձագետներ, ուշադրություն, հարց. Ի՞նչ արդյունք կտա վերջին հրահանգը: echo $name; ?

Ինչպես ինքներդ տեսաք, մենք ունեինք 2 փոփոխական $name, մեկը ֆունկցիայի ներսում (տեղական շրջանակ), մյուսը պարզապես կոդի մեջ (գլոբալ տիրույթ), փոփոխականի վերջին նշանակումը $nameէր $name = «Ռուդ Սերգեյ»;Բայց քանի որ ֆունկցիայի ներսում էր, այնտեղ մնաց։ Համաշխարհային մասշտաբով վերջին հանձնարարությունն էր $name = «Անդրեյ»;ինչը մենք իրականում տեսնում ենք արդյունքում:

Այսինքն՝ երկու նույնական փոփոխականներ, բայց տարբեր տիրույթներում դրանք չեն հատվում և չեն ազդում միմյանց վրա։

Թույլ տվեք պատկերացնել շրջանակը նկարում.

Առաջին անցման ժամանակ թարգմանիչը համառոտ սկանավորում է գլոբալ շրջանակը, հիշում է, թե ինչ փոփոխականներ և գործառույթներ կան, բայց չի կատարում կոդը:

Համաշխարհային փոփոխականների հասանելիություն տեղական շրջանակից

Բայց ի՞նչ, եթե մենք դեռ պետք է մուտք գործենք նույն $name փոփոխականին գլոբալ շրջանակից որևէ ֆունկցիայից, և ոչ միայն մուտք գործենք այն, այլ փոխենք այն: Դրա համար կա 3 հիմնական տարբերակ. Առաջինը հիմնաբառի օգտագործումն է համաշխարհային:

գլոբալ $name; /*այսուհետ մենք նկատի ունենք $name*/ գլոբալ փոփոխականը$name = «Ռուդ Սերգեյ»; ) $name = «Անդրեյ»; sayHi ($name); echo $name; //?

Արդյունք:

Բայց այս մեթոդը մի թերություն ունի, քանի որ մենք մուտք ենք գործել գլոբալ փոփոխական $nameմենք կորցրել ենք (վերագրել) տեղական փոփոխականը $name.

Երկրորդ ճանապարհօգտագործելն է PHP սուպերգլոբալ զանգված. PHP-ն ինքնին ավտոմատ կերպով տեղադրում է յուրաքանչյուր փոփոխական, որը մենք ստեղծել ենք գլոբալ տիրույթում այս զանգվածում: Օրինակ:

$name = «Անդրեյ»; //Նույնը, ինչ$GLOBALS["name"] = "Անդրեյ";

Հետևաբար.

"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

Արդյունքը նույնն է, ինչ բանալի բառն օգտագործելը համաշխարհային:

Միայն թե այս անգամ մենք չենք վերագրել լոկալ փոփոխականը, այսինքն՝ փոփոխականը $nameֆունկցիայի ներսում մնում է նույնը և հավասար է «Անդրեյ», բայց չէ «Ռուդ Սերգեյ».

Փաստարկների փոխանցումը հղումով

Երրորդ ճանապարհ- սա հասցեի փոխանցում է ( հղումներ) փոփոխականի, ոչ թե դրա արժեքի: PHP-ում հղումներն այնքան էլ հաջող չեն, ի տարբերություն այլ ծրագրավորման լեզուների։ Այնուամենայնիվ, ես ձեզ կասեմ միակ ճիշտ տարբերակը՝ արգումենտ փոխանցելու համար՝ հղում անելով ֆունկցիային, որը սովորաբար աջակցվում է PHP 5.3 և ավելի բարձր տարբերակներում: Հղումների հետ աշխատելու այլ եղանակներ կան, բայց դրանք աշխատում էին PHP 5.2 և ավելի ցածր, արդյունքում PHP մշակողները իրենք որոշեցին հրաժարվել դրանցից, ուստի մենք դրանց մասին չենք խոսի:

Այսպիսով, PHP 5.3 և ավելի բարձր հղման միջոցով արգումենտի ՃԻՇՏ փոխանցումը կատարվում է հետևյալ կերպ.

Գործառույթը sayHi(& $name)(

Ֆունկցիայի նկարագրության մեջ մենք ավելացրել ենք ամպերսանդի պատկերակ (&) - այս պատկերակը նշանակում է, որ մենք չենք ընդունում փոփոխականի արժեքը, այլ հղում (հասցե) այս արժեքին հիշողության մեջ: PHP-ի հղումները թույլ են տալիս ստեղծել երկու փոփոխական՝ մատնանշելով նույն արժեքը: Սա նշանակում է, որ երբ այս փոփոխականներից մեկը փոխվում է, երկուսն էլ փոխվում են, քանի որ դրանք վերաբերում են նույն արժեքին հիշողության մեջ:

Եվ վերջում մենք ունենք.

//ընդունիր ոչ թե արժեք, այլ արժեքի հղում echo «Բարև, «.$name»!
"; $name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

Արդյունք:

Ստատիկ փոփոխականներ

Պատկերացրեք հետևյալ իրավիճակը՝ պետք է հաշվենք, թե ընդհանուր առմամբ քանի անգամ ենք բարևել։ Ահա թե ինչ ենք մենք փորձում անել.

$c++; // մեծացնել հաշվիչը 1-ով

Արդյունք:

Փոփոխական $cչի հիշում դրա իմաստը, այն ամեն անգամ նորովի է ստեղծվում։ Մենք պետք է դարձնենք մեր տեղական փոփոխականը $cֆունկցիան կատարելուց հետո հիշել է դրա արժեքը, դրա համար նրանք օգտագործում են հիմնաբառ ստատիկ:

// հաշվիչ, պատրաստված ստատիկ echo «Բարև, «.$name»!
$c++; // մեծացնել հաշվիչը 1-ով echo «Ուղղակի բարև ասաց»: $c . «Մի անգամ.

";) sayHi ("Rud Sergey"); sayHi ("Andrey"); sayHi ("Dmitry");

Արդյունք:

Վերադարձնող արժեքներ

Գործառույթներն ունեն այնպիսի հարմար բան, ինչպիսին է արժեքների վերադարձը։ Սա այն դեպքում, երբ ֆունկցիան էկրանին ինչ-որ բան տպելու փոխարեն ամեն ինչ դնում է փոփոխականի մեջ և տալիս է այդ փոփոխականը մեզ: Եվ մենք արդեն որոշում ենք, թե ինչ անել դրա հետ։ Օրինակ, եկեք վերցնենք այս ֆունկցիան, այն քառակուսիացնում է թիվը.

Արդյունք:

Եկեք այնպես դարձնենք, որ այն էկրանին ցուցադրելու փոխարեն վերադարձնի կատարման արդյունքը։ Դա անելու համար օգտագործեք վերադարձի հիմնաբառը.

Արդյունք:

Այժմ մենք կարող ենք օգտագործել սա տարբեր ձևերով.

//արտադրում է արդյունքըարձագանք»
$num = getSquare(5); echo $num;

Արդյունք:

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

echo «PHP-ն ինձ երբեք չի հասնի:(»;) echo getSquare (5); //արտադրում է արդյունքըարձագանք»
$num = getSquare(5); // արդյունքը վերագրեց փոփոխականին echo $num; // ցուցադրել փոփոխականը էկրանին

Արդյունք:

Այն է վերադարձ– սա նաև ելք է ֆունկցիայից: Այն կարող է օգտագործվել առանց վերադարձի արժեքի, միայն արդյունքի համար:

Ռեկուրսիվ ֆունկցիա

Ռեկուրսիվ ֆունկցիան իրեն կանչող ֆունկցիա է: Recursion-ը հաճախ չի օգտագործվում և համարվում է ռեսուրսային (դանդաղ) գործողություն: Բայց պատահում է, որ ռեկուրսիայի օգտագործումը ամենաակնհայտ և պարզ տարբերակն է։ Օրինակ:

"; եթե ($համար< 20){ // որպեսզի ռեկուրսիան անվերջ չդառնա countPlease(++$number); // countPlease ֆունկցիան իրեն կանչեց) ) countPlease(1);

Արդյունք:

Եթե ​​գիտեք, թե ինչպես անել առանց ռեկուրսիայի, ապա ավելի լավ է դա անել:

PHP-ում ուժեղ մուտքագրում (տեսակի ճշգրտում)

PHP-ն փոքր քայլեր է ձեռնարկում դեպի ուժեղ մուտքագրում, այնպես որ մենք կարող ենք նախապես նշել, թե ինչ տեսակ պետք է կատարի ֆունկցիան (սա կոչվում է. տեսակ-ակնարկ):

Արդյունք:

Բռնելի ճակատագրական սխալ. արգումենտ 1-ը փոխանցված է countPlease()-ին, պետք է լինի զանգված, տրված ամբողջ թիվ, որը կոչվում է /home/index.php տող 7-ում և սահմանվում է /home/index.php տող 3-ում:

Սխալը մեզ ասում է, որ ֆունկցիան ակնկալում է զանգված ստանալ, բայց փոխարենը մենք այն փոխանցում ենք մի թիվ: Ցավոք, առայժմ մենք կարող ենք նշել միայն (զանգվածի) տեսակը, իսկ PHP 5.4-ով մենք նաև ավելացրել ենք այնպիսի տարբերակ, ինչպիսին է. կանչելի:

Կանչելիստուգում է, արդյոք փոխանցված արժեքը կարող է կանչվել որպես ֆունկցիա: Callable կարող է լինել կամ ֆունկցիայի անունը, որը նշված է տողային փոփոխականով, կամ օբյեկտ և կանչվող մեթոդի անվանումը: Բայց օբյեկտների և մեթոդների մասին կխոսենք ավելի ուշ (սա օբյեկտի վրա հիմնված ծրագրավորման բաժին է), բայց դուք արդեն ծանոթ եք ֆունկցիաներին։ Ես չեմ կարող ձեզ ցույց տալ աշխատանքի արդյունքը, քանի որ ներկայումս ունեմ PHP 5.3, բայց դա կլինի.

Կոչվում է getEcho ֆունկցիա

Օգտագործելով փոփոխական երկարության փաստարկներ

Եվ վերջապես ևս մեկ շատ հազվադեպ օգտագործվող նրբերանգ. Պատկերացրեք մի իրավիճակ. մենք արգումենտներ ենք փոխանցում ֆունկցիային, թեև դրանք ֆունկցիայի մեջ չենք նկարագրել, օրինակ.

Արդյունք:

Ինչպես տեսնում եք, սխալներ չկան, բայց մեր անցած արգումենտները ոչ մի տեղ չեն օգտագործվում։ Բայց սա չի նշանակում, որ դրանք անհետացել են. դրանք դեռ փոխանցվել են ֆունկցիային, և մենք կարող ենք դրանք օգտագործել, դրա համար կան ներկառուցված PHP գործառույթներ.

func_num_args ()- Վերադարձնում է ֆունկցիային փոխանցված արգումենտների քանակը
func_get_arg (հաջորդական համարը)- Վերադարձնում է տարր փաստարկների ցանկից
func_get_args ()- Վերադարձնում է ֆունկցիայի փաստարկները պարունակող զանգված

"; echo func_get_arg(0) ;) $age = 22; getEcho("Rud Sergey", $age);

Արդյունք:

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

Այսօրվա հոդվածը վերջինն է PHP-ում գործառույթների թեմայով: Այժմ դուք կարող եք վստահ լինել այս թեմայի վերաբերյալ ձեր գիտելիքների ամբողջականության մեջ և կարող եք վստահորեն օգտագործել գործառույթները ձեր կարիքների համար:

Եթե ​​ինչ-որ մեկը ցանկություն ունի դրանում ավելի լավը դառնալու, բայց գաղափար չունի, թե ինչպես դա անել, լավագույն միջոցը կլինի պատրաստի (ներկառուցված) PHP ֆունկցիաները գրելը, օրինակ՝ կարող եք գրել ձեր սեփական count() ֆունկցիան: կամ որևէ այլ:

Շնորհակալություն բոլորիդ ուշադրության համար և նորից կտեսնվենք: Եթե ​​ինչ-որ բան պարզ չէ, ազատ զգալ տվեք ձեր հարցերը մեկնաբանություններում:

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

Երբ սկսում եք սովորել PHP և սկսում եք աշխատել գործառույթների և օբյեկտների հետ, փոփոխական շրջանակը մի փոքր շփոթեցնող է: Բարեբախտաբար, PHP-ի կանոններն այս առումով շատ հեշտ են հասկանալի (համեմատած ծրագրավորման այլ լեզուների հետ):

Ի՞նչ է շրջանակը:

Փոփոխականների շրջանակը այն համատեքստն է, որի շրջանակներում փոփոխականը սահմանվել է և որտեղ կարելի է մուտք գործել: PHP-ն ունի երկու փոփոխական շրջանակ.

  • Համաշխարհային- փոփոխականներին կարելի է մուտք գործել սցենարի ցանկացած կետ
  • Տեղական- փոփոխականներին կարելի է մուտք գործել միայն այն ֆունկցիայի ներսում, որով դրանք սահմանվել են

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

Գլոբալ տիրույթ ունեցող փոփոխականները կոչվում են գլոբալ, իսկ լոկալ տիրույթ ունեցող փոփոխականները՝ լոկալ։

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

";) sayHello(); echo "\$globalName-ի արժեքը. "$globalName"
"; echo "\$localName արժեքը՝ "$localName"
"; ?>

Բարև Հարրի: $globalName արժեքը՝ "Zoe" $localName արժեքը՝ ""

Այս սցենարում մենք ստեղծեցինք երկու փոփոխական.

  • $globalName- Սա համաշխարհայինփոփոխական
  • $localName- Սա տեղականփոփոխական, որը ստեղծվում է sayHello() ֆունկցիայի ներսում:

Փոփոխականն ու ֆունկցիան ստեղծելուց հետո սկրիպտը կանչում է sayHello(), որը տպում է «Hello Harry!» . Այնուհետև սցենարը փորձում է դուրս բերել երկու փոփոխականների արժեքները՝ օգտագործելով echo ֆունկցիան: Ահա թե ինչ է տեղի ունենում.

  • Որովհետեւ $globalNameստեղծվել է ֆունկցիայից դուրս, այն հասանելի է սցենարի ցանկացած կետում, ուստի «Zoe»-ն թողարկվում է:
  • $localNameհասանելի կլինի միայն sayHello() ֆունկցիայի ներսում: Քանի որ echo արտահայտությունը ֆունկցիայից դուրս է, PHP-ն թույլ չի տալիս մուտք գործել տեղական փոփոխական: Փոխարենը, PHP-ն ակնկալում է, որ կոդը կստեղծի $localName անունով նոր փոփոխական, որը կունենա դատարկ տողի լռելյայն արժեքը: այդ իսկ պատճառով երկրորդ զանգը echo-ին դուրս է բերում «» արժեքը $localName փոփոխականի համար։

Գործառույթի ներսում գլոբալ փոփոխականների մուտք

Համաշխարհային փոփոխական մուտք գործելու համար ֆունկցիայից դուրսԲավական է պարզապես գրել նրա անունը։ Բայց գլոբալ փոփոխական մուտք գործելու համար ֆունկցիայի ներսում, դուք նախ պետք է փոփոխականը հայտարարեք որպես գլոբալ ֆունկցիայում՝ օգտագործելով գլոբալ հիմնաբառը՝

myFunction() ֆունկցիա (գլոբալ $globalVariable; // Մուտք գործեք $globalVariable գլոբալ փոփոխական)

Եթե ​​դուք դա չեք անում, PHP-ն ենթադրում է, որ դուք ստեղծում կամ օգտագործում եք տեղական փոփոխական։

Ահա մի օրինակ սցենար, որն օգտագործում է գլոբալ փոփոխական ֆունկցիայի ներսում.

"; գլոբալ $globalName; echo "Բարև $globalName!
";) sayHello(); ?>

Կատարվելուց հետո սցենարը դուրս կգա.

Բարև Հարրի: Բարև Զոյա:

sayHello() ֆունկցիան օգտագործում է գլոբալ հիմնաբառը՝ $globalName փոփոխականը գլոբալ հայտարարելու համար։ Այնուհետև նա կարող է մուտք գործել փոփոխական և թողարկել դրա արժեքը («Zoe»):

Ի՞նչ են սուպերգլոբալները:

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

Ահա սուպերգլոբալների ցանկը, որոնք հասանելի են PHP 5.3 տարբերակում.

  • $GLOBALS - սկրիպտի բոլոր գլոբալ փոփոխականների ցանկը (բացառությամբ սուպերգլոբալների)
  • $_GET - պարունակում է բոլոր ձևի դաշտերի ցանկը, որոնք ներկայացված են զննարկչի կողմից՝ օգտագործելով GET հարցումը
  • $_POST - պարունակում է զննարկչի կողմից ուղարկված բոլոր ձևերի ցանկը POST հարցումով
  • $_COOKIE - պարունակում է բրաուզերի կողմից ուղարկված բոլոր թխուկների ցանկը
  • $_REQUEST - պարունակում է բոլոր բանալիների/արժեքների համակցությունները, որոնք պարունակվում են $_GET, $_POST, $_COOKIE զանգվածներում
  • $_FILES - պարունակում է բրաուզերի կողմից ներբեռնված բոլոր ֆայլերի ցանկը
  • $_SESSION - թույլ է տալիս պահել և օգտագործել սեսիայի փոփոխականները ընթացիկ բրաուզերի համար
  • $_SERVER - պարունակում է տեղեկատվություն սերվերի մասին, ինչպես օրինակ՝ կատարվող սցենարի ֆայլի անվանումը և բրաուզերի IP հասցեն:
  • $_ENV - պարունակում է PHP-ին փոխանցված միջավայրի փոփոխականների ցանկ, ինչպիսիք են CGI փոփոխականները:
Օրինակ, դուք կարող եք օգտագործել $_GET՝ սկրիպտի հարցման URL տողի մեջ ներառված փոփոխականների արժեքները ստանալու և դրանք էջում ցուցադրելու համար.

Եթե ​​գործարկեք վերը նշված սկրիպտը՝ օգտագործելով http://www.example.com/script.php?yourName=Fred URL-ը, այն կարտադրվի.

Բարև Ֆրեդ:

Զգուշացում.Իրական սցենարում նման տվյալների փոխանցումը երբեք չպետք է օգտագործվի թույլ անվտանգության պատճառով: Դուք միշտ պետք է վավերացնեք կամ զտեք տվյալները:

Գերգլոբալ $GLOBALS-ը շատ հարմար է օգտագործման համար, քանի որ այն թույլ է տալիս կազմակերպել գլոբալ փոփոխականների հասանելիությունը ֆունկցիայի մեջ՝ առանց գլոբալ հիմնաբառի անհրաժեշտության: Օրինակ:

";) sayHello(); // Տպում է "Hello, Zoya!" ?>

Ստատիկ փոփոխականներ. դրանք ինչ-որ տեղ են

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

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

Այնուամենայնիվ, կան իրավիճակներ, երբ հարմար կլինի ստեղծել լոկալ փոփոխական, որը «հիշում» է իր արժեքը ֆունկցիայի կանչերի միջև։ Նման փոփոխականը կոչվում է ստատիկ:

Ֆունկցիայի մեջ ստատիկ փոփոխական ստեղծելու համար դուք պետք է օգտագործեք ստատիկ բանալի բառը փոփոխականի անունից առաջ և համոզվեք, որ դրան սկզբնական արժեք եք տալիս: Օրինակ:

myFunction() ֆունկցիա ( ստատիկ $myVariable = 0; )

Դիտարկենք մի իրավիճակ, երբ հարմար է օգտագործել ստատիկ փոփոխական: Ենթադրենք, դուք ստեղծում եք մի ֆունկցիա, որը կանչվելիս ստեղծում է վիջեթ և ցուցադրում արդեն ստեղծված վիջեթների քանակը։ Կարող եք փորձել կոդ գրել այսպես՝ օգտագործելով տեղական փոփոխական.


"; echo createWidget() ." մենք արդեն ստեղծել ենք։
"; echo createWidget() ." մենք արդեն ստեղծել ենք։>
"; ?>

Բայց քանի որ $numWidgets փոփոխականը ստեղծվում է ամեն անգամ, երբ ֆունկցիան կանչվում է, մենք կստանանք հետևյալ արդյունքը.

Մենք ստեղծում ենք մի քանի վիդջեթներ... Մենք արդեն ստեղծել ենք 1: Մենք արդեն ստեղծել ենք 1. Մենք արդեն ստեղծել ենք 1.

Բայց օգտագործելով ստատիկ փոփոխական, մենք կարող ենք պահել արժեքը մի ֆունկցիայի կանչից մյուսը.

"; echo createWidget() ." մենք արդեն ստեղծել ենք։
"; echo createWidget() ." մենք արդեն ստեղծել ենք։
"; echo createWidget() ։ " >մենք արդեն ստեղծել ենք։
"; ?>

Այժմ սցենարը կտա ակնկալվող արդյունքը.

Մենք ստեղծում ենք մի քանի վիդջեթներ... Մենք արդեն ստեղծել ենք 1: Մենք արդեն ստեղծել ենք 2. Մենք արդեն ստեղծել ենք 3.

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

Այսքանը: Խնդրում ենք հաճախակի դիմել ձեր PHP փաստաթղթերին:

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

Ամենաճիշտ մոտեցումը կլինի գործառնությունների շարքը որպես ֆունկցիաներ/դասեր տեղադրել ֆայլի մեջ, ներառել ֆայլը (առանց ֆունկցիաներից դուրս վերադարձի հայտարարության), այնուհետև կանչել ֆունկցիան: ակնհայտորենպահանջվող փաստարկներով:

Այսպիսով, ո՞րն է խնդիրը:

Ամեն ինչ չափազանց պարզ է, դուք դա անում եք ներառումմեթոդի ներսում մեթոդ, ինչը նշանակում է, որ ներառված ֆայլում նշված փոփոխականները սկզբնավորվում են մեթոդի շրջանակում մեթոդ. Հետևաբար, փոփոխականը $ langգլոբալ չէ և սահմանափակվում է մեթոդի տեսանելիությամբ, և դուք մուտք եք գործում գլոբալ փոփոխական, այնպես որ, երբ օգտագործում եք փոփոխիչը համաշխարհայինայն հավասար կլինի զրոյականի։

Եթե ​​դուք ներառեք գլոբալ տիրույթում, ապա lang փոփոխականը կդառնա հանրային (գլոբալ) և դրա օգտագործումը հնարավոր կդառնա։ Սա հեշտ է ստուգել, ​​ներառված ֆայլում, նախքան որևէ փոփոխականի սահմանումը սկսելը, պարզապես գրեք գլոբալ $ փոփոխական:

Օրինակ:

ներառել «file1.php»; ֆունկցիան include2() (ներառում է «file2.php»;)
  • file1.php-ը սահմանված է գլոբալ տիրույթում:
  • file2.php-ը սահմանված է include2 ֆունկցիայի տեղական շրջանակում:

Գլոբալ փոփոխականների և նման ընդգրկումների հետ կապված մոտեցումը հենակետ է, որը ձեզ խնդիրներ կբերի ապագայում: Գործառույթները պետք է հստակորեն սահմանված լինեն, ունենան եզակի անվանում և կատարվեն ըստ պահանջի:

Ինչու՞ է վատ մոտեցումը գլոբալ փոփոխականներով:

Բանն այն է, որ գլոբալ փոփոխականները տեսանելի են ամենուր, գլոբալ: Սա հարմար է՝ սահմանափակումներ չկան։ Մյուս կողմից, լիովին անհնար է դառնում հետևել, թե ով է փոխում տվյալները։ Անվերահսկելի փոփոխությունները առաջին բանն է, որ սովորաբար գալիս է մտքում, երբ հարցնում են, թե ինչու են գլոբալ փոփոխականները վատ:

Ենթադրենք, դուք ունեք ֆունկցիա, որի արդյունքը կախված է գլոբալ փոփոխականից: Զանգում ես, զանգում ես, բայց 10 րոպե հետո ֆունկցիան սկսում է սխալ արդյունքներ տալ։ Ինչ է պատահել? Ի վերջո, դուք նույն պարամետրերի փաթեթն եք փոխանցում դրան որպես մուտքագրում: Հմմ, ինչ-որ մեկը փոխել է գլոբալ փոփոխականի արժեքը... Ո՞վ կարող է լինել: Այո, որևէ մեկը, ի վերջո, գլոբալ փոփոխականը հասանելի է բոլորին:

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

Ձեր նախագծում անհարկի մի օգտագործեք գլոբալ փոփոխականներ, օգտվեք տեղական շրջանակի բոլոր հնարավորություններից՝ պարամետրեր փոխանցելով ֆունկցիայի արգումենտներին, և կոդը ավելի հեշտ կլինի գրել, պահպանել և փորձարկել։

Գիտե՞ք, թե որն է գլոբալ փոփոխականների լավագույն նախածանցը:

Փոփոխականներ, որոնք սահմանված են ենթածրագրի շրջանակներում (օգտագործողի կողմից սահմանված գործառույթ): Դրանք հասանելի են միայն այն գործառույթի շրջանակներում, որով դրանք սահմանված են:

PHP-ի համար բոլոր փոփոխականները, որոնք հայտարարագրվել և օգտագործվում են ֆունկցիայում, լռելյայնորեն տեղական են ֆունկցիայի համար: Այսինքն՝ լռելյայն հնարավոր չէ փոխել գլոբալ փոփոխականի արժեքը ֆունկցիայի մարմնում։

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

Այս փաստը բացատրենք կոնկրետ օրինակով.

$a = 100;

ֆունկցիայի ֆունկցիա () (
$a = 70;
արձագանք»

$a

" ;
}
ֆունկցիա ();
արձագանք»

$a

" ;
?>

Սցենարը նախ կտպագրի 70, ապա 100.

70
100

Այս թերությունից ազատվելու համար PHP-ում կա հատուկ հրահանգ համաշխարհային, որը թույլ է տալիս օգտվողի կողմից սահմանված ֆունկցիան աշխատել գլոբալ փոփոխականների հետ: Դիտարկենք այս սկզբունքը՝ օգտագործելով կոնկրետ օրինակներ.

$a = 1;
$b = 2;

Գործառույթի գումար ()
{
համաշխարհային $a, $b;

$b = $a + $b ;
}

Գումար ();
արձագանք $b ;
?>

Վերոնշյալ սցենարը դուրս կգա « 3 «Սահմանելուց հետո $aԵվ $bնման ֆունկցիայի ներսում համաշխարհայինԱյս փոփոխականներից որևէ մեկի բոլոր հղումները մատնանշում են դրանց գլոբալ տարբերակը: Համաշխարհային փոփոխականների քանակի սահմանափակում չկա, որոնք կարող են կարգավորվել օգտատիրոջ կողմից սահմանված գործառույթներով:

Գլոբալ շրջանակի փոփոխականներ մուտք գործելու երկրորդ եղանակը PHP-ով սահմանված հատուկ զանգվածի օգտագործումն է $ ԳԼՈԲԱԼՆԵՐ. Նախորդ օրինակը կարելի է վերաշարադրել այսպես.

Օգտագործելով $GLOBALS-ը համաշխարհայինի փոխարեն.

$a = 1;
$b = 2;

Գործառույթի գումար ()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b"];
}

Գումար ();
արձագանք $b ;
?>

$ ԳԼՈԲԱԼՆԵՐասոցիատիվ զանգված է, որի բանալին անունն է, իսկ արժեքը՝ գլոբալ փոփոխականի բովանդակությունը։ Նկատի ունեցեք, որ $GLOBALS-ը գոյություն ունի ցանկացած տիրույթում, դա պայմանավորված է նրանով, որ սա զանգված է: Ստորև բերված է սուպերգլոբալների հնարավորությունները ցուցադրող օրինակ.

ֆունկցիա test_global()
{
// Նախապես սահմանված փոփոխականների մեծ մասը չեն
// «սուպեր» և հասանելի լինել տեղական տարածքում
// ֆունկցիայի տեսանելիությունը պահանջում է «գլոբալ» նշել:
համաշխարհային $HTTP_POST_VARS;

Echo $HTTP_POST_VARS["name"];

// Սուպերգլոբալները հասանելի են ցանկացած ծավալով
// տեսանելիություն և չեն պահանջում «գլոբալ» նշել:
// Superglobals-ը հասանելի է PHP 4.1.0-ից
echo $_POST ["անուն"];
}
?>



Հարակից հրապարակումներ