Biztos van otthon szekrényed vagy komódod. Használatuk elve egyszerű: olyan dolgokat teszünk oda, amelyekre jelenleg nincs szükségünk, de egy idő után szükségünk lehet.

A változók pontosan ugyanúgy vannak elrendezve. Értéket rakhatsz beléjük, és tárolhatod ott, amíg szükséged van rá.

Változók létrehozása

Egy ilyen változóba értéket adhatsz:

A fenti kódban létrehoztunk egy $name változót és beleírtuk az Iván értéket, majd létrehoztunk egy $age változót és 20 értéket rendeltünk hozzá.

A "változó" név azt jelenti, hogy értéke változhat a szkript végrehajtása során:

Egyes nyelveken egy változót először „deklarálni kell”, majd használni kell. BAN BEN PHP deklarációk nem - a változó abban a pillanatban jön létre, amikor értéket adsz bele.
A PHP programozók azonban gyakran azt mondják, hogy „változót deklarál” a „változó létrehozása” helyett.

Illetve a „berakás” helyett változó érték" gyakran azt mondják, hogy "értéket rendel."
Az ok egyszerű - a = szimbólumot, amelynek köszönhetően értéket tárolunk egy változóban, „hozzárendelési operátornak” nevezik. Innen ered a „megfelelő” kifejezés.

Változó elnevezési szabályok

1. A változó neve $ szimbólummal kezdődik.

2. A második karakter lehet betű vagy aláhúzás _

A változónevek megkülönböztetik a kis- és nagybetűket. A $name és a $Name különböző változók.

Változó értékének megjelenítése a képernyőn

Megjeleníthet egy változót az általunk már ismert echo paranccsal:

Az echo parancs lehetővé teszi több érték megjelenítését egyszerre:

Figyeljük meg, hogy 2 értéket adtunk át a visszhangnak, vesszővel elválasztva. Így annyi értéket tudunk átadni, amennyit csak akarunk. A következő két példa ugyanazt az eredményt adja:

Van egy rövidített szintaxis is a változók megjelenítésére a PHP-ben. Ahelyett

A PHP 5.4 előtt a gyorsírási szintaxis csak akkor működött, ha engedélyezve volt a beállításokban PHP direktívák short_open_tag, amely lehetővé teszi egy rövidített nyitócímke használatát is

Változó értékének ellenőrzése

Az echo parancs nem mindig alkalmas egy változó aktuális értékének ellenőrzésére. Például, ha megpróbálja megjeleníteni az üres "" karakterláncot, akkor semmi sem fog megjelenni a képernyőn. És nem világos, hogy mi az oka - üres változó vagy törött kód.

Ezért egy változó értékének ellenőrzéséhez a var_dump() függvényt használjuk:

A szkript végrehajtásának eredménye:

String(5) "Vasya" string(0) ""

Mint látható, a PHP nem csak a változó tartalmát jelenítette meg, hanem a karakterek számát, sőt a változó típusát (string) is. A következő leckékben részletesen megvizsgáljuk az adattípusokat.

Változók eltávolítása

Egy meglévő változót az unset() függvénnyel távolíthat el:

Most itt az ideje egy kicsit gyakorolni.

Ne feledje, szinte minden PHP-probléma több megoldást is tartalmazhat. Ezért, ha az Ön megoldásai eltérnek az ezen az oldalon leírtaktól, az egyáltalán nem jelenti azt, hogy valamit rosszul csinált.

Írj egy szkriptet, amely:
1. Változókat hoz létre a cím és a tartalom nevekkel és néhány értékkel.
2. Megjeleníti a cím változó értékét a h1 címkén belül, és a tartalom változó értékét a div címkén belül.

Megoldás megjelenítése

", $title, ""; visszhang"

"; ?>

Még egyszer szeretném felhívni a figyelmet arra, hogy nem ez a döntés az egyetlen helyes. Például a következő kód ugyanazt az eredményt adja:

Ez a lecke a tárgykört fedi le PHP változók. Elmagyarázza a különbséget a lokális és a globális hatókör között, bemutatja, hogyan lehet elérni a globális változókat 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, míg a globális hatókörű változókat nevezzük helyi láthatóság - helyi.

Í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 használja kulcsszó global, hogy a $globalName változót globálisnak nyilvánítsa. 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 meghatározott globális tömbökkel rendelkezik, amelyek tartalmazzák különféle információk. 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.

Itt található az itt elérhető szuperglobálok listája PHP verziók 5.3:

• $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.

Például a $_GET segítségével lekérheti a szkript kérés URL-karakterláncába zárt változók értékeit, és megjelenítheti azokat az oldalon:

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, a statikus kulcsszót kell használnia a változó neve előtt, és feltétlenül be kell állítania kezdő érték. 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étrehoztunk 1. Már létrehoztunk 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. Már létrehoztunk 3-at.

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.

A Windows környezeti változói különféle információkat tartalmaznak a rendszerbeállításokról és a felhasználói környezetről. Különbséget teszünk felhasználói, rendszer- és folyamatkörnyezeti változók között.

A környezeti változók tartalmának megtekintéséhez a legegyszerűbb módja a Windows rendszerben a Rendszertulajdonságok ( sysdm.cpl) -> Speciális -> Környezeti változók. Amint látható, a megnyíló ablakban két rész található: a felső a felhasználó környezeti változóit, az alsó pedig a rendszerváltozókat tartalmazza.

Ezenkívül a környezeti változókat a rendszerleíró adatbázis tárolja. A felhasználói változókat a . Rendszer - be HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment.

Az összes környezeti változó értékét megjelenítheti a parancssorban Windows vonal. A parancs egyszerű:

A parancs felsorolja a környezeti változókat és azok értékeit.

A PowerShellben a parancs segítségével megjelenítheti az összes környezeti változót:

Ha csak egy változó értékét kell megjeleníteni, akkor az echo parancsot kell használni, és a változó nevét százalékjelek közé kell zárni. Például,

Echo %systemroot%

set > c:\tmp\env_var.txt

Egy adott folyamathoz tartozó környezeti változókat a free segítségével lehet beszerezni Process Explorer segédprogramok(a Sysinternalstól). Csak nyissa meg a folyamat tulajdonságait, és lépjen a lapra Környezet.

13 évvel ezelőtt

Egy kis apróság, amire figyelni kell:

Ha kikapcsolja a RegisterGlobals szolgáltatást és a kapcsolódó szolgáltatást, majd a get_defined_vars() parancsot, a következőhöz hasonlót láthat:

Sor
[ GLOBALS ] => Tömb
[ GLOBALS ] => Tömb
*REKURZIÓ*
[ _POST ] => Array()
[ _GET ] => Array()
[ _COOKIE ] => Array()
[ _FILES ] => Array()
)

[ _POST ] => Array()
[ _GET ] => Array()
[ _COOKIE ] => Array()
[ _FILES ] => Array()

)
?>

Figyeld meg, hogy a $_SERVER nincs ott. Úgy tűnik, hogy a php csak akkor tölti be a szuperglobális $_SERVER-t, ha valahol használják. Ezt teheted:

nyomtatni"

" . htmlspecialchars(print_r(get_defined_vars(), true))."

" ;
nyomtatni"

" . htmlspecialchars (print_r ($_SERVER , true )) . "

" ;
?>

Ezután mindkét listában megjelenik a $_SERVER. Azt hiszem, ez nem igazán baj, mert így sem fog történni semmi rossz, de ettől függetlenül érdekes érdekesség.

6 évvel ezelőtt

Mivel a get_defined_vars() csak azon a ponton kapja meg a változókat, ahol a függvényt meghívjuk, van egy egyszerű módszer a változók definiálására az aktuális hatókörön belül.

// A php szkript legteteje
$vars = get_defined_vars();

// Most csináld a dolgod
$foo = "foo" ;
$bar = "sáv" ;

// Az aktuális hatókörben meghatározott összes változó lekérése
$vars = array_diff(get_defined_vars(), $vars);

visszhang"

"
;
print_r($vars); 
visszhang"

" ;
?>

15 évvel ezelőtt

Itt van egy funkció, amely hibakeresési jelentést hoz létre megjelenítéshez vagy e-mailhez
a get_defined_vars használatával. Kiválóan alkalmas részletes pillanatkép készítéséhez anélkül
felhasználói bemenetre támaszkodva.

function generateDebugReport ($method, $defined_vars, $email = "undefined" )(
// Hibakeresési jelentés létrehozásának funkciója megjelenítésre vagy e-mailben.
// Használat: generateDebugReport(method,get_defined_vars(),email);
// Ahol a metódus "böngésző" vagy "e-mail".

// Hozzon létre egy figyelmen kívül hagyó listát a "get_defined_vars" által visszaadott kulcsokhoz.
// Például a HTTP_POST_VARS, HTTP_GET_VARS és mások azok
// redundáns (ugyanaz, mint _POST, _GET)
// Tartalmazza azokat a varokat is, amelyeket biztonsági okokból figyelmen kívül kell hagyni – pl. PHPSESSID.
$ignorelist =array("HTTP_POST_VARS" , "HTTP_GET_VARS" ,
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
"_ENV" , "PHPSESSID" , "SESS_DBUSER" ,
"SESS_DBPASS" , "HTTP_COOKIE" );

$időbélyeg = dátum ("h/n/é h:h:s" );
$message = "A hibakeresési jelentés létrehozva $timestamp \n" ;

// Az utolsó SQL hiba lekérése a jó méréshez, ahol a $link az erőforrás azonosítója
// a mysql_connecthez. Írjon megjegyzést vagy módosítsa adatbázisát vagy absztrakciós beállításait.
globális $link ;
$sql_error = mysql_error($link);
if($sql_error )(
$message .= "\nMysql üzenetek:\n" . mysql_error($link);
}
// Végezze el a MySQL-t

// Használhat itt egy rekurzív függvényt. Érted az ötletet ;-)
foreach($defined_vars mint $key => $val )(
if(is_array ($val ) && ! in_array ($kulcs , $ignorelist ) && count ($val ) > 0 )(
$message .= "\n $kulcstömb (kulcs=érték):\n" ;
foreach($val mint $alkulcs => $subval )(
if(! in_array ($alkulcs , $ignorelist ) && ! is_array ($subval ))(
$üzenet .= $alkulcs . " = " . $subval. "\n" ;
}
elseif(! in_array ($alkulcs , $ignorelist ) && is_array ($subval ))(
foreach($subval mint $alalkulcs => $subsubval )(
if(! in_array ($alkulcs, $ignorelist))(
$üzenet .= $alalkulcs . " = " . $subsubval . "\n" ;
}
}
}
}
}
elseif(! is_array ($val ) && ! in_array ($kulcs , $ignorelist ) && $val )(
$message .= "\nVáltozó" . $kulcs . " = " . $val. "\n" ;
}
}

If($method == "böngésző" )(
echo nl2br($üzenet);
}
elseif($method == "e-mail" )(
if($email == "undefined" )(
$email = $_SERVER [ "SZERVER_ADMIN" ];
}

$mresult = mail ($email , "Hibakeresési jelentés a következőhöz: " . $_ENV [ "HOSTNAME" ]. "" , $üzenet );
if($meredmény == 1 )(
visszhang "A hibakeresési jelentés sikeresen elküldve.\n";
}
más(
visszhang "Nem sikerült elküldeni a hibakeresési jelentést.\n";
}
}
}
?>

17 évvel ezelőtt

Egyszerű rutin a get_defined_vars objektum XML-lé konvertálására.

függvény obj2xml ($v, $indent = "" ) (
while (lista($kulcs , $val ) = mindegyik ($v )) (
if ($key == "__attr" ) folytatódik;
// Ellenőrizze a __attr
if (is_object ($val -> __attr )) (
while (lista($kulcs2 , $érték2 ) = mindegyik ($val -> __attr )) (
$attr .= " $key2 =\" $val2 \"" ;
}
}
else $attr = "" ;
if (is_array ($val ) || is_object ($val )) (
print(" $indent< $key$attr >\n" );
obj2xml($val, $indent. "");
print(" $indent\n" );
}
else print(" $indent< $key$attr >$val\n" );
}
}

//Példaobjektum
$x -> név -> első = "János" ;
$x -> név -> utolsó = "Smith" ;
$x -> arr [ "Fruit" ] = "Bannana" ;
$x -> arr [ "Veg" ] = "Sárgarépa" ;
$y -> ügyfél = $x ;
$y -> ügyfél -> __attr -> id = "176C4" ;

$z = get_defined_vars();
obj2xml($z["y"]);
?>
ki fogja adni:


János
Kovács


Banán
Sárgarépa

11 évvel ezelőtt

Megjegyzés: a get_defined_vars() nem ad vissza változó hivatkozások halmazát (ahogy reméltem). Például:

// definiál egy változót
$my_var = "foo" ;

// lekérjük a definiált változók listáját
$defined_vars = get_defined_vars();

// most próbálja meg megváltoztatni az értéket a visszaadott tömbön keresztül
$defined_vars [ "my_var" ] = "sáv" ;

echo $my_var , "\n" ;

?>

"foo"-t (az eredeti értéket) adja ki. Jó lenne, ha a get_defined_vars()-nak lenne egy opcionális argumentuma a hivatkozások létrehozására, de úgy gondolom, hogy ez egy meglehetősen speciális kérés. Megteheti saját maga (kevésbé kényelmesen) valami ilyesmivel:

$defined_vars = array();
$var_nevek = array_keys(get_defined_vars());

foreach ($var_names mint $var_name)
{
$defined_vars [ $var_name ] =& $ $var_name ;
}

?>

1 évvel ezelőtt

Korábban írtam itt arról, hogy "ez" a get_defined_vars-ban van.

Kiderült, hogy nincs mindig ott, de bizonyos esetekben megmagyarázhatatlanul megjelenik.

Php -r "
osztály teszt(
nyilvános függvény a() (var_dump(array_keys(get_defined_vars()));$a = 123;)
public function b() (var_dump(array_keys(get_defined_vars()));$this;)
}
$t = new Teszt();
$t->a();
$t->b();
"

Sor()
array("ez")

Ez nem történik meg a PHP 7.2-ben, de megtörténik a PHP 5.6-ban.

1 évvel ezelőtt

Néhány megjegyzés rámutat arra, hogy ez a függvény nem ad vissza hivatkozásokat. Azonban neveket ad vissza, és a nevek "hivatkozások".

Nem ajánlom az itt található javaslatokat, amelyek hivatkozásokká konvertálják.

Nyilvános függvény x($a, $b, $c) (
foreach(array_keys(get_defined_vars()) $kulcsként)
if($kulcs !== "ez")
$this->y($($kulcs));
}

Nyilvános függvény y(&$input) (
$bemenet++;
}

A $() helyett használhatja a $$-t is.

Csináltam néhány fura dolgot az időmben, hogy rendkívül általános kódot készítsek, de soha nem kellett a fentihez hasonlót csinálnom. Lehet, hogy nem is működik (de kellene, mert nem különbözik az $a[$key]-től).

Azt is megteheti, hogy $$key++, de még soha nem láttam olyan kódot, ami nem volt borzasztóan rossz (dinamikus használata, ahol a dinamika nem előnyös).

Ha valami ilyesmit csinál, akkor vizsgálja meg jobban.