Php7 - PHP: global sa loob ng isang function ay hindi nagpapakita ng variable - Stack Overflow sa Russian. Saklaw ng mga variable ng PHP. Lahat ng gusto mong malaman ngunit natatakot kang magtanong Mag-print ng global php variable sa labas ng isang function

Huling na-update: 11/1/2015

Kapag gumagamit ng mga variable at function, isaalang-alang ang variable na saklaw. Tinutukoy ng saklaw ang saklaw ng pagkilos at pagiging naa-access ng isang naibigay na variable.

Mga lokal na variable

Ang mga lokal na variable ay nilikha sa loob ng isang function. Ang mga naturang variable ay maaari lamang ma-access mula sa loob ng isang ibinigay na function. Halimbawa:

Sa kasong ito, ang get() function ay tumutukoy sa isang lokal na variable $result . At mula sa pangkalahatang konteksto hindi natin ito ma-access, ibig sabihin, isulat ang $a = $result; Hindi ito posible dahil ang saklaw ng $result variable ay limitado ng get() function. Sa labas ng function na ito, ang $result variable ay hindi umiiral.

Ang parehong naaangkop sa mga parameter ng function: sa labas ng function, ang mga parameter na $lowlimit at $highlimit ay wala din.

Bilang isang patakaran, ang mga lokal na variable ay nag-iimbak ng ilang mga intermediate na resulta ng mga kalkulasyon, tulad ng sa halimbawa sa itaas.

Mga Static na Variable

Ang mga static na variable ay katulad ng mga lokal na variable. Naiiba sila sa na pagkatapos makumpleto ang pag-andar, ang kanilang halaga ay nai-save. Sa tuwing tatawagin ang function, ginagamit nito ang dating nakaimbak na halaga. Halimbawa:

Upang ipahiwatig na ang isang variable ay magiging static, ang keyword na static ay idinagdag dito. Sa tatlong magkakasunod na tawag sa getCounter(), ang $counter variable ay dadagdagan ng isa.

Kung ang $counter variable ay isang regular na non-static na variable, ang getCounter() ay magpi-print ng 1 tuwing ito ay tatawagin.

Karaniwan, ang mga static na variable ay ginagamit upang lumikha ng iba't ibang mga counter, tulad ng sa halimbawa sa itaas.

Mga Global Variable

Minsan gusto mong maging available ang isang variable kahit saan, sa buong mundo. Ang ganitong mga variable ay maaaring mag-imbak ng ilang data na karaniwan sa buong programa. Upang tukuyin ang mga pandaigdigang variable, gamitin ang pangkalahatang keyword:1

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

Pagkatapos tawagan ang getGlobal() function, ang $gvar variable ay maaaring ma-access mula sa anumang bahagi ng programa.

Ang tala: Ang adaptive na bersyon ng site ay isinaaktibo, na awtomatikong umaangkop sa maliit na sukat ng iyong browser at nagtatago ng ilang mga detalye ng site para sa kadalian ng pagbabasa. Masiyahan sa panonood!

Kamusta mahal na mga mambabasa ng blog Lugar sa! Sa natutunan namin na mayroong isang function sa PHP, natutunan namin kung paano lumikha ng aming sariling mga function, ipasa ang mga argumento sa kanila at tawagan ang mga ito para sa pagpapatupad. Sa pagpapatuloy ng paksa ng mga function sa PHP, kinakailangang bigyang-diin ang mga sumusunod na bagay:

  • Sa loob ng function, maaari mong gamitin ang anumang PHP code (mga cycle, kundisyon, anumang operasyon), kabilang ang iba pang mga function (parehong built-in at custom);
  • Ang pangalan ng function ay dapat magsimula sa isang Latin na titik o isang underscore, na sinusundan ng anumang bilang ng mga Latin na titik, numero o underscore;
  • Ang lahat ng mga function ay may pandaigdigang saklaw, na nangangahulugan na ang anumang function ay maaaring tawagan kahit saan, kahit na ang function na iyon ay tinukoy sa loob ng isa pa;
  • Hindi sinusuportahan ng PHP ang overloading ng function, wala ring posibilidad na muling tukuyin (baguhin, idagdag) o tanggalin ang isang nilikhang function;
  • Ang mga function ay hindi kailangang tukuyin bago sila gamitin. Iyon ay, kung una kang tumawag sa isang function, at pagkatapos ay ilarawan ito sa code sa ibaba, hindi ito makakaapekto sa pagganap at hindi magiging sanhi ng mga error.

Mga Kondisyonal na Pag-andar

Maaari tayong lumikha ( tukuyin, ilarawan) ang isang function depende sa kundisyon. Halimbawa:

//tinawag ang function na sayHi, maaari itong tawagan kahit saan /*ang sayGoodbye function ay hindi matatawag dito, dahil hindi pa namin nasusuri ang kundisyon at hindi pa nakapasok sa loob ng if construct*/ if($apply)( function sayGoodbye())( echo "Bye everyone!
"; } } /*ngayon pwede na tayong tumawag sayGoodbye*/
"; }

Resulta:

At tingnan ang halimbawang ito:

/*at ito ang mangyayari kung tatawag ka dito sayGoodbye*/ magpaalam(); if($apply)( function sayGoodbye())( echo "Bye everyone!
"; ) ) function sayHi())( echo "Hello everyone!
"; }

Resulta:

Sa katunayan, hangga't nagtatrabaho ako, hindi pa ako nakakita ng ganito kahit saan, ngunit kailangan mong isaisip ang lahat ng posibilidad ng wika.

Mga nested na function

Ang nested function ay isang function na idineklara sa loob ng isa pang function. Halimbawa:

/*Hindi ka maaaring tumawag sa sayGoodbye dito, dahil lalabas lang ito pagkatapos tawagan ang sayHi function*/ sabihin hi(); /*tawagan ang function sayHi, maaari itong tawagan kahit saan*/ /*Ngayon ay maaari na tayong tumawag sayGoodbye*/ magpaalam(); function sayHi())( echo "Kumusta sa lahat!
"; function sayGoodbye())( echo "Bye everyone!
"; } }

Muli, sa unang traversal, minarkahan ng PHP interpreter ang sarili nito na nakahanap ito ng paglalarawan ng sayHi function, ngunit hindi pumapasok sa loob ng katawan nito, nakikita lang nito ang pangalan, at dahil ang interpreter ay hindi pumapasok sa katawan ng sayHi, pagkatapos ay wala itong ideya kung ano ang aming tinutukoy sa loob ng isa pang function – sayGoodbye.

Pagkatapos ang code ay magsisimulang mag-execute, tinatawagan namin ang sayHi, ang PHP interpreter ay kailangang pumunta sa katawan ng sayHi function upang maisakatuparan ito at doon ay hindi sinasadyang nahanap nito ang paglalarawan ng isa pang function - sayGoodbye, pagkatapos nito ang sayGoodbye ay maaaring tawagan kahit saan, nang maraming beses ayon sa gusto mo.

Ngunit ito ay nagkakahalaga ng pagbibigay pansin sa isang napaka banayad na punto sa sitwasyon sa itaas: ang sayHi function ay nagiging isang beses, dahil kung tatawagin natin itong muli, PHP ay muling makikita ang kahulugan ng sayGoodbye function, at sa PHP hindi mo magagawa. ito - hindi mo ma-override ang mga function. Sumulat ako tungkol dito at kung paano haharapin ito sa isang nakaraang artikulo.

Sa PHP, ang mga diskarteng inilarawan sa itaas ay bihirang ginagamit; mas madalas silang makikita, halimbawa, sa JavaScript.

Variable Saklaw

Mayroong eksaktong dalawang saklaw sa PHP: global At lokal. Iba-iba ang saklaw ng bawat istruktura ng programming language. Halimbawa, sa C++, kahit na ang mga loop ay may sariling (lokal) na saklaw. Sa PHP, sa pamamagitan ng paraan, ito ay isang pandaigdigang saklaw. Ngunit ngayon ay pinag-uusapan natin ang tungkol sa mga pag-andar.

Ang mga function sa PHP ay may sariling panloob na saklaw (lokal), iyon ay, ang lahat ng mga variable sa loob ng isang function ay makikita lamang sa loob ng mismong function na ito.

Kaya, muli: lahat ng nasa labas ng mga function ay ang pandaigdigang saklaw, lahat ng nasa loob ng mga function ay ang lokal na saklaw. Halimbawa:

Mahal na mga eksperto, pansin, tanong! Ano ang magiging output ng huling pagtuturo? echo $name; ?

Tulad ng nakita mo para sa iyong sarili, mayroon kaming 2 variable $pangalan, ang isa sa loob ng function (lokal na saklaw), ang isa ay nasa code lamang (global na saklaw), ang huling pagtatalaga sa isang variable $pangalan ay $name = "Rud Sergey"; Ngunit dahil nasa loob ito ng function, nanatili ito doon. Sa pandaigdigang saklaw, ang huling takdang-aralin ay $name = "Andrey"; na kung ano talaga ang nakikita natin bilang isang resulta.

Iyon ay, dalawang magkaparehong mga variable, ngunit sa magkakaibang mga saklaw ay hindi sila nagsalubong at hindi nakakaapekto sa isa't isa.

Hayaan akong ilarawan ang saklaw sa figure:

Sa unang paglalakbay, ang interpreter ay panandaliang ini-scan ang pandaigdigang saklaw, naaalala kung anong mga variable at function ang mayroon, ngunit hindi ini-execute ang code.

Pag-access sa mga pandaigdigang variable mula sa lokal na saklaw

Ngunit paano kung kailangan pa rin nating i-access ang parehong variable ng $name mula sa pandaigdigang saklaw mula sa isang function, at hindi lamang i-access ito, ngunit baguhin ito? Mayroong 3 pangunahing pagpipilian para dito. Ang una ay gumagamit ng isang keyword global:

"; pandaigdigang $pangalan; /*mula ngayon ang ibig naming sabihin ay ang global variable na $name*/$name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

Resulta:

Ngunit ang pamamaraang ito ay may kawalan, dahil na-access namin ang pandaigdigang variable $pangalan nawala (na-overwrote) namin ang isang lokal na variable $pangalan.

Pangalawang paraan ay gamitin PHP superglobal array. Ang PHP mismo ay awtomatikong inilalagay ang bawat variable na ginawa namin sa pandaigdigang saklaw sa array na ito. Halimbawa:

$name = "Andrey"; //Katulad ng$GLOBALS["pangalan"] = "Andrey";

Kaya naman:

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

Ang resulta ay pareho sa paggamit ng keyword global:

Sa pagkakataong ito ay hindi namin muling isinulat ang lokal na variable, iyon ay, ang variable $pangalan sa loob ng function ay nananatiling pareho at pantay "Andrey", ngunit hindi "Rud Sergey".

Pagpasa ng mga argumento sa pamamagitan ng sanggunian

Pangatlong paraan– ito ang paglilipat ng address ( mga link) ng isang variable, hindi ang halaga nito. Ang mga link sa PHP ay hindi masyadong matagumpay, hindi katulad ng ibang mga programming language. Gayunpaman, sasabihin ko sa iyo ang tanging tamang opsyon para sa pagpasa ng argumento sa pamamagitan ng pagtukoy sa isang function, na karaniwang sinusuportahan sa PHP 5.3 at mas mataas. Mayroong iba pang mga paraan upang gumana sa mga link, ngunit nagtrabaho sila sa PHP 5.2 at mas mababa, bilang isang resulta, ang mga developer ng PHP mismo ay nagpasya na abandunahin ang mga ito, kaya hindi namin pag-uusapan ang mga ito.

Kaya, ang TAMANG pagpasa ng isang argumento sa pamamagitan ng sanggunian sa PHP 5.3 at mas mataas ay ginagawa tulad ng sumusunod:

Function sayHi(& $name)(

Sa mismong paglalarawan ng function, nagdagdag kami ng icon na ampersand (&) - nangangahulugan ang icon na ito na hindi namin tinatanggap ang halaga ng variable, ngunit isang link (address) sa halagang ito sa memorya. Hinahayaan ka ng mga sanggunian sa PHP na lumikha ng dalawang variable na tumuturo sa parehong halaga. Nangangahulugan ito na kapag ang isa sa mga variable na ito ay nagbago, parehong nagbabago, dahil ang mga ito ay tumutukoy sa parehong halaga sa memorya.

At sa huli mayroon tayong:

//hindi tanggapin ang isang halaga, ngunit isang sanggunian sa halaga echo "Hello, ".$name."!
"; $name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

Resulta:

Mga Static na Variable

Isipin ang sumusunod na sitwasyon: kailangan nating bilangin kung ilang beses tayong bumati sa kabuuan. Narito ang sinusubukan naming gawin:

"; $c++; // dagdagan ang counter ng 1

Resulta:

Variable $c hindi naaalala ang kahulugan nito, ito ay nilikha muli sa bawat oras. Kailangan nating gawin ang ating lokal na variable $c naalala ang halaga nito pagkatapos isagawa ang function, para dito gumagamit sila ng isang keyword static:

// counter, ginawang static echo "Hello, ".$name."!
"; $c++; // dagdagan ang counter ng 1 echo "Nag-hello lang " . $c . "isang beses.

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

Resulta:

Nagbabalik ng mga halaga

Ang mga pag-andar ay may isang maginhawang bagay tulad ng pagbabalik ng mga halaga. Ito ay kapag ang isang function, sa halip na mag-print ng isang bagay sa screen, ay naglalagay ng lahat sa isang variable at nagbibigay sa variable na iyon sa amin. At tayo ay nagpapasya na kung ano ang gagawin dito. Halimbawa, kunin natin ang function na ito, ito ay naglalagay ng isang numero:

Resulta:

Gawin natin ito upang sa halip na ipakita ito sa screen, ibabalik nito ang resulta ng pagpapatupad. Upang gawin ito, gamitin ang return keyword:

Resulta:

Ngayon ay magagamit natin ito sa iba't ibang paraan:

//inilalabas ang resulta echo"
"; $num = getSquare(5); echo $num;

Resulta:

Pakitandaan na ang keyword bumalik ay hindi lamang nagbabalik ng isang halaga, ngunit ganap na nakakagambala sa pag-andar, iyon ay, ang lahat ng code na nasa ibaba ng keyword bumalik hinding hindi matutupad. Sa madaling salita, ang pagbabalik para sa mga function ay gumagana din tulad ng pahinga para sa mga loop:

echo "Hinding hindi ako maaabot ng PHP :(";) echo getSquare(5); //inilalabas ang resulta echo"
"; $num = getSquare(5); // itinalaga ang resulta sa isang variable echo $num; // ipakita ang variable sa screen

Resulta:

Yan ay bumalik– isa rin itong exit mula sa function. Maaari itong magamit nang walang halaga ng pagbabalik, para lamang sa kapakanan ng output.

Recursive function

Ang recursive function ay isang function na tumatawag sa sarili nito. Ang recursion ay hindi madalas na ginagamit at itinuturing na isang resource-intensive (mabagal) na operasyon. Ngunit nangyayari na ang paggamit ng recursion ay ang pinaka-halata at simpleng opsyon. Halimbawa:

"; kung($number< 20){ // upang ang recursion ay hindi maging walang katapusan countPlease(++$number); // tinawag ng function na countPlease ang sarili nito) ) countPlease(1);

Resulta:

Kung alam mo kung paano gawin nang walang recursion, pagkatapos ay mas mahusay na gawin ito.

Malakas na pag-type sa PHP (type refinement)

Gumagawa ang PHP ng maliliit na hakbang patungo sa malakas na pag-type, upang matukoy namin nang maaga kung anong uri ang dapat gawin ng isang function (ito ay tinatawag na uri-pahiwatig):

Resulta:

Catchable fatal error: Ang Argument 1 na ipinasa sa countPlease() ay dapat isang array, integer na ibinigay, na tinatawag sa /home/index.php sa linya 7 at tinukoy sa /home/index.php sa linya 3

Sinasabi sa amin ng error na inaasahan ng function na makatanggap ng array, ngunit sa halip ay ipinapasa namin ito ng isang numero. Sa kasamaang palad, sa ngayon ay maaari lamang naming tukuyin ang uri para sa (array), at sa PHP 5.4 ay nagdagdag din kami ng isang opsyon bilang matatawag:

Matatawagan sinusuri kung ang naipasa na halaga ay matatawag bilang isang function. Ang matatawag ay maaaring alinman sa pangalan ng isang function na tinukoy ng string variable, o isang object at ang pangalan ng method na tinatawag. Ngunit pag-uusapan natin ang tungkol sa mga bagay at pamamaraan sa ibang pagkakataon (ito ay isang seksyon ng object-oriented programming), ngunit pamilyar ka na sa mga function. Hindi ko maipakita sa iyo ang resulta ng trabaho, dahil kasalukuyang mayroon akong PHP 5.3, ngunit ito ay magiging:

Tinatawag na getEcho function

Paggamit ng Variable Length Argument

At sa wakas, isa pang napakabihirang ginagamit na nuance. Isipin ang isang sitwasyon: ipinapasa namin ang mga argumento sa isang function, kahit na hindi namin inilarawan ang mga ito sa function, halimbawa:

Resulta:

Tulad ng nakikita mo, walang mga error, ngunit ang aming mga naipasa na argumento ay hindi ginagamit kahit saan. Ngunit hindi ito nangangahulugan na wala na sila - naipasa pa rin sila sa function at magagamit natin ang mga ito; may mga built-in na PHP function para dito:

func_num_args()- Ibinabalik ang bilang ng mga argumento na ipinasa sa function
func_get_arg(sequence number)- Nagbabalik ng isang elemento mula sa isang listahan ng mga argumento
func_get_args()- Nagbabalik ng array na naglalaman ng mga argumento ng function

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

Resulta:

Konklusyon

Ang artikulo ngayong araw ay ang pangwakas sa paksa ng mga function sa PHP. Ngayon ay maaari kang magtiwala sa pagiging kumpleto ng iyong kaalaman tungkol sa paksang ito at may kumpiyansa na magagamit ang mga pag-andar para sa iyong mga pangangailangan.

Kung ang isang tao ay may pagnanais na pagbutihin ito, ngunit walang ideya kung paano ito gagawin, ang pinakamahusay na paraan ay ang pagsulat ng mga handa (built-in) na function ng PHP, halimbawa, maaari kang sumulat ng iyong sariling count() function. o anumang iba pa.

Salamat sa lahat para sa iyong pansin at makita ka muli! Kung may hindi malinaw, huwag mag-atubiling itanong ang iyong mga katanungan sa mga komento!

Sinasaklaw ng tutorial na ito ang saklaw ng mga variable ng PHP. Ipinapaliwanag ang pagkakaiba sa pagitan ng lokal at pandaigdigang saklaw, ipinapakita kung paano i-access ang mga pandaigdigang variable sa loob ng isang function, kung paano magtrabaho kasama ang mga superglobal at lumikha ng mga static na variable.

Kapag nagsimula kang mag-aral ng PHP at nagsimulang magtrabaho sa mga function at object, medyo nakakalito ang variable na saklaw. Sa kabutihang palad, ang mga patakaran ng PHP sa bagay na ito ay napakadaling maunawaan (kumpara sa iba pang mga programming language).

Ano ang saklaw?

Ang saklaw ng mga variable ay ang konteksto kung saan tinukoy ang variable at kung saan ito maa-access. Ang PHP ay may dalawang variable na saklaw:

  • Global- Maaaring ma-access ang mga variable kahit saan sa script
  • Lokal- Maa-access lamang ang mga variable sa loob ng function kung saan tinukoy ang mga ito

Ang saklaw ng isang variable, at lalo na ang lokal, ay lubos na nagpapasimple sa pamamahala ng code. Kung ang lahat ng mga variable ay pandaigdigan, maaari silang baguhin kahit saan sa script. Ito ay hahantong sa kaguluhan at malalaking script, dahil madalas ang iba't ibang bahagi ng script ay gumagamit ng mga variable na may parehong mga pangalan. Sa pamamagitan ng paglilimita sa saklaw sa lokal na konteksto, tinutukoy mo ang mga hangganan ng code na maaaring ma-access ang isang variable, na ginagawang mas matatag, modular, at mas madaling i-debug ang code.

Ang mga variable na may pandaigdigang saklaw ay tinatawag na global, at ang mga variable na may lokal na saklaw ay tinatawag na lokal.

Narito ang isang halimbawa kung paano gumagana ang mga global at lokal na variable.

"; ) sayHello(); echo "Halaga ng \$globalName: "$globalName"
"; echo "\$localName value: "$localName"
"; ?>

Hi Harry! $globalName value: "Zoe" $localName value: ""

Sa script na ito lumikha kami ng dalawang variable:

  • $globalName- Ito global variable
  • $localName- Ito lokal isang variable na nilikha sa loob ng sayHello() function.

Pagkatapos gumawa ng variable at function, ang script ay tumatawag sayHello(), na nagpi-print ng "Hello Harry!" . Sinusubukan ng script na i-output ang mga halaga ng dalawang variable gamit ang echo function. Narito kung ano ang mangyayari:

  • kasi $globalName ay nilikha sa labas ng function, ito ay magagamit saanman sa script, kaya "Zoe" ay output.
  • $localName ay magagamit lamang sa loob ng sayHello() function. Dahil ang echo expression ay nasa labas ng function, ang PHP ay hindi nagbibigay ng access sa lokal na variable. Sa halip, inaasahan ng PHP na gagawa ang code ng bagong variable na tinatawag na $localName , na magkakaroon ng default na halaga ng walang laman na string. kaya naman ang pangalawang tawag sa echo ay naglalabas ng value na "" para sa $localName variable.

Pag-access sa mga pandaigdigang variable sa loob ng isang function

Upang ma-access ang isang pandaigdigang variable wala sa function Ang pagsusulat lang ng kanyang pangalan ay sapat na. Ngunit upang ma-access ang isang pandaigdigang variable sa loob ng isang function, kailangan mo munang ideklara ang variable bilang global sa function gamit ang global na keyword:

Function myFunction() ( global $globalVariable; // I-access ang global variable na $globalVariable )

Kung hindi mo ito gagawin, ipinapalagay ng PHP na ikaw ay lumilikha o gumagamit ng isang lokal na variable.

Narito ang isang halimbawang script na gumagamit ng global variable sa loob ng isang function:

"; global $globalName; echo "Hello $globalName!
"; ) sayHello(); ?>

Kapag naisakatuparan, ang script ay maglalabas ng:

Hi Harry! Hello Zoya!

Ang sayHello() function ay gumagamit ng pandaigdigang keyword upang ideklara ang $globalName variable na global. Maa-access niya pagkatapos ang variable at i-output ang value nito (“Zoe”).

Ano ang mga superglobal?

Ang PHP ay may espesyal na hanay ng mga paunang natukoy na mga global array na naglalaman ng iba't ibang impormasyon. Ang ganitong mga array ay tinatawag superglobals, dahil ang mga ito ay naa-access mula sa kahit saan sa script, kabilang ang panloob na espasyo sa pag-andar, at hindi kailangang tukuyin gamit ang pandaigdigang keyword.

Narito ang isang listahan ng mga superglobal na available sa PHP bersyon 5.3:

  • $GLOBALS - listahan ng lahat ng pandaigdigang variable sa script (hindi kasama ang mga superglobal)
  • $_GET - naglalaman ng isang listahan ng lahat ng mga field ng form na isinumite ng browser gamit ang isang kahilingan sa GET
  • $_POST - naglalaman ng isang listahan ng lahat ng mga field ng form na ipinadala ng browser gamit ang isang kahilingan sa POST
  • $_COOKIE - naglalaman ng listahan ng lahat ng cookies na ipinadala ng browser
  • $_REQUEST - naglalaman ng lahat ng key/value combinations na nasa $_GET, $_POST, $_COOKIE arrays
  • $_FILES - naglalaman ng listahan ng lahat ng file na na-download ng browser
  • $_SESSION - nagbibigay-daan sa iyong mag-imbak at gumamit ng mga variable ng session para sa kasalukuyang browser
  • $_SERVER - naglalaman ng impormasyon tungkol sa server, tulad ng pangalan ng file ng script na isinasagawa at ang IP address ng browser.
  • $_ENV - naglalaman ng listahan ng mga variable ng kapaligiran na ipinasa sa PHP, tulad ng mga variable ng CGI.
Halimbawa, maaari mong gamitin ang $_GET upang makuha ang mga halaga ng mga variable na nakapaloob sa string ng URL ng kahilingan ng script, at ipakita ang mga ito sa pahina:

Kung pinapatakbo mo ang script sa itaas gamit ang URL na http://www.example.com/script.php?yourName=Fred, maglalabas ito ng:

Hello Fred!

Babala! Sa isang tunay na script, hindi dapat gamitin ang naturang paglilipat ng data dahil sa mahinang seguridad. Dapat mong palaging i-validate o i-filter ang data.

Ang superglobal ng $GLOBALS ay napaka-maginhawang gamitin dahil binibigyang-daan ka nitong ayusin ang access sa mga global variable sa isang function nang hindi nangangailangan ng pandaigdigang keyword. Halimbawa:

"; ) sayHello(); // Nagpi-print ng "Hello, Zoya!" ?>

Mga static na variable: nasa paligid sila sa isang lugar

Kapag lumikha ka ng isang lokal na variable sa loob ng isang function, ito ay umiiral lamang habang tumatakbo ang function. Kapag nakumpleto ang function, mawawala ang lokal na variable. Kapag ang function ay tinawag muli, isang bagong lokal na variable ay nilikha.

Sa karamihan ng mga kaso ito ay mahusay na gumagana. Kaya, ang mga pag-andar ay nakapag-iisa at palaging gumagana nang pareho sa tuwing sila ay tinatawag.

Gayunpaman, may mga sitwasyon kung saan magiging maginhawang gumawa ng lokal na variable na "naaalala" ang halaga nito sa pagitan ng mga function call. Ang ganitong variable ay tinatawag na static.

Upang lumikha ng static na variable sa isang function, dapat mong gamitin ang static na keyword bago ang pangalan ng variable at tiyaking bigyan ito ng paunang halaga. Halimbawa:

Function myFunction() ( static $myVariable = 0; )

Isaalang-alang natin ang isang sitwasyon kung kailan maginhawang gumamit ng static na variable. Sabihin nating lumikha ka ng isang function na, kapag tinawag, ay lumilikha ng isang widget at ipinapakita ang bilang ng mga widget na nagawa na. Maaari mong subukang magsulat ng code tulad nito gamit ang isang lokal na variable:


"; echo createWidget() . " nakagawa na kami.
"; echo createWidget() . " nagawa na namin.>
"; ?>

Ngunit, dahil ang $numWidgets variable ay nilikha sa tuwing tatawagin ang function, makukuha natin ang sumusunod na resulta:

Gumagawa kami ng ilang widget... Nakagawa na kami ng 1. Nakagawa na kami ng 1. Nakagawa na kami ng 1.

Ngunit sa pamamagitan ng paggamit ng isang static na variable, maaari naming iimbak ang halaga mula sa isang function na tawag sa isa pa:

"; echo createWidget() . " nakagawa na kami.
"; echo createWidget() . " nakagawa na kami.
"; echo createWidget() . " >nakagawa na kami.
"; ?>

Ngayon ang script ay maglalabas ng inaasahang resulta:

Gumagawa kami ng ilang widget... Nakagawa na kami ng 1. Nakagawa na kami ng 2. Nakagawa na kami ng 3.

Bagama't pinapanatili ng isang static na variable ang halaga nito sa pagitan ng mga function call, valid lang ito habang tumatakbo ang script. Sa sandaling makumpleto ng script ang pagpapatupad, ang lahat ng mga static na variable ay masisira, pati na rin ang mga lokal at pandaigdigang variable.

Iyon lang! Mangyaring sumangguni sa iyong dokumentasyon ng PHP nang madalas.

Ang bagay na dapat tandaan dito ay ang elemento ng code na iyong ipinakita ay dapat isaalang-alang bilang masamang disenyo at istilo ng programming, dahil tinatrato nito ang kasamang file bilang isang instant executable na hanay ng mga operasyon.

Ang pinakatamang diskarte ay ang ilagay ang hanay ng mga operasyon bilang mga function/klase na may sariling pangalan sa isang file, isama ang file (nang walang anumang return statement sa labas ng mga function), at pagkatapos ay tawagan ang function halata naman kasama ang kinakailangang hanay ng mga argumento.

So anong problema?

Ang lahat ay sobrang simple, gagawin mo ito isama sa loob ng isang pamamaraan paraan, na nangangahulugang ang mga variable na tinukoy sa kasamang file ay sinisimulan sa saklaw ng pamamaraan paraan. Samakatuwid, ang variable $lang ay hindi pandaigdigan at nalilimitahan ng visibility ng pamamaraan, at ina-access mo ang isang global variable, kaya kapag ginagamit ang modifier global ito ay magiging katumbas ng null.

Kung isasama mo sa pandaigdigang saklaw, magiging pampubliko (global) ang variable na lang at magiging posible ang paggamit nito. Madali itong suriin; sa kasamang file, bago simulan ang pagtukoy ng anumang variable, isulat lamang pandaigdigang $variable.

Halimbawa:

isama ang "file1.php"; function include2() ( isama ang "file2.php"; )
  • Ang file1.php ay tinukoy sa pandaigdigang saklaw.
  • Ang file2.php ay tinukoy sa lokal na saklaw ng include2 function.

Ang diskarte sa mga pandaigdigang variable at tulad nito ay isang saklay na magdadala sa iyo ng mga problema sa hinaharap. Ang mga function ay dapat na tahasang tinukoy, may natatanging pangalan, at isakatuparan kapag hinihiling.

Bakit masama ang diskarte sa mga global variable?

Ang punto ay ang mga pandaigdigang variable ay makikita mula sa lahat ng dako, sa buong mundo. Ito ay maginhawa: walang mga paghihigpit. Sa kabilang banda, nagiging ganap na imposibleng subaybayan kung sino ang nagbabago ng data. Ang hindi nakokontrol na mga pagbabago ay ang unang bagay na karaniwang naiisip kapag tinanong kung bakit masama ang mga pandaigdigang variable.

Sabihin nating mayroon kang function na ang resulta ay depende sa isang global variable. Tawagan mo ito, tawagan ito, ngunit pagkatapos ng 10 minuto ang function ay magsisimulang magbalik ng mga maling resulta. Anong nangyari? Pagkatapos ng lahat, ipinapasa mo ang parehong hanay ng mga parameter dito bilang input? Hmm, may nagbago sa halaga ng isang global variable... Sino kaya ito? Oo, kahit sino - pagkatapos ng lahat, isang pandaigdigang variable ay magagamit sa lahat..

Ang pinakamahusay na recipe para sa pagdidisenyo ng mga subroutine ay: gawin ang resulta ng iyong function na nakasalalay lamang sa mga argumento. Ito ay isang mainam na pagsusumikap.

Huwag gumamit ng mga pandaigdigang variable sa iyong proyekto nang hindi kinakailangan, samantalahin ang lahat ng mga tampok ng lokal na saklaw, pagpasa ng mga parameter upang gumana ang mga argumento, at ang code ay magiging mas madaling isulat, mapanatili, at subukan.

Alam mo ba kung ano ang pinakamahusay na prefix para sa mga global variable?

Tinukoy ang mga variable sa loob ng isang subroutine (function na tinukoy ng user). Maa-access lamang ang mga ito sa loob ng function kung saan tinukoy ang mga ito.

Para sa PHP, lahat ng mga variable na ipinahayag at ginamit sa isang function ay lokal sa function bilang default. Iyon ay, bilang default, hindi posible na baguhin ang halaga ng isang global variable sa katawan ng isang function.

Kung sa katawan ng isang function na tinukoy ng gumagamit ay gumagamit ka ng isang variable na may pangalan na kapareho ng pangalan ng isang global variable (na matatagpuan sa labas ng function na tinukoy ng user), ang lokal na variable na ito ay walang anumang kaugnayan sa global variable. Sa sitwasyong ito, isang lokal na variable na may pangalan na kapareho ng pangalan ng global variable ay gagawin sa user-defined function, ngunit ang lokal na variable na ito ay magagamit lamang sa loob ng user-defined function na ito.

Ipaliwanag natin ang katotohanang ito sa isang tiyak na halimbawa:

$a = 100 ;

function function() (
$a = 70 ;
echo"

$a

" ;
}
function();
echo"

$a

" ;
?>

Ang script ay magpi-print muna ng 70 at pagkatapos ay 100:

70
100

Upang mapupuksa ang disbentaha na ito, mayroong isang espesyal na pagtuturo sa PHP global, na nagpapahintulot sa isang function na tinukoy ng user na gumana sa mga global variable. Tingnan natin ang prinsipyong ito gamit ang mga partikular na halimbawa:

$a = 1 ;
$b = 2 ;

Function Sum()
{
pandaigdigang $a, $b;

$b = $a + $b ;
}

Sum();
echo $b ;
?>

Ang script sa itaas ay maglalabas ng " 3 ". Pagkatapos tukuyin $a At $b sa loob ng function tulad ng global lahat ng reference sa alinman sa mga variable na ito ay tuturo sa kanilang global na bersyon. Walang limitasyon sa bilang ng mga pandaigdigang variable na maaaring pangasiwaan ng mga function na tinukoy ng user.

Ang pangalawang paraan upang ma-access ang mga variable ng pandaigdigang saklaw ay ang paggamit ng isang espesyal na array na tinukoy ng PHP $GLOBALS. Ang nakaraang halimbawa ay maaaring muling isulat tulad nito:

Paggamit ng $GLOBALS sa halip na global:

$a = 1 ;
$b = 2 ;

Function Sum()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b" ];
}

Sum();
echo $b ;
?>

$GLOBALS ay isang associative array na ang susi ay ang pangalan at ang halaga ay ang mga nilalaman ng global variable. Tandaan na ang $GLOBALS ay umiiral sa anumang saklaw, ito ay dahil ito ay isang array. Nasa ibaba ang isang halimbawa na nagpapakita ng mga kakayahan ng mga superglobal:

function test_global()
{
// Karamihan sa mga paunang natukoy na variable ay hindi
// "super" at maging available sa lokal na lugar
// function visibility ay nangangailangan ng "global" na tinukoy.
pandaigdigang $HTTP_POST_VARS ;

Echo $HTTP_POST_VARS["pangalan"];

// Ang mga superglobal ay magagamit sa anumang saklaw
// visibility at hindi nangangailangan ng "global" na tukuyin.
// Superglobals available simula PHP 4.1.0
echo $_POST ["pangalan" ];
}
?>



Mga kaugnay na publikasyon