Globala variabler i PHP. Php variabel synlighet scope variabel synlighet i funktioner
Senaste uppdatering: 11/1/2015
När du använder variabler och funktioner, överväg variabel omfattning. Omfattningen anger handlingsomfattningen och tillgängligheten för en given variabel.
Lokala variabler
Lokala variabler skapas inuti en funktion. Sådana variabler kan endast nås från en given funktion. Till exempel:
I det här fallet definierar funktionen get() en lokal variabel $result . Och från det allmänna sammanhanget kan vi inte komma åt det, det vill säga skriv $a = $result; Detta är inte möjligt eftersom omfattningen av variabeln $result begränsas av funktionen get(). Utanför denna funktion existerar inte variabeln $result.
Detsamma gäller funktionsparametrar: utanför funktionen finns inte heller parametrarna $lowlimit och $highlimit.
Som regel lagrar lokala variabler vissa mellanresultat av beräkningar, som i exemplet ovan.
Statiska variabler
Statiska variabler liknar lokala variabler. De skiljer sig åt genom att efter att funktionen är klar sparas deras värde. Varje gång funktionen anropas använder den det tidigare lagrade värdet. Till exempel:
För att indikera att en variabel kommer att vara statisk läggs nyckelordet static till den. Med tre på varandra följande anrop till getCounter(), kommer variabeln $counter att ökas med ett.
Om variabeln $counter var en vanlig icke-statisk variabel, skulle getCounter() skriva ut 1 varje gång den anropades.
Vanligtvis används statiska variabler för att skapa olika räknare, som i exemplet ovan.
Globala variabler
Ibland vill man att en variabel ska vara tillgänglig överallt, globalt. Sådana variabler kan lagra vissa data som är gemensamma för hela programmet. För att definiera globala variabler, använd det globala nyckelordet:1
"; ) getGlobal(); echo $gvar; ?>
Efter att ha anropat funktionen getGlobal() kan variabeln $gvar nås från vilken del av programmet som helst.
Variabel omfattningär det sammanhang där variabeln definieras. De flesta PHP-variabler har ett enda omfång. Detta enda omfattning (även kallat det globala omfattningen) täcker även inkluderade filer:
I det här exemplet kommer variabeln $a också att vara tillgänglig i det inkluderade skriptet - main.inc .
Lokala variabler
En anpassad funktionsdefinition anger lokal omfattning för en variabel, dvs. Varje variabel som används i en funktion är som standard begränsad till funktionens lokala omfattning (endast tillgänglig inom funktionen där den är definierad). Hur det fungerar: För att separera variabler som används i allmän kod från variabler som används i funktioner, tillhandahåller PHP separat lagring för variabler inom varje funktion. Denna uppdelning av lagringsutrymme innebär att scope, det vill säga området där värdet på en variabel är tillgängligt, är funktionens lokala lagring.
Exemplet nedan visar tydligt att en variabel som deklareras utanför en funktion inte ändras inuti funktionen. Även om du inte bör försöka förstå hur funktionen fungerar, är det viktigaste att den har sin egen unika uppsättning variabler:
30 ?>
Som ett resultat av att köra detta fragment kommer följande att visas: 30.
Inuti funktionen birth() är variabeln $age satt till 1, men detta är inte samma variabel som definierades i det globala omfånget. Därför, när värdet på variabeln $age skrivs ut, skrivs det ursprungliga värdet av 30. Det är värt att notera att lokala variabler skapas när funktionen anropas och tas bort efter att funktionen är klar.
Om du faktiskt vill läsa eller ändra värdet på en global variabel (som variabler som används i det globala omfånget kallas) snarare än en lokal inom funktionen birth() måste den deklareras som global inom funktionsdefinitionen.
Anteckningen: Den adaptiva versionen av webbplatsen aktiveras, som automatiskt anpassar sig till din webbläsares lilla storlek och döljer vissa detaljer om webbplatsen för att underlätta läsningen. Njut av att titta!
Hej kära bloggläsare Webbplats på! I vi lärde oss att det finns en funktion i PHP, vi lärde oss hur vi skapar våra egna funktioner, skickar argument till dem och kallar dem för exekvering. För att fortsätta ämnet funktioner i PHP, är det nödvändigt att betona följande saker:
- Inuti funktionen kan du använda vilken PHP-kod som helst (cykler, villkor, alla operationer), inklusive andra funktioner (både inbyggda och anpassade);
- Funktionsnamnet måste börja med en latinsk bokstav eller ett understreck, följt av ett valfritt antal latinska bokstäver, siffror eller understreck;
- Alla funktioner har globalt omfång, vilket innebär att vilken funktion som helst kan anropas var som helst, även om den funktionen är definierad i en annan;
- PHP stöder inte funktionsöverbelastning, det finns heller ingen möjlighet att omdefiniera (ändra, lägga till) eller ta bort en skapad funktion;
- Funktioner behöver inte definieras innan de används. Det vill säga, om du först anropar en funktion, och först sedan beskriver den i koden nedan, kommer detta inte att påverka prestandan och kommer inte att orsaka fel.
Villkorliga funktioner
Vi kan skapa (definiera, beskriva) en funktion beroende på villkoret. Till exempel:
//kallade funktionen sayHi, den kan anropas var som helst
/*sägGoodbye-funktionen kan inte anropas här, eftersom vi ännu inte har kontrollerat villkoret och inte har gått in i if-konstruktionen*/ if($apply)( function sayGoodbye())( echo "Hejdå alla!
";
}
}
/*nu kan vi säga hej då*/
";
}
Resultat:
Och ta en titt på detta exempel:
/*och detta är vad som kommer att hända om du ringer säg hej då*/ Säg hejdå(); if($apply)( function sayGoodbye())( echo "Hejdå alla!
"; ) ) function sayHi())( echo "Hej alla!
";
}
Resultat:
Faktum är att så mycket som jag har arbetat har jag aldrig sett något liknande någonstans, men du måste tänka på alla möjligheter med språket.
Kapslade funktioner
En kapslad funktion är en funktion som deklareras inuti en annan funktion. Exempel:
/*Du kan inte anropa sayGoodbye här, eftersom det bara visas efter att du har anropat sayHi-funktionen*/ Säg hej(); /*ring funktionen säg hej, den kan anropas var som helst*/
/*Nu kan vi säga hej då*/ Säg hejdå(); function sayHi())( echo "Hej alla!
"; function sayGoodbye())( echo "Hejdå alla!
";
}
}
Återigen, på den första genomgången, markerar PHP-tolkaren sig själv att den har hittat en beskrivning av sayHi-funktionen, men går inte in i sin kropp, den ser bara namnet, och eftersom tolken inte går in i sayHi-kroppen, då har den ingen aning om vad vi definierar i en annan funktion – säg adjö.
Sedan börjar koden exekvera, vi anropar sayHi, PHP-tolkaren måste gå in i kroppen på sayHi-funktionen för att köra den och där hittar den av misstag beskrivningen av en annan funktion - sayGoodbye, varefter sayGoodbye kan anropas var som helst, lika många gånger som du vill.
Men det är värt att uppmärksamma en mycket subtil punkt i situationen ovan: sayHi-funktionen blir engångsfunktion, för om vi kallar den igen kommer PHP igen att stöta på definitionen av sayGoodbye-funktionen, och i PHP kan du inte göra det. detta - du kan inte åsidosätta funktioner. Jag skrev om detta och hur man hanterar det i en tidigare artikel.
I PHP används de ovan beskrivna teknikerna mycket sällan, de kan ses oftare, till exempel i JavaScript.
Variabelt omfattning
Det finns exakt två omfattningar i PHP: global Och lokal. Varje programmeringsspråk strukturerar olika omfattningar. Till exempel, i C++, har även loopar sin egen (lokala) omfattning. I PHP är detta förresten en global räckvidd. Men idag pratar vi om funktioner.
Funktioner i PHP har sin egen interna scope (lokal), det vill säga alla variabler inuti en funktion är synliga endast inom just denna funktion.
Så återigen: allt utanför funktionerna är det globala omfånget, allt inom funktionerna är det lokala omfånget. Exempel:
Kära experter, uppmärksamhet, fråga! Vad kommer den sista instruktionen ut? echo $namn; ?
Som du själv såg hade vi 2 variabler $namn, en inom funktionen (lokalt omfång), den andra bara i koden (globalt omfång), den sista tilldelningen till en variabel $namn var $name = "Rud Sergey"; Men eftersom det var inne i funktionen stannade det där. I den globala omfattningen var det sista uppdraget $name = "Andrey"; vilket är vad vi faktiskt ser som ett resultat.
Det vill säga två identiska variabler, men i olika omfattning skär de sig inte och påverkar inte varandra.
Låt mig illustrera omfattningen i figuren:
Under den första genomgången skannar tolken kort det globala omfånget, kommer ihåg vilka variabler och funktioner som finns, men exekverar inte koden.
Åtkomst till globala variabler från lokalt omfång
Men vad händer om vi fortfarande behöver komma åt samma $name-variabel från det globala omfånget från en funktion, och inte bara komma åt den, utan ändra den? Det finns 3 huvudalternativ för detta. Den första använder ett nyckelord global:
"; global $namn; /*från och med nu menar vi den globala variabeln $name*/$name = "Rud Sergey"; ) $name = "Andrey"; säg Hej($namn); echo $namn; //?
Resultat:
Men den här metoden har en nackdel, eftersom vi fick tillgång till den globala variabeln $namn vi förlorade (skrev över) en lokal variabel $namn.
Andra sättetär att använda PHP superglobal array. PHP själv placerar automatiskt varje variabel som vi skapade i det globala omfånget i denna array. Exempel:
$name = "Andrey"; //Samma som$GLOBALS["name"] = "Andrey";
Därav:
"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "Andrey"; säg Hej($name); echo $name; // ?
Resultatet är detsamma som att använda nyckelordet global:
Bara den här gången skrev vi inte om den lokala variabeln, det vill säga variabeln $namn inuti förblir funktionen densamma och är lika "Andrey", men inte "Rud Sergey".
Skicka argument genom referens
Tredje vägen– detta är överföringen av adress ( länkar) av en variabel, inte dess värde. Länkar i PHP är inte särskilt framgångsrika, till skillnad från andra programmeringsspråk. Jag kommer dock att berätta för dig det enda korrekta alternativet för att skicka ett argument med hänvisning till en funktion, som normalt stöds i PHP 5.3 och högre. Det finns andra sätt att arbeta med länkar, men de fungerade i PHP 5.2 och lägre, som ett resultat beslutade PHP-utvecklarna själva att överge dem, så vi kommer inte att prata om dem.
Så, KORREKT överföring av ett argument genom referens i PHP 5.3 och högre görs enligt följande:
Funktion sayHi(& $name)(
I själva funktionsbeskrivningen har vi lagt till en et-tecken (&) ikon - denna ikon betyder att vi inte accepterar värdet på variabeln, utan en länk (adress) till detta värde i minnet. Referenser i PHP låter dig skapa två variabler som pekar på samma värde. Det betyder att när en av dessa variabler ändras ändras båda, eftersom de refererar till samma värde i minnet.
Och i slutändan har vi:
//acceptera inte ett värde, utan en referens till värdet echo "Hej, ".$namn."!
"; $name = "Rud Sergey"; ) $name = "Andrey"; säg Hej($namn); echo $namn; // ?
Resultat:
Statiska variabler
Föreställ dig följande situation: vi måste räkna hur många gånger vi sa hej totalt. Här är vad vi försöker göra:
"; $c++; // öka räknaren med 1
Resultat:
Variabel $c kommer inte ihåg dess betydelse, den skapas på nytt varje gång. Vi måste göra vår lokala variabel $c kom ihåg dess värde efter att ha kört funktionen, för detta använder de ett nyckelord statisk:
// räknare, gjort statisk echo "Hej, ".$namn."!
"; $c++; // öka räknaren med 1 echo "Har precis sagt hej". $c . " en gång.
"; ) sayHi("Rud Sergey"); sayHi("Andrey"); sayHi("Dmitry");
Resultat:
Returnerande värden
Funktioner har en så bekväm sak som att returnera värden. Det är när en funktion, istället för att skriva ut något på skärmen, lägger allt i en variabel och ger den variabeln till oss. Och vi har redan bestämt oss för vad vi ska göra med det. Låt oss till exempel ta den här funktionen, den kvadrerar ett tal:
Resultat:
Låt oss göra det så att istället för att visa det på skärmen, returnerar det exekveringsresultatet. För att göra detta, använd nyckelordet return:
Resultat:
Nu kan vi använda detta på olika sätt:
//matar ut resultatet eka"
"; $num = getSquare(5); echo $num;
Resultat:
Observera att nyckelordet lämna tillbaka returnerar inte bara ett värde, utan avbryter helt funktionen, det vill säga all kod som finns under nyckelordet lämna tillbaka kommer aldrig att uppfyllas. Med andra ord, retur för funktioner fungerar också som ha sönder för loopar:
echo "PHP når mig aldrig:(";) echo getSquare(5); //matar ut resultatet eka"
"; $num = getSquare(5); // tilldelade resultatet till en variabel eko $num; // visa variabeln på skärmen
Resultat:
Det är lämna tillbaka– detta är också en utgång från funktionen. Den kan användas utan returvärde, bara för utmatningens skull.
Rekursiv funktion
En rekursiv funktion är en funktion som kallar sig själv. Rekursion används inte ofta och anses vara en resurskrävande (långsam) operation. Men det händer att användning av rekursion är det mest uppenbara och enkla alternativet. Exempel:
"; if($nummer< 20){ // så att inte rekursionen blir oändlig countPlease(++$nummer); // countPlease-funktionen kallade sig själv) ) countPlease(1);
Resultat:
Om du vet hur man gör utan rekursion, är det bättre att göra det.
Starkt skrivande i PHP (typförfining)
PHP tar små steg mot stark skrivning, så vi kan i förväg specificera vilken typ en funktion ska ta (det kallas typtips):
Resultat:
Fattigt fatalt fel: Argument 1 som skickas till countPlease() måste vara en array, heltal givet, anropad /home/index.php på rad 7 och definierad i /home/index.php på rad 3
Felet talar om för oss att funktionen förväntar sig att ta emot en array, men istället skickar vi ett nummer till den. Tyvärr kan vi för närvarande bara ange typen för (array), och med PHP 5.4 har vi också lagt till ett sådant alternativ som anropsbar:
Ringbar kontrollerar om det godkända värdet kan anropas som en funktion. Anropsbar kan antingen vara namnet på en funktion specificerad av en strängvariabel, eller ett objekt och namnet på metoden som anropas. Men vi kommer att prata om objekt och metoder senare (detta är en del av objektorienterad programmering), men du är redan bekant med funktioner. Jag kan inte visa dig resultatet av arbetet, eftersom jag för närvarande har PHP 5.3, men det skulle vara:
Kallas getEcho-funktionen
Använda argument med variabel längd
Och slutligen, ytterligare en mycket sällan använd nyans. Föreställ dig en situation: vi skickar argument till en funktion, även om vi inte beskrev dem i funktionen, till exempel:
Resultat:
Som du kan se finns det inga fel, men våra godkända argument används inte någonstans. Men detta betyder inte att de är borta - de skickades fortfarande in i funktionen och vi kan använda dem; det finns inbyggda PHP-funktioner för detta:
func_num_args()- Returnerar antalet argument som skickats till funktionen
func_get_arg(sekvensnummer)- Returnerar ett element från en lista med argument
func_get_args()- Returnerar en array som innehåller funktionsargumenten
"; echo func_get_arg(0); ) $age = 22; getEcho("Rud Sergey", $age);
Resultat:
Slutsats
Dagens artikel är den sista på ämnet funktioner i PHP. Nu kan du vara säker på att dina kunskaper är fullständiga om detta ämne och med säkerhet kan använda funktionerna för dina behov.
Om någon har en önskan om att bli bättre på det, men inte har en aning om hur man gör det, är det bästa sättet att skriva färdiga (inbyggda) PHP-funktioner, till exempel kan du skriva din egen count() funktion eller någon annan.
Tack alla för er uppmärksamhet och vi ses igen! Om något är oklart, ställ gärna dina frågor i kommentarerna!
Omfattningen av en variabel är det sammanhang i vilket variabeln definieras. I de flesta fall har alla PHP-variabler bara ett omfång. Detta enda omfång täcker också inkluderade och nödvändiga filer. Till exempel:
$a = 1 ;
inkludera "b.inc" ;
?>
Här kommer variabeln $a att vara tillgänglig i det inkluderade b.inc-skriptet. Definitionen (kroppen) av en användardefinierad funktion anger dock det lokala omfånget för den funktionen. Varje variabel som används inom en funktion är som standard begränsad till funktionens lokala omfång. Till exempel:
$a = 1 ; /* globalt omfång */
Funktionstest()
{
echo $a ; /* referens till lokal scope-variabel */
}
Testa();
?>
Detta skript kommer inte att generera någon utdata eftersom echo-satsen pekar på en lokal version av variabeln $a och den har inte tilldelats ett värde inom det omfånget. Du kanske har märkt att detta skiljer sig lite från C genom att globala variabler i C är automatiskt tillgängliga för funktioner om de inte har skrivits över av en lokal definition. Detta kan orsaka vissa problem eftersom människor av misstag kan ändra den globala variabeln. I PHP, om en global variabel ska användas inom en funktion, måste den deklareras global inom funktionsdefinitionen.
Nyckelord global
Först ett användningsexempel global:
Exempel #1 Användning global
$a = 1 ;
$b = 2 ;
funktion Sum()
{
global $a, $b;
$b = $a + $b ;
}
Belopp();
eko $b ;
?>
Ovanstående skript kommer att matas ut 3 . När $a och $b väl har definierats som globala i en funktion, kommer alla referenser till någon av dessa variabler att peka på deras globala version. Det finns ingen gräns för antalet globala variabler som en funktion kan hantera.
Det andra sättet att komma åt globala scope-variabler är att använda en speciell PHP-definierad array, $GLOBALS . Det tidigare exemplet skulle kunna skrivas om så här:
$GLOBALS är en associativ array vars nyckel är namnet och värdet är innehållet i den globala variabeln. Observera att $GLOBALS existerar i alla omfång, detta beror på att $GLOBALS är superglobal. Nedan är ett exempel som visar superglobals förmåga:
Exempel #3 Superglobals och omfattning
funktion test_global()
{
// De flesta fördefinierade variabler är det inte
// "super" och vara tillgänglig i närområdet
// synlighet, funktioner kräver att "global" anges.
global $HTTP_POST_VARS ;
Echo $HTTP_POST_VARS["namn"];
// Superglobals finns i alla omfattningar
// synlighet och kräver inte att "global" anges.
// Superglobals är tillgängliga sedan PHP 4.1.0, och
// användningen av HTTP_POST_VARS är utfasad.
echo $_POST ["namn" ];
}
?>
Kommentar:
Användning av sökord global utanför funktionen är inte ett fel. Den kan användas i en fil som ingår i en funktion.
Använder statisk ( statisk) variabler
En annan viktig egenskap hos variabel omfattning är statisk variabel. En statisk variabel finns bara i det lokala omfånget för en funktion, men förlorar inte sitt värde när programkörning lämnar det omfånget. Tänk på följande exempel:
Exempel #4 Visar behovet av statiska variabler
funktionstest()
{
$a = 0 ;
echo $a ;
$a++;
}
?>
Den här funktionen är ganska värdelös eftersom varje gång den kallas ställer den $a till 0 och utgångar 0 . Ökningen av variabeln $a ++ spelar ingen roll här, eftersom variabeln $a försvinner när funktionen avslutas. För att skriva en användbar räknefunktion som inte förlorar det aktuella räknarvärdet, deklareras variabeln $a statisk:
Exempel #5 Exempel på användning av statiska variabler
funktionstest()
{
statisk $a = 0 ;
echo $a ;
$a++;
}
?>
Nu kommer $a att initieras endast vid det första funktionsanropet och varje funktionsanrop testa() kommer att skriva ut värdet på $a och öka det.
Statiska variabler gör det också möjligt att arbeta med rekursiva funktioner. En rekursiv funktion är en som kallar sig själv. När du skriver en rekursiv funktion måste du vara försiktig, eftersom det finns en möjlighet att göra rekursionen oändlig. Du måste se till att det finns ett adekvat sätt att avsluta rekursionen. Följande enkla funktion räknar upp till 10 rekursivt, med hjälp av den statiska variabeln $count för att avgöra när man ska sluta:
Kommentar:
Statiska variabler kan deklareras som visas i föregående exempel. Försök att tilldela värden till dessa variabler som är resultatet av uttryck kommer att orsaka ett bearbetningsfel.
Exempel #7 Deklarera statiska variabler
function foo ()(
statisk $int = 0 ; // höger
statisk $int = 1 + 2 ; // felaktigt (eftersom det är ett uttryck)
statisk $int = sqrt(121); // felaktigt (eftersom detta också är ett uttryck)$int++;
echo $int ;
}
?>
Kommentar:
Statiska deklarationer utvärderas under skriptkompilering.
Länkar med globala ( global) och statisk ( statisk) variabler
Zend Engine 1, som driver PHP 4, behandlar statiska och globala variabelmodifierare som referenser. Till exempel en verklig global variabel inbäddad i en funktions omfattning genom att ange nyckelordet global skapar i själva verket en referens till en global variabel. Detta kan leda till oväntat beteende, som visas i följande exempel:
funktion test_global_ref() (
global $obj ;
$obj = &ny stdklass ;
}
function test_global_noref() (
global $obj ;
$obj = ny stdklass ;
}
test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>
Resultatet av att köra detta exempel: get_instance_noref () (
statisk $obj ;
Eko "Statiskt objekt: ";
var_dump($obj);
if (!isset($obj )) (
// Tilldela ett objekt till en statisk variabel
$obj = ny stdklass ;
}
$obj -> egenskap++;
returnera $obj ;
}
$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n" ;
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>
Resultatet av att köra detta exempel:
Statiskt objekt: NULL
Statiskt objekt: NULL
Statiskt objekt: NULL
Statiskt objekt: object(stdClass)(1) (
["property"]=>
int(1)
}
Det här exemplet visar att när du tilldelar en referens till en statisk variabel så gör den inte det minnesvärd när du anropar funktionen &get_instance_ref() en andra gång.
För att skapa en fullfjädrad webbplats med ett brett utbud av funktioner behöver du veta mycket. PHP kan dock ge en webbplats verklig unikhet. Den globala variabeln används inte ofta i detta programmeringsspråk, men ibland är det väldigt användbart att veta hur det fungerar.
I den här artikeln kommer vi att studera exakt vad en global variabel är och hur den fungerar.
Global variabel: omfattning
Kontexten inom vilken en variabel definieras kallas dess omfattning. Vanligtvis har variabler bara ett omfång. När globala variabler i PHP laddas från andra filer kan de krävas eller inkluderas. De är som standard begränsade till funktionens lokala omfattning. Hur kan du göra en variabel synlig för filer utanför dess gränser och även kunna använda den? Det är precis därför PHP tillhandahåller en global variabel. Nyckelordet här är "global". Hur deklarerar man en global variabel i PHP? För att uppnå detta mål måste ordet "global" användas. Den måste placeras omedelbart före variabeln som du vill göra global. Det ser ut ungefär så här: global "variabel". Efter att ha implementerat instruktioner av detta slag kommer absolut alla filer att kunna arbeta med data.
Om det finns referenser till denna variabel någonstans kommer programmet att uppmärksamma den globala versionen. Varför används så konstiga formuleringar? Saken är den att samtidigt kan även lokala versioner finnas. Men de kommer att vara mer tillgängliga uteslutande i de filer där de deklareras. För resten kommer globala PHP-klassvariabler att gälla. Här måste du agera mycket noggrant och noggrant. För att undvika tvivel, låt oss ge ett enkelt exempel på hur de kan se ut: globala a. Om en fil har åtkomst till flera variabler kan detta orsaka en konflikt. Men det är omöjligt att säga säkert här om en global eller lokal variabel kommer att läsas, eller om ett fel kommer att inträffa. Om du skriver det inuti en funktion bör inga problem uppstå. Att använda en variabel utanför en funktions gränser kommer att vara problematiskt. Därför måste du mycket noggrant övervaka kodens struktur och se till att det inte finns några förutsättningar för en konflikt någonstans.
Globala variabler: Another Notation
Finns det andra sätt att ställa in globala variabler? Ja, och inte ensam. Låt oss först titta på $GLOBALS. Det är en associativ array där nyckeln är namnet. Innehållet i den globala variabeln används som värde. Det är värt att notera att efter deklaration finns denna array i alla omfattningar. Detta ger anledning att betrakta det som superglobalt. Det ser ut så här: $GLOBALS ['Variabel'].
Superglobals
I alla programmeringsspråk finns det namn som är reserverade för enskilda funktioner. Det är helt enkelt inte möjligt att skapa globala variabler med samma namn i PHP. Detta programmeringsspråk har sina egna egenskaper. Till exempel är det särskilt viktigt att fördefinierade variabler inte har prefixet "super". Det betyder att de inte är tillgängliga på alla platser. Hur kan denna situation korrigeras? För att göra en fördefinierad variabel tillgänglig på något lokalt nätverk måste du deklarera den så här: global "variabel". Detta har redan nämnts tidigare. Detta är dock inte helt sant. Låt oss titta på ett verkligt exempel:
Global $HTTP_POST_VARS; echo $HTTP_POST_VARS ['namn'].
Känner du skillnaden? Det är värt att komma ihåg att i PHP måste en global variabel användas inom en funktion. Den kan också finnas i en fil som ingår i den.
Säkerhet och länkar
Som du själv kan se är det inget problem att skapa en global variabel i PHP. Men finns det några specifika länkar? När du använder globala variabler är vissa oväntade beteenden möjligt. Men innan du studerar denna fråga mer i detalj är det nödvändigt att vända sig till bakgrunden. Direktivet register_globals ändrades från aktiverat till inaktiverat som standard i version 4.2. För många användare är detta helt oviktigt, och förgäves, eftersom säkerheten för produkten som utvecklas beror direkt på det. Om du behöver göra en global variabel kommer inte PHP-direktivet att direkt påverka denna inställning. Däremot kan felaktig användning bli en säkerhetsrisk. Så, till exempel, om register_globals är i det aktiverade tillståndet, kommer olika nödvändiga variabler att initieras innan koden exekveras. Därför bestämde de sig för att stänga av den. Varför är en global variabel skyldig mycket av sitt tillstånd till ett givet direktiv? Problemet är att när det var aktiverat kunde utvecklarna inte alltid svara på frågan om var det kom ifrån, men å andra sidan underlättade detta avsevärt processen att skriva kod. Samtidigt skapade en sådan organisation ett visst hot mot säkerheten. För att undvika datablandning och fel har direktivet inaktiverats. Låt oss nu titta på ett exempel på osäker kod. Vi kommer också att titta på hur du kan upptäcka fall då deklarationen av en global PHP-variabel åtföljs av ett försök att ersätta information. Detta krävs för att skapa stabila arbetssidor som inte kan hackas av den första användaren som stöter på dem.
Farliga koder
Låt oss ställa in variabeln till true för de användare som är auktoriserade:
If (authenticate_user()) ($authoriza=true;) if ($authorize) (inkludera "/highly/sensitive/data.php";). En variabel i detta tillstånd kan ställas in automatiskt. Med tanke på att data helt enkelt kan ersättas och källan till dess ursprung inte är fastställd, kan praktiskt taget alla användare passera en sådan kontroll och utge sig för vem som helst. En angripare kan, om så önskas, störa logiken i hela skriptet. Om du ändrar värdet på direktivet kommer koden att fungera korrekt. Det är precis vad vi behöver göra. Att initiera variabler är dock inte bara en bra praxis bland programmerare, det garanterar också stabiliteten i skriptet.
Pålitligt alternativ
För att uppnå detta mål kan du försöka inaktivera direktivet, eller skriva mer komplex kod, till exempel så här: if (isset($_SESSION ['användarnamn'])) (eko "Hej" ($_SESSION ['användarnamn') ])”;) else (eko “Hej gäst”; eko “Välkommen!”;). I det här fallet blir det svårt att göra ett byte. Det är dock möjligt. För att göra detta måste du i förväg ta hand om tillgången på snabba svarsverktyg. Om du behöver inkludera globala variabler i PHP kan du använda följande verktyg: om du vet exakt inom vilket område värdet kommer att tas emot, kan du skriva det på ett sådant sätt att skriptet kontrollerar detta faktum genom jämförelse. Detta kan naturligtvis inte heller garantera ett 100-procentigt skydd mot värdesubstitution. Att gå igenom de möjliga alternativen kommer dock att komplicera operationen avsevärt.
Hur upptäcker man ett spoofingförsök?
Låt oss nu kontrollera om du förstod allt som tidigare skrivits korrekt. Du måste själv deklarera globala variabler i en funktion. Det här är en sorts läxa. Först, här är koden:
Låt oss ge några förklaringar. Variabeln C_COOKIE är hämtad från en pålitlig källa. För att säkerställa att dess resultat blir som förväntat kontrolleras variabelns värde. Om problem uppstår får administratören ett meddelande. Om inget händer kommer inga åtgärder att vidtas.
