Hogyan van hozzárendelve egy konstans a php-ben? PHP szabványos állandók. Állandó létezésének ellenőrzése

Ebben a megjegyzésben meg fogjuk érteni, mi a különbség PHP deklaráció konstansokat a const kulcsszó és a define() függvény használatával.

A PHP-ben a konstansok "konstansok", amelyek értéke csak egyszer van megadva, és utólag nem módosítható. Amikor megpróbálja megváltoztatni az értéket, az nem fog megváltozni, és megjelenik egy PHP megjegyzés: "A konstans már definiált" (az állandó már definiálva van):

Define("FOO", "val"); define("FOO", "val2"); // Megjegyzés: A már definiált állandó echo FOO; //> val

A PHP-ben kétféleképpen deklarálhatunk konstansokat:

// 1 define("NÉV", "ÉRTÉK"); // 2 const NÉV = "ÉRTÉK";

Mindegyik módszernek megvannak a sajátosságai, ezek megértése érdekében nézzünk meg mindent szakaszosan, hogyan és mi változott a PHP egyes verzióival.

Hogyan készítsünk állandókat

PHP kevesebb, mint 5.3

A PHP 5.3 előtt az állandókat csak a define() segítségével lehetett meghatározni. A const kulcsszó az 5.3-as verzió óta létezik.

A konstansok csak skalárokat tárolhatnak. A skaláris változók egész szám , float , string és logikai típusú változók . A tömb , objektum és erőforrástípusok nem skalárisak.

// skalárok define("FOO", 10); define("FOO", 10.9); define("FOO", "val"); define("FOO", igaz); // nem skalarok define("FOO", array(1)); // konstans nincs beállítva és get Warning define("FOO", (object) array(1)); // a konstans nincs beállítva, és megkapja a Figyelmeztetést

A PHP 5.3 óta

Megjelent kulcsszó const és most egy állandó is definiálható vele.

Azonban nem adhat meg változót, függvényt vagy valamilyen kifejezést a const-ban, hanem "közvetlenül" kell átadnia egy skalárt:

Const FOO = "val"; // nincs hiba const FOO = $var; // Elemzési hiba const FOO = home_url(); // Elemzési hiba const FOO = 5 + 10; // Elemzési hiba const FOO = "foo"."bar"; // elemzési hiba

Míg a define() esetében nincsenek ilyen korlátozások...

Define("FOO", "val"); // nincs hiba define("FOO", $var); // nincs hiba define("FOO", home_url()); // nincs hiba define("FOO", 5 + 10); // nincs hiba define("FOO", "foo"."bar"); // nincs hiba

PHP 5.6

Lehetővé vált primitív értékek megadása const értékekben PHP kifejezések(kifejezések skalárokból):

Const FOO = 1 + 2; const FOO = "foo" . "rúd";

Lehetővé vált a tömbök konstansokban való tárolása:

Const FOO = ; // működik a define("FOO", ); // PHP 5.6-ban nem működik, PHP 7.0-ban működik

A define() és a const közötti különbség

Az #1 const-ot a felső hatókörben kell deklarálni

A define() függvénytől eltérően a const a legfelső hatókörben kell deklarálni, mert a parancsfájl fordításakor kerülnek meghatározásra. Ez azt jelenti, hogy nem deklarálhatók függvények/hurkok/if utasításokban vagy try/catch blokkokban.

If (1) ( const NÉV = "ÉRTÉK"; // nem működik ) // de if (1) ( define("NAME", "VALUE"); // működik )

#2 const mindig megkülönbözteti a kis- és nagybetűket

A const mindig megkülönbözteti a kis- és nagybetűket, míg a define() lehetővé teszi, hogy a kis- és nagybetűket nem érzékeny konstansokat állítson elő:

Define("NÉV", "ÉRTÉK", igaz); visszhang NÉV; // ÉRTÉK visszhangnév; // ÉRTÉK

#3 const csak a skalárokat érti

Ez csak a PHP 5.6-os és korábbi verzióira igaz...

A const nem adható át változóknak, függvényeknek, kifejezéseknek, de a define() lehet:

Const FOO = $var; // Elemzési hiba const FOO = home_url(); // Elemzési hiba define("FOO", $var); // nincs hiba define("FOO", home_url()); // nincs hiba

A #4 const a PHP 5.6 óta képes tömböket tárolni és a PHP 7.0 óta definiálni

Összehasonlítási eredmények

Szinte mindig jobb, ha egy konstanst a define() paranccsal definiál, mert több lehetőség és kevesebb lehetőség van a hiba "elkapására"... A kivétel az, ha PHP verzió 5.6 és konstansba kell menteni a tömböt, itt a const segít.

PHP osztálykonstansok

Csak a const -val vannak deklarálva. A szabályok rájuk a fent leírtak: csak skalárokat fogadnak el, nem értik PHP változók, függvények, kifejezések...

Az osztálykonstansok mindig nyilvánosak – nincs privát vagy védett állapot.

A deklarált állandó az osztályhoz tartozik, nem tartozik egyetlen objektumhoz sem, és az osztály összes objektumára (példányára) közös.

Osztály My_Class ( const NÉV = "ÉRTÉK"; // a PHP 5.6 óta használhatsz matematikai kifejezéseket: const SEC_PER_DAY = 60 * 60 * 24; függvény print_name() ( // egy metóduson belüli osztálykonstansra hivatkozva önmagán keresztül (maga az osztály) echo self ::NAME; ) ) // az osztályon kívüli konstansra való hivatkozás // hívható a globális hatókörből az osztálypéldány inicializálása nélkül echo My_Class::NAME;

Az osztályállandók nagyon hasonlóak a statikus osztálytulajdonságokhoz.

Class My_Class ( const NÉV = "ÉRTÉK"; statikus $név = "ÉRTÉK";; ) echo My_Class::NAME; echo My_Class::$name;

"Mágikus" állandók

Végezetül pedig emlékezzünk a speciális PHP állandókról...

A PHP-nek kilenc mágikus állandója van, amelyek a használat kontextusától függően változtatják a jelentésüket. Például a __LINE__ értéke a szkript azon sorától függ, amelyen ez a konstans meg van adva. Minden "mágikus" konstans feloldása fordítási időben történik, ellentétben a normál konstansokkal, amelyek futási időben kerülnek feloldásra. A speciális állandók nem tesznek különbséget a kis- és nagybetűk között, és az alábbiakban találhatók:

Az állandók létezésének ellenőrzése

Konstansok a PHP-ben

A konstans egy elnevezett érték, amely nem változik a program végrehajtása során.

A változókkal ellentétben nem változtathatja meg a deklaráláskor hozzárendelt állandó értékét. A konstansok hasznosak olyan értékek tárolására, amelyek nem változhatnak a program futása közben. A konstansok csak skaláris adatokat tartalmazhatnak (boolean, integer, float és string típusok).

A PHP-ben az állandókat a függvény határozza meg define() . Ennek a függvénynek a formátuma a következő:

meghatározni ($név, $érték, $case_sen), ahol:

$név- az állandó neve;
$érték- az állandó értéke;
$case_sen- opcionális logikai típusú paraméter,
legyen-e kis- és nagybetű érzékeny (igaz) vagy sem (hamis).

Példa konstansok meghatározására és használatára PHP-ben:

define("pi",3.14,igaz);
echopi;
// Kimenetek 3.14
?>

Ha a paraméter $case_sen egyenlő igaz, akkor az értelmező megkülönbözteti a kis- és nagybetűket a konstans kezelésénél. Vegye figyelembe, hogy a konstansokat előtag nélkül használjuk $ .

Az állandók és a változók közötti különbségek:

A konstansoknak nincs dollárjel előtagja ( $ );

A konstansok csak a függvénnyel definiálhatók define(), nem érték hozzárendelésével;

· A konstansok bárhonnan definiálhatók és elérhetők a hatókör figyelembevétele nélkül;

· A konstansok nem definiálhatók vagy törölhetők a kezdeti deklaráció után; és

· A konstansoknak csak skaláris értékei lehetnek.

Egy állandó létezésének ellenőrzéséhez használhatja a függvényt meghatározott() . Ez a funkció visszatér igaz, ha a konstans deklarálva van. Íme egy példa:

// A pi konstans deklarálása
define("pi",3.14,igaz);
if (defined("pi")==true) echo "A pi konstans deklarálva van!";
// A szkript kiírja a "Constant pi deklarált!"
?>

A PHP a következő előre definiált állandókkal rendelkezik:

A PHP előre definiált állandók nagy listáját kínálja minden végrehajtott szkripthez. Ezen állandók közül sokat különböző modulok határoznak meg, és csak akkor lesznek jelen, ha ezek a modulok dinamikus betöltés vagy statikus felépítés révén elérhetők.

Öt előre definiált állandó van, amelyek a használat kontextusától függően változtatják jelentésüket. Például az állandó __VONAL__ attól függ, hogy a szkript melyik sorában van megadva ez az állandó. A speciális állandók nem tesznek különbséget a kis- és nagybetűk között, és az alábbiakban találhatók.

Ez a bejegyzés az állandókról szól. Szokás szerint foglalkozzunk a konstans fogalmával a programozási nyelvekben, és nézzük meg, hogyan deklarálják és használják őket konstansok PHP-ben.

A konstans és a konstans fogalma a PHP-ben

A konstans szónak ismerősnek kell lennie a matematikából:

„Matematikai állandó- olyan mennyiség, amelynek értéke nem változik.

Ugyanez igaz a PHP-ben is. Állandó a PHP-ben egy olyan azonosító, amely egy egyszerű érték (karakterlánc, valamilyen szám) kijelölésére szolgál, amely kódvégrehajtás során nem módosítható.

Egy állandó deklarálásához (érték hozzárendeléséhez) használja a függvényt meghatározni. Példa egy állandó deklarációra:

A PHP-ben a konstans nevek megkülönböztetik a kis- és nagybetűket (a nagy- és kisbetűk eltérőek), ezért óvatosnak kell lenni. Van egy olyan konvenció is, hogy az állandó neveket mindig nagybetűvel írjuk.

A konstans nevének betűvel vagy „_” aláhúzásjellel kell kezdődnie, és betűkből, számokból és aláhúzásjelekből állhat.

Vegyünk egy egyszerű példát egy állandó használatára:

Ebben a példában deklaráltunk egy konstanst és használtuk a programban.

Mire használhatók az állandók, és nem egyszerűbb a változók használata?

Mint már említettük, a konstansok nem változtathatják meg értéküket a program végrehajtása során. A konstansok általában állandó helyparamétereket tárolnak, például adatbázis-hozzáférési adatokat (gazdagép, felhasználónév és jelszó, adatbázisnév), a hely helyét a lemezen és sok más beállítást.

Ha változókat használunk, akkor a szkript véletlenül (hiba esetén) megváltoztathatja a változó értékét, és nem fog úgy működni, ahogyan azt akarta.

A konstansok használata biztosítja, hogy a konstans deklarálásakor megadott érték változatlan maradjon.

Jó nap. Alexey Gulynin kapcsolatban áll. Az utolsó cikkben megbeszéltük ekvivalencia operátor a PHP-ben. Ebben a cikkben arról szeretnék beszélni konstansok PHP-ben. Az iskolában gyakran találkozott állandókkal, például a "PI-számmal" vagy a fizikából az univerzális gázállandóval (R). Az állandók definiálják egyszer és már nem változnak. Ugyanez vonatkozik a konstansokra a programozásban, pl. egyszer definiálunk egy konstanst és már nem változik a programkódban. A konstansok különféle matematikai értékek, fájlok elérési útjai lehetnek.

Miben különbözik egy állandó a változótól:

1) Egyszer van meghatározva, és sehol máshol nem lehet értéket hozzárendelni,
2) A hivatkozáshoz nem kell "$" jelet tenni elé (itt van egy mínusz - most már nem használhatjuk a konstans nevét szöveges karakterláncban).
Nyomtassuk ki a "PI" állandót:

A konstansoknak két típusa van: tolmács által meghatározott és felhasználó által meghatározott:

Példák az értelmező által meghatározott állandókra:

1) __FILE__ - az éppen végrehajtott kódot tartalmazó fájl nevét tárolja,
2) PHP_VERSION – PHP interpreter verzió,
3) PHP_OS - verzió operációs rendszer amely alatt a PHP fut.

Írja be a következő kódot, és nézze meg, mik az egyéb állandók:

Megadhatja saját állandóit, ez a define utasítással történik. Definiáljunk 2 állandót:

"; echo Const2; ?>

Ebben az esetben ezeknek az állandóknak az értékeit jelenítjük meg.

Alapértelmezés szerint a konstans neve megkülönbözteti a kis- és nagybetűket, kikapcsolható az opcionális harmadik paraméterrel, így:

"; echo newW1; ?>

Látni fogja, hogy minden működik (az előző példában nem fog működni, mivel megkülönbözteti a kis- és nagybetűket).

Ügyeljen az idézetekre, amelyekben az állandó neve szerepel. Ezt meg kell tenni. Ezenkívül nem hozhat létre azonos nevű állandókat.

A PHP-ben ellenőrizheti, hogy létezik-e konstans, vagy nem használja a függvényt meghatározott (állandó név). Vegyünk egy példát, hogy egyértelmű legyen:

Írja be ezt a példát, és nézze meg, mi történik.

A változó olyan entitás, amely adatokat tartalmaz. Ha az adattípus Általános leírása a tárolt adatok formátuma és a velük való munkavégzés módja, akkor a változó a számítógép memória egy adott blokkját jelöli. Ez a blokk tárolja változó érték, és a blokkra (és az értékre) hivatkozhat változó neve.

A PHP-ben a változó neve mindig dollárjellel ($) kezdődik, amelyet egy betű követ, majd betűk, számok és aláhúzásjelek. A nevek megkülönböztetik a kis- és nagybetűket, pl. a $érték, $érték, $ÉRTÉK és $Érték változó négy KÜLÖNBÖZŐ változó, bár a nevük ugyanaz.

Példák szintaktikailag helyes változónevekre:

Példa érvénytelen nevekre:

Van egy Általános szabály(minden programozási nyelvhez) a változók elnevezésével kapcsolatban. A szabály nagyon egyszerű: a neveknek mindig értelmesnek kell lenniük.

Egy példa a rosszul olvasható kódra

A rövidség természetesen a tehetség lényege, de ésszerűtlen feláldozni a kód könnyű érzékelhetőségét a tömörsége érdekében. Ráadásul a név hossza semmilyen módon nem befolyásolja a forgatókönyv teljesítményét. De nem szabad az ellenkező végletbe esni – változókat is megadni hosszú nevek. Ha a névnek két vagy több szóból kell állnia, a név egyes részeit ki kell jelölni nagybetűvel vagy aláhúzásjelekkel elválasztva. Például név $strusernameadndomain formában sokkal jobb $str_UserNameAndDomain.

Példa jól olvasható kódra

A változóknak két típusa van: szabályos változók(értékváltozók) és referencia változók. A legfontosabb különbség köztük az adatok feldolgozási módja. Amikor egy közönséges változóhoz értéket adunk, a hozzárendelt érték teljesen másolódik, azaz. létre új blokk memória, ahová az eredeti érték másolata kerül. Nál nél további munka minden változás ebben a másolatban, és nem az eredeti adatokban fog megjelenni.

A referenciaváltozók eltérően működnek. Amikor egy referenciaváltozóhoz értéket rendelünk, a rendszer nem adatokat másol, hanem információkat arról, hogy hol találhatók. Ennek eredményeként kiderül, hogy a változó ugyanarra a blokkra mutat, amely az eredeti adatokat tartalmazza. Most, ha megváltoztatja a referenciaváltozó értékét, az eredeti érték megváltozik.

Vegyünk egy példát:

Változók átadása érték szerint

A PHP-ben vannak speciális függvények a változókkal való munkavégzéshez:

• isset() - ellenőrzi, hogy egy változó deklarálva van-e, és hogy értéke eltér-e a NULL-tól;
• üres() - az isset() analógja
• Az unset() egy beépített nyelvi függvény, amely eltávolítja egy változó értékét, és magát a változót eltávolítja az elérhető változók listájáról (megsemmisíti a változót).

Változó hatókör

Magasan fontos jellemzője változó - hatóköre (hatóköre), azaz. annak leírása, hogy a programban (script) hol lehet olvasni vagy módosítani az értékét. Mindig emlékezni kell arra, hogy egy programblokkon belül deklarált változó csak ezen a blokkon belül látható, és a blokkon kívül deklarált változóra való hivatkozáshoz speciális módon kell deklarálni.

A programblokkok ebben az esetben "script", "function" vagy "class". Például:

Úgy tűnik, minden rendben van, de nem működik. Miért? Mert hacsak nem mondod kifejezetten, hogy a függvényen belüli $name változó valójában a $name globális változó, akkor az értelmező létrehoz egy ideiglenes másolatot a $name nevű változóról és üres érték. És mivel az érték üres (undefined), így a karakterláncok hozzáadásának eredménye nem definiált (üres).

A javítás nagyon egyszerű, csak adjon hozzá egy sort (félkövéren):

globális $név; // kifejezetten jelzi, hogy // globális változót kell használnunk.$fullName = $név . $család; echo "Név a függvényen belül: ".$fullName; ) echo "Név a függvény meghívása ELŐTT: ".$name; // eredmény: "Név a függvény meghívása ELŐTT: Vasya" tryChengeName(" Ivanov"); // eredmény: "Név a függvényen belül: Vasya Ivanov" echo "Név a függvény meghívása UTÁN: ".$name; // eredmény: "Név a függvény meghívása után: Vasya Ivanov" ?>

NÁL NÉL ezt a példát a $name változó hatóköre megegyezik a teljes parancsfájl hatókörével, a függvényben deklarált $fullName változó pedig magának a függvénynek a hatókörével rendelkezik. Ez azt jelenti, hogy amikor a függvényük kilép, a $fullName változó megsemmisül, és az értékének minden beolvasási kísérlete hibát eredményez.

Az „Osztályok és öröklődés” részben az osztályokkal való munkavégzés példáit nézzük meg.

változó változók

Igen, igen, itt nincs tévedés, így (két szóban) a PHP-ben néhány változót hívnak. A lényeg az, hogy egy változónév szöveges része (vagyis a dollárjel nélküli név) maga is név lehet. Például:

Erősen nem ajánlott az ilyen technikák alkalmazása, hacsak nem feltétlenül szükséges. Az ilyen trükkökkel teli kódot nagyon nehéz karbantartani. Ez különösen fontos, ha a felhasználók által bevitt adatokkal dolgozik. A nehézségek fő oka az implicit függőségek. Például mi történik, ha a „Vasya” név helyett valami ilyesmit ír """""_;%//^q""? Helyesen! A szkript a legtöbb esetben meghiúsul! Természetesen hozzáadhat egy csomó ellenőrzést a "rossz" karakterek jelenlétére, de egyszerűbb, ha egyáltalán nem használ ilyen trükköket.

Állandók

Az állandó egy változatlan érték. A konstans névként és értékként egyszerre kerül deklarálásra. A függvény egy állandó deklarálására szolgál. define(), és egy konstans jelenlétének meghatározására (vagyis hogy meg van-e definiálva vagy sem) - a függvény meghatározott(). Egy konstans neve ugyanazon szabályok szerint épül fel, mint a változók neve.

Állandó példák:

A PHP-konstansok külön fajtája az úgynevezett "mágikus konstansok". Ezek olyan rendszerállandók, amelyek értékét az értelmező határozza meg és állítja be. Kevés ilyen állandó van:

• __LINE__ Számot tartalmaz aktuális vonal az aktuális fájlban.
• __FILE__ Az aktuális fájl teljes nevét tartalmazza
• __FUNCTION__ Az aktuális függvény nevét tartalmazza.
• __CLASS__ Az aktuális osztály nevét tartalmazza.
• __METHOD__ Az aktuális osztály aktuális metódusának nevét tartalmazza.

Ezek a konstansok nagyon kényelmesek a hibakereséshez, de minden más esetben jobb, ha nem használjuk őket, helyettük a megfelelő függvények hívásaival.