változók a php-ban egyfajta információs tároló, amely tartalmazhat Különféle típusok adatok (szöveg, számok, tömbök és így tovább). Általában a változók lehetővé teszik a bennük megadott információk létrehozását, tárolását, módosítását, majd gyors elérését.
Hogyan nevezzük el a változókat:
$var
$változó
1945 dollár
$_változó
Hogyan ne nevezzünk el változókat:
$1 - csak egy számjegyből áll
$1var – a változónevet nem lehet számmal kezdeni
$/var - további karakterekből csak aláhúzás megengedett _
$változó – a cirill betűt a php dokumentáció engedélyezi, de nem ajánlott
$var iable – szóközök nem használhatók
Minden változóhoz hozzá van rendelve egy érték. Az előjel az érték hozzárendelésére szolgál. =
(egyenlő). A szkript feldolgozása során egy változó értéke a különböző feltételektől függően többször változhat.
$város = "Moszkva"; // a $city változóhoz a karakterlánc (idézőjelben) Moszkva értéket rendeltünk
év $ = 1147; // és a $year változóhoz 1147 számértéket rendeltünk
?>
$név = "Sándor";
$Name = "Alex";
echo "$name, $Name"; // kiírja: "Alexander, Alexey"
?>
// Így állítjuk be a változók értékeit
$név1 = "Alex";
$name2 = "Sándor";
// Változók megjelenítése
echo $név2; // Kimenet: Alexander
echo "név1 a $név1"; // name1 Alexey
// Használata egyetlen idézőjel Kimenet
// változó neve, nem érték
echo "név1 a $név1"; // kimenet: név1 a $név1
// csak a változók értékeit jelenítheti meg
echo $név1; // Alekszej
echo $név1,$név2; // Alekszej Sándor
echo $name1." ".$name2; // Alekszej Sándor
echo "$név1, $név2"; // Alekszej, Sándor
visszhang<<
több sor $változó helyettesítéssel.
VÉGE;
-$a(negáció) Változtasd meg $a jelét.
$a + $b(összeadás) $a és $b összege.
$a - $b(kivonás) $a és $b különbsége.
$a * $b(szorozzuk) $a és $b szorzata.
$a / $b(osztás) $a hányadosa osztva $b-vel.
$a % $b(modulo) $a egész maradéka osztva $b-vel.
Vegye figyelembe a példákat
$a = 2; // vegye figyelembe, hogy számok esetén az idézőjel nem kerül beírásra
$b = 3; // vegye figyelembe, hogy számok esetén az idézőjel nem kerül beírásra
$eredmény = $a + $b; // változók hozzáadása
echo $eredmény; // nyomtat 5
$eredmény = $b - $a; // változók hozzáadása
echo $eredmény; // nyomtat 1
Növelési és csökkentési műveletek PHP-ben
Ezek a műveletek elsősorban a ciklusok felépítésében lesznek hasznosak, amelyekről egy kicsit később fogunk beszélni.
előtag- a változó ELŐTT írt operátorok ( --$a; ++$a). A változtatások előtt adja vissza a változó értékét.
Postfix- a változó után írt operátorok ( $a--; $a--). Egy változó értékét adja vissza változtatásokkal.
Növekedés- az érték növelése.
Csökkenés- csökkenő érték.
++$a előtag növekménye. Növeli $a eggyel, és visszaadja $a értékét.
$a++ postfix növekmény. Visszaadja $a értékét, majd eggyel növeli $a értékét.
--$a előtag csökkenése. Csökkenti $a-t eggyel, és visszaadja $a értékét.
$a-- Postfix csökkenés. Visszaadja $a értékét, majd eggyel csökkenti $a értékét.
visszhang"
visszhang"
visszhang"
visszhang"
Hozzárendelési műveletek PHP-ben
Alap operátorúgy néz ki, mint a =
. Első pillantásra úgy tűnhet, hogy ez az egyenlőség operátor. Valójában nem. Valójában a hozzárendelési operátor azt jelenti, hogy a bal oldali operandus megkapja a jobb oldali kifejezés értékét (azaz a kapott értékre van állítva). Kombinált operátorok- ezek olyan operátorok, amelyek lehetővé teszik a változók korábbi értékeinek használatát a következő műveletekhez (sztring változóhoz (szöveggel) vagy numerikus értékek hozzáadásához).
$a = ($b = 2) + 4; // eredmény: $a értéke 6, $b értéke 2.
$a = 2;
$a += 3; // az $a-t 5-re állítja, hasonlóan a következőhöz: $a = $a + 3;
$b = "Szia";
$b .= "Béke!"; // beállítja a $b-t "Hello World!"-re, mint például a $b = $b . "Ott!";
Vannak még összehasonlító műveletekÉs összerakós játékaik, de róluk a következő leckékben fogunk beszélni. Igyekszem nem ijesztgetni egyszerre nagy mennyiségű információval!)
13 évvel ezelőtt
Egy kis apróság, amire figyelni kell:
Ha te kikapcsolni RegisterGlobals és kapcsolódó, majd a get_defined_vars() használatával a következőkhöz hasonlót láthat:
sor
[ GLOBALS ] => Tömb
[ GLOBALS ] => Tömb
*REKURZIÓ*
[_POST] => Tömb()
[ _GET ] => Array()
[_COOKIE] => Tömb()
[ _FILES ] => Array()
)
[_POST] => Tömb()
[ _GET ] => Array()
[_COOKIE] => Tömb()
[ _FILES ] => Array()
)
?>
Figyeljük 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álatban van. Ezt teheti:
nyomtatás"
" .htmlspecialchars(print_r(get_defined_vars(), true )) . "" ;
" .htmlspecialchars (print_r ($_SERVER , true )) . "" ;
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ód 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" )(
$e-mail = $_SZERVER["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:
11 évvel ezelőtt
Megjegyzésként 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.
A Windows környezeti változói (környezet) különféle információkat tartalmaznak a rendszerbeállításokról és a felhasználó környezetérő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át a Windows rendszerben a legegyszerűbben úgy tekintheti meg, ha megnyitja a rendszertulajdonságokat ( sysdm.cpl) -> Speciális -> Környezeti változók. Amint látható, a megnyílt szekcióban két rész található: a felső a felhasználó környezeti változóit tartalmazza, az alsó pedig a rendszerváltozókat.
Ezenkívül a környezeti változókat a rendszerleíró adatbázis tárolja. A felhasználói változókat a . Szisztémás - be HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment.
Az összes környezeti változó értékét megjelenítheti a Windows parancssorában. A parancs egyszerű:
A parancs felsorolja a környezeti változókat és azok értékeit.
A PowerShellben az összes környezeti változó megjelenítéséhez a következő parancsot használhatja:
Ha csak egy változó értékét szeretné megjeleníteni, akkor az echo parancsot kell használnia, és a változó nevét százalékjelek közé kell tenni. Például,
echo %systemroot%
set > c:\tmp\env_var.txt
Egy adott folyamat környezeti változói a free segítségével szerezhetők be Process Explorer segédprogramok(a Sysinternalstól). Csak nyissa meg a folyamat tulajdonságait, és lépjen a lapra Környezet.
Biztos van otthon szekrényed vagy komódod. Használatuk elve egyszerű: olyan dolgokat teszünk oda, amelyekre most nincs szükségünk, de egy idő után szükség lehet rá.
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á.
Egy ilyen változóba értéket adhatsz:
A fenti kódban létrehoztuk a $name változót és beleírtuk az Iván értéket, majd létrehoztuk az $age változót és hozzárendeltük a 20 értéket.
A "változó" név azt jelenti, hogy értéke változhat a szkript végrehajtása során:
Egyes nyelveken a változókat először „deklarálni kell” használat előtt. A PHP-ben nincs deklaráció – 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.
Ezenkívül az "értéket adjon a változóba" helyett gyakran azt mondják, hogy "értéket rendel".
Az ok egyszerű - az = szimbólumot, amelynek köszönhetően egy változóban tároljuk az értéket, "hozzárendelési operátornak" nevezzük. Innen ered a "hozzárendelés" kifejezés.
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.
Egy változót a már általunk ismert echo paranccsal jeleníthet meg:
Az echo parancs lehetővé teszi több érték megjelenítését egyszerre:
Vegye figyelembe, hogy 2 értéket adtunk át a visszhangnak, vesszővel elválasztva őket. Így annyi értéket adhatunk át, amennyit csak akarunk. A következő két példa ugyanazt az eredményt adja:
A PHP-ben is van egy rövidített szintaxis a változók kimenetére. Ahelyett
A PHP 5.4 előtt a gyorsírási szintaxis csak akkor működött, ha a short_open_tag direktíva engedélyezve volt a PHP beállításaiban, amely lehetővé teszi a rövidített nyitócímke használatát is
Az echo parancs nem mindig alkalmas egy változó aktuális értékének ellenőrzésére. Például, ha egy üres "" karakterláncot próbál megjeleníteni, akkor semmi sem fog megjelenni a képernyőn. És nem világos, hogy mi az oka - üres változóban vagy nem működő kódban.
Ezért a var_dump() függvény egy változó értékének ellenőrzésére szolgál:
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 adja ki, 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.
Egy meglévő változót az unset() függvénnyel távolíthat el:
És most itt az ideje gyakorolni egy kicsit.
Ne feledje, szinte minden PHP-probléma több megoldást is tartalmazhat. Ezért, ha az Ön döntései eltérnek az ezen az oldalon leírtaktól, ez egyáltalán nem jelenti azt, hogy valamit rosszul csinált.
Írj egy szkriptet, amely:
1. Cím és tartalom nevű változókat és néhány értéket hoz létre.
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"
Szeretném még egyszer 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:
Ebben a leckében a hatókört vizsgáljuk meg. 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 hozzáférni a függvényen belüli globális változókhoz, hogyan kell dolgozni szuperglobálisokkal és statikus változókat létrehozni.
Amikor elkezded PHP tanulásés elkezd dolgozni a függvényekkel és objektumokkal, a változók hatóköre némi zavart okoz. Szerencsére a PHP szabályai ebben a vonatkozásban nagyon könnyen érthetők (más programozási nyelvekhez képest).
A változó 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:
A változó hatókör, és különösen a helyi hatókör 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 a szkript különböző részei nagyon gyakran használnak azonos nevű változókat. Ha a hatókört a helyi környezetre korlátozza, meghatározhatja a változóhoz hozzáférő kód határait, ami robusztusabbá, modulárisabbá és könnyebben hibakereshetőbbé teszi a kódot.
Változók globális hatókör a hatóköröket globálisnak, a helyi hatókörrel rendelkezőket 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 "Érték \$globalName: "$globalName"
"; echo "Érték \$localName: "$localName"
";
?>
Szia Harry! $globalName értéke: "Zoya" $localName értéke: ""
Ebben a szkriptben két változót hoztunk 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 "Hi 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:
Globális változó eléréséhez funkción kívül csak írd 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 nem, akkor a PHP feltételezi, hogy Ön 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 ("Zoya").
A PHP speciális előre meghatározott készlettel rendelkezik globális tömbök amelyek különféle információkat tartalmaznak. Az ilyen tömböket ún szuperglobálisok, mivel bárhonnan elérhetők a szkriptben, 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:
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 ezt az adatátvitelt soha nem szabad használni a gyenge biztonság miatt. Mindig ellenőrizze vagy szűrje az adatokat.
A $GLOBALS szuperglobal nagyon kényelmesen használható, mivel 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 a globális kulcsszót kellene használni. Például:
"; ) sayHello(); // A "Hello Zoya!" ?> megjelenítése
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 leáll, a lokális 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 önellátóak, és mindig ugyanúgy működnek minden alkalommal, 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; )
Vegyünk egy olyan 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 kiírja 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 egyes függvényhíváskor létrejön, a következő eredményt kapjuk:
Létrehozunk néhány widgetet... 1-et már létrehoztunk. 1 már létrehoztuk. 1 már létrehoztuk.
De statikus változó használatával megtarthatjuk 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... 1-et már létrehoztunk. 2 már létrehoztuk. 3 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 szkript befejezi a végrehajtást, az összes statikus változó, valamint a helyi és globális változók megsemmisülnek.
Ez minden! Gyakran olvassa el a PHP dokumentációját.
