Php7 - PHP: a globális függvényen belül nem mutat változót - Stack Overflow oroszul. A PHP változók hatóköre. Minden, amit tudni akart, de félt megkérdezni Globális php változó nyomtatása függvényen kívül
Utolsó frissítés: 2015.11.01
Változók és függvények használatakor vegye figyelembe a változó hatókörét. A hatókör egy adott változó cselekvési körét és elérhetőségét határozza meg.
Lokális változók
A lokális változók egy függvényen belül jönnek létre. Az ilyen változókat csak egy adott függvényen belül lehet elérni. Például:
Ebben az esetben a get() függvény egy $result helyi változót határoz meg. Az általános kontextusból pedig nem érhetjük el, vagyis írjuk $a = $eredmény; Ez nem lehetséges, mert a $result változó hatókörét a get() függvény korlátozza. Ezen a függvényen kívül a $result változó nem létezik.
Ugyanez vonatkozik a függvényparaméterekre is: a függvényen kívül a $lowlimit és $highlimit paraméterek sem léteznek.
A helyi változók általában a számítások néhány közbenső eredményét tárolják, mint a fenti példában.
Statikus változók
A statikus változók hasonlóak a lokális változókhoz. Abban különböznek egymástól, hogy a funkció befejezése után értékük mentésre kerül. A függvény minden meghívásakor a korábban tárolt értéket használja. Például:
Annak jelzésére, hogy egy változó statikus lesz, hozzáadjuk a static kulcsszót. A getCounter() három egymást követő meghívásával a $counter változó eggyel nő.
Ha a $counter változó egy normál, nem statikus változó lenne, akkor a getCounter() 1-et ír ki minden alkalommal, amikor meghívják.
Általában statikus változókat használnak különféle számlálók létrehozására, mint a fenti példában.
Globális változók
Néha azt szeretné, ha egy változó mindenhol elérhető lenne, globálisan. Az ilyen változók tárolhatnak néhány, az egész programra jellemző adatot. Globális változók meghatározásához használja a globális kulcsszót:1
"; ) getGlobal(); echo $gvar; ?>
A getGlobal() függvény meghívása után a $gvar változó a program bármely részéből elérhető.
A jegyzet: A webhely adaptív verziója aktiválva van, amely automatikusan alkalmazkodik a böngésző kis méretéhez, és elrejti a webhely egyes részleteit a könnyebb olvashatóság érdekében. Jó szórakozást!
Sziasztok kedves blog olvasók Webhely tovább! Megtanultuk, hogy a PHP-ben van függvény, megtanultuk, hogyan hozhatunk létre saját függvényeket, hogyan adhatunk át nekik argumentumokat és hívhatjuk meg őket végrehajtásra. Folytatva a PHP-beli függvények témakörét, a következőket kell kiemelni:
- A függvényen belül bármilyen PHP kódot használhat (ciklusokat, feltételeket, bármilyen műveletet), beleértve az egyéb függvényeket is (beépített és egyedi);
- A függvény nevének latin betűvel vagy aláhúzásjellel kell kezdődnie, amit tetszőleges számú latin betű, szám vagy aláhúzás követhet;
- Minden függvénynek globális hatóköre van, ami azt jelenti, hogy bármely függvény bárhol meghívható, még akkor is, ha az adott függvény egy másikon belül van definiálva;
- A PHP nem támogatja a funkciók túlterhelését, nincs lehetőség a létrehozott függvény újradefiniálására (módosítására, hozzáadására) vagy törlésére;
- A függvényeket nem kell meghatározni használatuk előtt. Vagyis ha először meghív egy függvényt, és csak azután írja le az alábbi kódban, az nem befolyásolja a teljesítményt és nem okoz hibát.
Feltételes függvények
A feltételtől függően létrehozhatunk (definiálhatunk, leírhatunk) függvényt. Például:
//meghívta a sayHi függvényt, bárhol meg lehet hívni
/*a sayGoodbye függvény itt nem hívható meg, mivel még nem ellenőriztük a feltételt és nem mentünk be az if konstrukcióba*/ if($apply)( function sayGoodbye())( echo "Viszlát mindenkinek!
";
}
}
/*most már elköszönhetünk*/
";
}
Eredmény:
És nézd meg ezt a példát:
/*és ez fog történni, ha ide hívod a Goodbye-t*/ elköszönni(); if($apply)( function sayGoodbye())( echo "Viszlát mindenkinek!
"; ) ) function sayHi())( echo "Üdv mindenkinek!
";
}
Eredmény:
Sőt, amennyit dolgoztam, sehol nem láttam ehhez hasonlót, de szem előtt kell tartani a nyelv minden lehetőségét.
Beágyazott függvények
A beágyazott függvény egy másik függvényen belül deklarált függvény. Példa:
/*Itt nem hívhatod meg a sayGoodbye-t, mert csak a sayHi függvény meghívása után jelenik meg*/ Mondd Szia(); /*hívd a sayHi függvényt, bárhol meg lehet hívni*/
/*Most már elköszönhetünk*/ elköszönni(); function sayHi())( echo "Üdv mindenkinek!
"; function sayGoodbye())( echo "Viszlát mindenki!
";
}
}
Ismét az első bejáráskor a PHP értelmező megjelöli magát, hogy megtalálta a sayHi függvény leírását, de nem megy be a törzsébe, csak a nevet látja, és mivel az interpreter nem megy be a sayHi törzsébe, akkor fogalma sincs, mit definiálunk egy másik funkcióban – mondd el, viszlát.
Ekkor elindul a kód végrehajtása, hívjuk a sayHi-t, a PHP interpreternek be kell mennie a sayHi függvény törzsébe, hogy végrehajtsa és ott véletlenül megtalálja egy másik függvény leírását - sayGoodbye, ami után a sayGoodbye bárhol hívható, ahányszor ahogy szeretnéd.
De érdemes figyelni a fenti helyzetben egy nagyon finom pontra: a sayHi függvény egyszerivé válik, mert ha újra hívjuk, akkor a PHP ismét találkozik a sayGoodbye függvény definíciójával, PHP-ben pedig ezt nem lehet megtenni. ez - nem bírálhatja felül a funkciókat. Erről és a kezelés módjáról egy korábbi cikkben írtam.
A PHP-ben a fent leírt technikákat nagyon ritkán használják, gyakrabban láthatók például a JavaScriptben.
Változó hatókör
A PHP-ben pontosan két hatókör van: globálisÉs helyi. Minden programozási nyelv másképp strukturálja a hatóköröket. Például a C++-ban még a ciklusoknak is megvan a saját (helyi) hatókörük. A PHP-ben egyébként ez egy globális hatókör. De ma funkciókról beszélünk.
A PHP függvényeinek saját belső hatókörük van (lokális), vagyis a függvényen belüli összes változó csak ezen a függvényen belül látható.
Tehát még egyszer: minden a függvényeken kívül a globális hatókör, minden a függvényen belül a lokális hatókör. Példa:
Kedves szakértők, figyelem, kérdés! Mit fog kiadni az utolsó utasítás? echo $név; ?
Amint maga is látta, 2 változónk volt $név, az egyik a függvényen belül (helyi hatály), a másik csak a kódban (globális hatókör), az utolsó hozzárendelés egy változóhoz $név volt $name = "Rud Szergej"; De mivel a funkción belül volt, ott is maradt. Globális körben az utolsó feladat az volt $name = "Andrey"; amit tulajdonképpen ennek eredményeként látunk.
Vagyis két azonos változó, de eltérő hatókörben nem metszik egymást és nem hatnak egymásra.
Hadd illusztráljam a terjedelmet az ábrán:
Az első bejárás során az értelmező röviden átvizsgálja a globális hatókört, megjegyzi, milyen változók és függvények vannak, de nem hajtja végre a kódot.
Globális változók elérése helyi hatókörből
De mi van akkor, ha mégis el kell érnünk ugyanazt a $name változót a globális hatókörből egy függvényből, és nem csak elérni, hanem módosítani is kell? 3 fő lehetőség van erre. Az első a kulcsszó használata globális:
"; globális $név; /* mostantól a $name globális változóra gondolunk*/$name = "Rud Szergej"; ) $név = "Andrey"; sayHi($név); echo $név; // ?
Eredmény:
Ennek a módszernek azonban van egy hátránya, mivel elértük a globális változót $név elvesztettünk (felülírtunk) egy lokális változót $név.
Második út használni PHP szuperglobális tömb. Maga a PHP automatikusan ebbe a tömbbe helyezi el a globális hatókörben létrehozott összes változót. Példa:
$name = "Andrey"; //Ugyanaz, mint a$GLOBALS["név"] = "Andrey";
Ennélfogva:
"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?
Az eredmény ugyanaz, mint a kulcsszó használatával globális:
Csak ezúttal nem írtuk át a lokális változót, vagyis a változót $név belül a függvény ugyanaz marad és egyenlő "Andrey", de nem "Rud Szergej".
Érvek átadása hivatkozással
Harmadik út– ez a cím átadása ( linkeket) egy változó, nem pedig az értéke. A PHP hivatkozásai nem túl sikeresek, ellentétben más programozási nyelvekkel. Mindazonáltal elmondom az egyetlen helyes lehetőséget az argumentum átadására egy függvényre hivatkozva, amelyet általában a PHP 5.3 és újabb verziók támogatnak. Vannak más módszerek is a hivatkozásokkal való munkavégzésre, de ezek PHP 5.2 és régebbi verziókban működtek, ennek eredményeként maguk a PHP fejlesztők úgy döntöttek, hogy elhagyják őket, ezért nem beszélünk róluk.
Tehát egy argumentum HELYES átadása hivatkozással PHP 5.3 és újabb verziókban a következőképpen történik:
függvény sayHi(& $name)(
Magában a függvényleírásban hozzáadtunk egy és (&) ikont - ez az ikon azt jelenti, hogy nem a változó értékét fogadjuk el, hanem egy hivatkozást (címet) ehhez az értékhez a memóriában. A PHP hivatkozásai lehetővé teszik két, azonos értékre mutató változó létrehozását. Ez azt jelenti, hogy ha e változók egyike megváltozik, mindkettő megváltozik, mivel ugyanarra az értékre vonatkoznak a memóriában.
És a végén van:
//nem értéket fogadunk el, hanem az értékre való hivatkozást echo "Hello, ".$name."!
"; $name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?
Eredmény:
Statikus változók
Képzeljük el a következő helyzetet: meg kell számolnunk, hányszor köszöntünk összesen. Íme, mit próbálunk tenni:
"; $c++; // növelje a számlálót 1-gyel
Eredmény:
Változó $c nem emlékszik a jelentésére, minden alkalommal újra létrejön. Lokális változónkat kell létrehoznunk $c a függvény végrehajtása után megjegyezték az értékét, ehhez kulcsszót használnak statikus:
// számláló, statikussá tett echo "Hello, ".$name."!
"; $c++; // növelje a számlálót 1-gyel echo "Csak köszöntem" . $c . "egyszer.
"; ) sayHi("Rud Sergey"); sayHi("Andrey"); sayHi("Dmitry");
Eredmény:
Visszatérő értékek
A függvényeknek van egy olyan kényelmes dolga, mint az értékek visszaadása. Ilyenkor egy függvény ahelyett, hogy valamit a képernyőre nyomtatna, mindent egy változóba tesz, és ezt a változót megadja nekünk. És már eldöntöttük, hogy mit kezdjünk vele. Vegyük például ezt a függvényt, négyzetre emel egy számot:
Eredmény:
Tegyük úgy, hogy a képernyőn való megjelenítés helyett a végrehajtás eredményét adja vissza. Ehhez használja a return kulcsszót:
Eredmény:
Most ezt többféleképpen használhatjuk:
//kiadja az eredményt visszhang"
"; $szám = getSquare(5); echo $szám;
Eredmény:
Felhívjuk figyelmét, hogy a kulcsszó Visszatérés nem csak egy értéket ad vissza, hanem teljesen megszakítja a függvényt, vagyis az összes kódot, amely a kulcsszó alatt van Visszatérés soha nem fog teljesülni. Más szóval, a függvények visszatérése is így működik szünet hurkok esetén:
echo "A PHP soha nem fog elérni:(";) echo getSquare(5); //kiadja az eredményt visszhang"
"; $szám = getSquare(5); // az eredményt egy változóhoz rendelte echo $szám; // megjeleníti a változót a képernyőn
Eredmény:
Azaz Visszatérés– ez is egy kilépés a funkcióból. Visszatérési érték nélkül is használható, csak a kimenet kedvéért.
Rekurzív függvény
A rekurzív függvény olyan függvény, amely meghívja magát. A rekurziót nem gyakran használják, és erőforrás-igényes (lassú) műveletnek számít. De előfordul, hogy a rekurzió használata a legkézenfekvőbb és legegyszerűbb lehetőség. Példa:
"; if($szám< 20){ // hogy a rekurzió ne váljon végtelenné countPlease(++$szám); // a countPlease függvény meghívta magát) ) számolj kérlek(1);
Eredmény:
Ha tudja, hogyan kell rekurzió nélkül csinálni, akkor jobb, ha ezt teszi.
Erős gépelés PHP-ben (típusfinomítás)
A PHP kis lépésekkel halad az erős gépelés felé, így előre megadhatjuk, hogy egy függvény milyen típusú legyen (ez az ún típus-tipp):
Eredmény:
Elkapható végzetes hiba: A countPlease()-nek átadott 1. argumentumnak egy tömbnek kell lennie, egész számnak kell lennie, amelyet a /home/index.php fájlban kell meghívni a 7. sorban, és a 3. sorban a /home/index.php fájlban kell megadni.
A hiba azt jelzi, hogy a függvény egy tömb fogadására számít, de ehelyett egy számot adunk át neki. Sajnos egyelőre csak a (tömb) típusát tudjuk megadni, és a PHP 5.4-nél egy olyan opciót is hozzáadtunk, mint pl. hívható:
Hívható ellenőrzi, hogy az átadott érték függvényként hívható-e. A hívható lehet egy karakterlánc-változó által megadott függvény neve, vagy egy objektum és a meghívott metódus neve. De az objektumokról és metódusokról később lesz szó (ez az objektum-orientált programozás egy része), de a függvényeket már ismered. A munka eredményét nem tudom megmutatni, mivel jelenleg PHP 5.3-am van, de ez lenne:
Az úgynevezett getEcho függvény
Változó hosszúságú argumentumok használata
És végül még egy nagyon ritkán használt árnyalat. Képzeljünk el egy helyzetet: argumentumokat adunk át egy függvénynek, bár nem írtuk le őket a függvényben, például:
Eredmény:
Mint látható, nincsenek hibák, de az átadott argumentumainkat sehol sem használjuk. De ez nem jelenti azt, hogy eltűntek - még mindig átkerültek a függvénybe, és használhatjuk őket; ehhez beépített PHP függvények vannak:
func_num_args()- A függvénynek átadott argumentumok számát adja vissza
func_get_arg(sorszám)- Egy elemet ad vissza az argumentumok listájából
func_get_args()- A függvény argumentumait tartalmazó tömböt ad vissza
"; echo func_get_arg(0) ; ) $életkor = 22; getEcho("Rud Szergej", $kor);
Eredmény:
Következtetés
A mai cikk az utolsó a PHP-beli függvények témakörében. Most már biztos lehet abban, hogy tudása teljes körű ebben a témában, és magabiztosan használhatja a funkciókat igényeinek megfelelően.
Ha valakinek az a vágya, hogy jobbá váljon, de fogalma sincs, hogyan csinálja, akkor a legjobb módszer az lenne, ha kész (beépített) PHP függvényeket írna, például saját count() függvényt írhat. vagy bármely más.
Köszönöm mindenkinek a figyelmet és találkozunk! Ha valami nem világos, nyugodtan tedd fel kérdéseidet a megjegyzésekben!
Ez az oktatóanyag a PHP-változók hatókörét ismerteti. Elmagyarázza a különbséget a lokális és a globális hatókör között, bemutatja, hogyan lehet hozzáférni a globális változókhoz egy függvényen belül, hogyan kell dolgozni szuperglobálisokkal és statikus változókat létrehozni.
Amikor elkezdi tanulni a PHP-t, és elkezd dolgozni a függvényekkel és objektumokkal, a változó hatókör kissé zavaró. Szerencsére a PHP szabályai ezzel kapcsolatban nagyon könnyen érthetők (más programozási nyelvekhez képest).
Mi az a terjedelem?
A változók hatóköre az a kontextus, amelyben a változót meghatározták, és ahol elérhető. A PHP-nek két változó hatóköre van:
- Globális- a változók bárhol elérhetők a szkriptben
- Helyi- a változók csak azon a függvényen belül érhetők el, amelyben meghatározták őket
A változó hatóköre, és különösen a lokális, nagyban leegyszerűsíti a kódkezelést. Ha minden változó globális lenne, akkor a szkriptben bárhol módosíthatók. Ez káoszhoz és nagy szkriptekhez vezetne, mivel nagyon gyakran a szkript különböző részei azonos nevű változókat használnak. Ha a hatókört a helyi környezetre korlátozza, meghatározhatja a változókhoz hozzáférő kód határait, ami robusztusabbá, modulárisabbá és könnyebben hibakereshetőbbé teszi a kódot.
A globális hatókörű változókat globálisnak, a lokális hatókörű változókat pedig lokálisnak nevezzük.
Íme egy példa a globális és lokális változók működésére.
"; ) sayHello(); echo "A \$globalName értéke: "$globalName"
"; echo "\$localName érték: "$localName"
";
?>
Szia Harry! $globalName értéke: "Zoe" $localName értéke: ""
Ebben a szkriptben két változót hoztunk létre:
- $globalName- Ezt globális változó
- $localName- Ezt helyi egy változó, amely a sayHello() függvényen belül jön létre.
A változó és a függvény létrehozása után a szkript meghívja a sayHello(t), amely kiírja a "Hello Harry!" . A szkript ezután megpróbálja kiadni a két változó értékét az echo függvény segítségével. Íme, mi történik:
- Mert $globalName a függvényen kívül jött létre, bárhol elérhető a szkriptben, így a "Zoe" kerül kiadásra.
- $localName csak a sayHello() függvényen belül lesz elérhető. Mivel az echo kifejezés a függvényen kívül van, a PHP nem biztosít hozzáférést a helyi változóhoz. Ehelyett a PHP azt várja, hogy a kód egy új változót hozzon létre $localName néven, amelynek alapértelmezett értéke az üres karakterlánc lesz. ezért a második echo hívás a $localName változó "" értékét adja ki.
Globális változók elérése egy függvényen belül
Globális változó eléréséhez funkcióból Elég, ha leírja a nevét. De egy globális változó eléréséhez egy függvényen belül, először globálisként kell deklarálnia a változót a függvényben a globális kulcsszó használatával:
Függvény myFunction() ( globális $globalVariable; // A $globalVariable globális változó elérése)
Ha ezt nem teszi meg, a PHP feltételezi, hogy helyi változót hoz létre vagy használ.
Íme egy példaszkript, amely globális változót használ egy függvényen belül:
"; globális $globalName; echo "Hello $globalName!
"; ) Hello(); ?>
Végrehajtáskor a szkript a következőt adja ki:
Szia Harry! Szia Zoya!
A sayHello() függvény a globális kulcsszó segítségével deklarálja a $globalName változót globálisnak. Ezután hozzáférhet a változóhoz, és kiadhatja annak értékét („Zoe”).
Mik azok a szuperglobálisok?
A PHP speciális előre definiált globális tömbökkel rendelkezik, amelyek különféle információkat tartalmaznak. Az ilyen tömböket ún szuperglobálisok, mivel a szkriptben bárhonnan elérhetők, beleértve a belső függvényteret is, és nem kell őket a globális kulcsszó használatával meghatározni.
Íme a PHP 5.3-as verziójában elérhető szuperglobalok listája:
- $GLOBALS – a szkriptben lévő összes globális változó listája (a szuperglobálisok kivételével)
- $_GET - tartalmazza a böngésző által GET kéréssel beküldött összes űrlapmező listáját
- $_POST - tartalmazza a böngésző által POST kéréssel küldött űrlapmezők listáját
- $_COOKIE - tartalmazza a böngésző által küldött összes cookie listáját
- $_REQUEST - tartalmazza az összes kulcs/érték kombinációt, amelyet a $_GET, $_POST, $_COOKIE tömbök tartalmaznak
- $_FILES - tartalmazza a böngésző által letöltött összes fájl listáját
- $_SESSION – lehetővé teszi az aktuális böngésző munkamenet-változóinak tárolását és használatát
- $_SERVER - információkat tartalmaz a szerverről, például a végrehajtott szkript fájlnevét és a böngésző IP-címét.
- $_ENV - tartalmazza a PHP-nek átadott környezeti változók listáját, például a CGI-változókat.
Ha a fenti szkriptet a http://www.example.com/script.php?yourName=Fred URL-címmel futtatja, a következőt fogja kiadni:
Szia Fred!
Figyelem! Valódi szkriptben ilyen adatátvitelt soha nem szabad használni a gyenge biztonság miatt. Mindig ellenőriznie kell vagy szűrnie kell az adatokat.
A $GLOBALS szuperglobal nagyon kényelmesen használható, mert lehetővé teszi a globális változókhoz való hozzáférés megszervezését egy függvényben anélkül, hogy szükség lenne a globális kulcsszóra. Például:
"; ) sayHello(); // Kiírja a "Hello, Zoya!" ?> szöveget
Statikus változók: valahol ott vannak
Ha helyi változót hoz létre egy függvényen belül, az csak akkor létezik, amíg a függvény fut. Amikor a függvény befejeződik, a helyi változó eltűnik. A függvény ismételt meghívásakor egy új helyi változó jön létre.
A legtöbb esetben ez remekül működik. Így a függvények önállóak, és mindig ugyanúgy működnek, amikor meghívják őket.
Vannak azonban olyan helyzetek, amikor célszerű lenne létrehozni egy lokális változót, amely "emlékezik" az értékére a függvényhívások között. Az ilyen változókat statikusnak nevezzük.
Ha statikus változót szeretne létrehozni egy függvényben, akkor a statikus kulcsszót kell használnia a változó neve előtt, és mindenképpen kezdeti értéket kell adnia. Például:
Függvény myFunction() ( statikus $myVariable = 0; )
Tekintsünk egy helyzetet, amikor kényelmes statikus változót használni. Tegyük fel, hogy létrehoz egy függvényt, amely meghívásakor létrehoz egy widgetet, és megjeleníti a már létrehozott widgetek számát. Megpróbálhat ilyen kódot írni egy helyi változó használatával:
"; echo createWidget() . " már létrehoztuk.
"; echo createWidget() . " már létrehoztuk.>
";
?>
De mivel a $numWidgets változó minden függvényhíváskor létrejön, a következő eredményt kapjuk:
Létrehozunk néhány widgetet... Már létrehoztunk 1-et. Már létrehoztuk az 1. Már létrehoztuk az 1.
De statikus változó használatával tárolhatjuk az értéket egyik függvényhívásról a másikra:
"; echo createWidget() . " már létrehoztuk.
"; echo createWidget() . " már létrehoztuk.
"; echo createWidget() . " >már létrehoztuk.
";
?>
Most a szkript a várt eredményt hozza:
Létrehozunk néhány widgetet... Már létrehoztunk 1-et. Már létrehoztunk 2-t. 3-at már létrehoztunk.
Bár egy statikus változó megtartja értékét a függvényhívások között, csak a szkript futása közben érvényes. Amint a parancsfájl végrehajtása befejeződött, az összes statikus változó megsemmisül, csakúgy, mint a helyi és globális változók.
Ez minden! Kérjük, gyakran olvassa el PHP dokumentációját.
Itt meg kell jegyezni, hogy a bemutatott kódelemnek kell tekintenie rossz tervezés és programozási stílus, mert a benne lévő fájlt azonnal végrehajtható műveletkészletként kezeli.
A leghelyesebb megközelítés az lenne, ha a műveletek halmazát függvényként/osztályként saját nevükkel egy fájlba helyeznénk, belefoglalnánk a fájlt (a függvényeken kívüli return utasítás nélkül), majd meghívnánk a függvényt. magától értetődően a szükséges argumentumkészlettel.
Tehát mi a probléma?
Minden rendkívül egyszerű, csináld meg tartalmazza egy módszer belsejében módszer, ami azt jelenti, hogy a csatolt fájlban megadott változók inicializálásra kerülnek a metódus hatókörében módszer. Ezért a változó $lang nem globális és a módszer láthatósága korlátozza, és egy globális változóhoz fér hozzá, tehát a módosító használatakor globális nullával lesz egyenlő.
Ha belefoglalja a globális hatókörbe, akkor a lang változó nyilvános (globális) lesz, és lehetővé válik a használata. Ez könnyen ellenőrizhető; a mellékelt fájlba, mielőtt elkezdené a változó definiálását, csak írja be globális $változó.
Példa:
tartalmazza "file1.php"; függvény include2() ( include "file2.php"; )- A file1.php globális hatókörben van definiálva.
- A file2.php az include2 függvény helyi hatókörében van definiálva.
A globális változókkal és hasonlókkal való megközelítés olyan mankó, amely problémákat hoz a jövőben. A függvényeket kifejezetten meg kell határozni, egyedi nevük kell, hogy legyen, és igény szerint kell végrehajtani őket.
Miért rossz a globális változókkal való megközelítés?
A lényeg az, hogy a globális változók mindenhonnan láthatóak, globálisan. Ez kényelmes: nincsenek korlátozások. Másrészt teljesen lehetetlenné válik annak nyomon követése, hogy ki változtatja meg az adatokat. Az ellenőrizetlen változások az első dolog, ami eszünkbe jut, amikor megkérdezzük, miért rosszak a globális változók.
Tegyük fel, hogy van egy függvénye, amelynek eredménye egy globális változótól függ. Hívja, hívja, de 10 perc múlva a függvény hibás eredményeket kezd visszaadni. Mi történt? Végül is ugyanazt a paraméterkészletet adja át neki bemenetként? Hmm, valaki megváltoztatta egy globális változó értékét... Ki lehet az? Igen, bárki – elvégre egy globális változó mindenki számára elérhető.
A szubrutinok tervezésének legjobb receptje a következő: a függvény eredménye csak az argumentumoktól függjön. Ez egy ideális, amire törekedni kell.
Ne használjon globális változókat szükségtelenül a projektben, kihasználja a helyi hatókör összes funkcióját, paramétereket ad át a függvény argumentumainak, és a kód könnyebben írható, karbantartható és tesztelhető lesz.
Tudja, mi a legjobb előtag a globális változókhoz?
Alprogramon belül definiált változók (felhasználó által definiált függvény). Csak azon a függvényen belül érhetők el, amelyben meghatározásra kerültek.
PHP esetén a függvényben deklarált és használt összes változó alapértelmezés szerint a függvény lokális. Vagyis alapértelmezés szerint nem lehet megváltoztatni egy globális változó értékét a függvény törzsében.
Ha egy felhasználó által definiált függvény törzsében egy globális változó nevével azonos nevű változót használ (amely a felhasználó által definiált függvényen kívül található), akkor ennek a lokális változónak nem lesz kapcsolata a globális változóval. Ebben a helyzetben a globális változó nevével azonos nevű helyi változó jön létre a felhasználó által definiált függvényben, de ez a helyi változó csak ezen a felhasználói függvényen belül lesz elérhető.
Magyarázzuk meg ezt a tényt egy konkrét példával:
$a = 100 ;
függvény függvény() (
$a = 70 ;
visszhang"
$a
" ;}
funkció();
visszhang"
$a
" ;?>
A szkript először 70-et, majd 100-at nyomtat:
70
100
Ennek a hátránynak a kiküszöbölésére van egy speciális utasítás a PHP-ben globális, amely lehetővé teszi a felhasználó által definiált függvény számára, hogy globális változókkal dolgozzon. Nézzük meg ezt az elvet konkrét példák segítségével:
$a = 1;
$b = 2 ;
Függvényösszeg()
{
globális $a, $b;
$b = $a + $b ;
}
Összeg();
visszhang $b ;
?>
A fenti szkript a " 3 ". meghatározása után $aÉs $b a függvényen belül tetszik globális a változók bármelyikére való hivatkozás a globális verziójukra mutat. A felhasználó által definiált függvényekkel kezelhető globális változók száma nincs korlátozva.
A globális hatókörű változók elérésének második módja egy speciális PHP által definiált tömb használata $GLOBALS. Az előző példát így lehetne átírni:
$GLOBALS használata globális helyett:
$a = 1;
$b = 2 ;
Függvényösszeg()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b" ];
}
Összeg();
visszhang $b ;
?>
$GLOBALS egy asszociatív tömb, amelynek kulcsa a név, értéke pedig a globális változó tartalma. Vegye figyelembe, hogy a $GLOBALS bármely hatókörben létezik, mert ez egy tömb. Az alábbiakban egy példa a szuperglobális képességek bemutatására:
függvény test_global()
{
// A legtöbb előre definiált változó nem
// "szuper" és elérhető legyen a környéken
// A függvény láthatósága megköveteli a "global" megadását.
globális $HTTP_POST_VARS ;
Echo $HTTP_POST_VARS["név"];
// A szuperglobalok bármilyen hatókörben elérhetők
// láthatóság, és nem szükséges a "global" megadása.
// A PHP 4.1.0 óta elérhető Superglobals
echo $_POST ["név" ];
}
?>
