Minden végrehajtott szkripthez. Ezen konstansok közül sokat különböző modulok határoznak meg, és csak akkor lesznek jelen, ha ezek a modulok ennek eredményeként elérhetők dinamikus terhelés vagy statikus felépítés eredményeként.

Kilenc mágikus állandó van, amelyek a használat kontextusától függően megváltoztatják a jelentésüket. Például az érték __VONAL__ attól függ, hogy a szkript melyik sorában van megadva ez az állandó. Minden mágikus állandó 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:

Néhány varázslatos PHP állandó

Név	Leírás
__VONAL__	Az aktuális sorszám a fájlban.
__FÁJL__	Az aktuális fájl teljes elérési útja és neve kiterjesztett szimbolikus hivatkozásokkal. Ha egy mellékelt fájlon belül használja, akkor az adott fájl nevét adja vissza.
__DIR__	Fájlkönyvtár. Ha egy mellékelt fájlon belül használja, akkor az adott fájl könyvtára kerül visszaadásra. Ez egyenértékű a hívással dirname (__FILE__). A visszaadott könyvtárnév nem végződik perjelre, kivéve a gyökérkönyvtárat.
__FUNKCIÓ__	Funkció neve ill (bezárás) névtelen funkció esetén.
__OSZTÁLY__	Osztály név. Ez a név annak a névtérnek a nevét tartalmazza, amelyben az osztály deklarálva lett (például foo\bar). Ne feledje, hogy a PHP 5.4 óta a __CLASS__ a tulajdonságokban is működik. Jellemző módszerekben használva a __CLASS__ annak az osztálynak a neve, amelyben ezeket a metódusokat használják.
__JELLEMVONÁS__	A tulajdonság neve. Ez a név annak a névtérnek a nevét tartalmazza, amelyben a tulajdonság deklarálva lett (például foo\bar).
__MÓDSZER__	Az osztálymetódus neve.
__NAMESPACE__	Az aktuális névtér neve.
Osztálynév::osztály	Teljes osztálynév (névtérrel). Lásd még ::class .

Lásd még get_class(), get_object_vars(), A fájl létezik()És function_exists().

Változások listája

14 évvel ezelőtt

A különbség
__FUNCTION__ és __METHOD__, mint a PHP 5.0.4-ben, az

A FUNCTION__ csak a függvény nevét adja vissza

míg az as __METHOD__ az osztály nevét adja vissza a függvény nevével együtt

osztályos trükk
{
függvény doit()
{
echo __FUNCTION__;
}
függvény doitagain()
{
visszhang __MÓDSZER__;
}
}
$obj=új trükk();
$obj->doit();
a kimenet ---- doit lesz
$obj->doitagain();
a kimenet ----- trükk::doitagain lesz

13 évvel ezelőtt

A __CLASS__ mágikus állandó szépen kiegészíti a get_class() függvényt.

Néha mindkettőt tudnod kell:
- az örökölt osztály neve
- a ténylegesen végrehajtott osztály neve

Íme egy példa, amely bemutatja a lehetséges megoldást:

osztály alap_osztály
{
függvény say_a()
{

" ;
}

Függvény say_b()
{

" ;
}

osztály származtatott_osztály kiterjeszti az alap_osztályt
{
függvény say_a()
{
szülő::say_a();
echo ""a" - mondta a " . __OSZTÁLY__ . "
" ;
}

Függvény say_b()
{
szülő::say_b();
echo ""b" - mondta a " . get_class($this) . "
" ;
}
}

$obj_b = új származtatott_osztály();

$obj_b -> say_a();
visszhang"
" ;
$obj_b -> say_b();

?>

A kimenetnek nagyjából így kell kinéznie:

"a" - mondta a base_class
"a" - mondta a származtatott_osztály

"b" - mondta a származtatott_osztály
"b" - mondta a származtatott_osztály

3 évvel ezelőtt

Figyeljen meg egy kis ellentmondást, amikor a __CLASS__ és a __METHOD__ tulajdonságokat használja (php 7.0.4): Míg a __CLASS__ hirdetett módon működik, és dinamikusan adja vissza annak az osztálynak a nevét, amelyben a tulajdonságot használják, a __METHOD__ valójában a tulajdonság nevét írja elő osztály név!

8 évvel ezelőtt

Nincs mód visszafelé kompatibilis __DIR__ megvalósítására az 5.3.0 előtti verziókban.

Az egyetlen dolog, hogy tudsz rekurzív keresést kell végrehajtani, és lecserélni a dirname(__FILE__) fájlra:
megtalálja. -type f -print0 | xargs -0 sed -i "s/__DIR__/dirname(__FILE__)/"

5 évvel ezelőtt

Itt sok megjegyzés vonatkozik a __DIR__ mágikus állandó meghatározására a funkciót nem támogató PHP-verziókhoz. Természetesen megadhatja ezt a varázsállandót olyan PHP-verziókhoz is, amelyek még nem rendelkeznek ezzel az állandóval, de megsemmisíti a célját, amint az állandót egy olyan fájlban használja, amely más könyvtárban lehet, mint a __DIR__ állandót meghatározó fájl. . Mint ilyen, a konstans elvesztette *varázsát*, és meglehetősen haszontalan lenne, hacsak nem biztosítod magad arról, hogy minden beletartozód ugyanabban a könyvtárban van.

Következtetés: a gmail dot com megjegyzése arra vonatkozóan, hogy definiálhat-e mágikus állandókat, érvényes, de az, hogy a __DIR__ meghatározása nem haszontalan, nem az!

7 évvel ezelőtt

Nem ellenőrizheti, hogy van-e mágikus állandó definiálva. Ez azt jelenti, hogy nincs értelme ellenőrizni, hogy a __DIR__ definiálva van-e, majd meghatározni. A `defined("__DIR__")` mindig false értéket ad vissza. A __DIR__ meghatározása csendben meghiúsul a PHP 5.3+ verziójában. Ez kompatibilitási problémákat okozhat, ha a szkript más szkripteket is tartalmaz.

echo (defined ("__DIR__" ) ? "__DIR__ meghatározva" : "__DIR__ NINCS definiálva" . PHP_EOL );
echo (defined ("__FILE__" ) ? "__FILE__ meghatározva" : "__FILE__ NINCS definiálva" . PHP_EOL );
echo (defined ("PHP_VERSION" ) ? "PHP_VERSION definiálva" : "PHP_VERSION NINCS definiálva" ) . PHP_EOL ;
echo "PHP verzió: " . PHP_VERSION . PHP_EOL ;
?>
Kimenet:
A __DIR__ NINCS definiálva
A __FILE__ NINCS definiálva
PHP_VERSION definiálva
PHP verzió: 5.3.6

Utolsó frissítés: 2015.11.1

A konstansok, akárcsak a változók, egy adott értéket tárolnak, csak eltérően változó érték konstansokat csak egyszer lehet beállítani, és akkor már nem tudjuk megváltoztatni. Például definiáljunk egy numerikus állandót:

Egy konstans definiálásához a define utasítást használjuk, amelynek a következő alakja van: define(string $name, string $value, bool $case_sen=false) . A $name paraméter a konstans neve, a $value paraméter pedig az értéke. A harmadik opcionális paraméter veszi logikai érték igaz vagy hamis . Ha az érték hamis, akkor a konstans használatakor annak esetét veszi figyelembe, ha igaz, akkor az esetet nem. Esetünkben a harmadik paramétert nem használjuk, így alapértelmezés szerint false.

Egy konstans definiálása után ugyanúgy használhatjuk, mint egy normál változót. Az egyetlen kivétel az, hogy az értékét nem tudjuk megváltoztatni. Egy másik különbség a változókhoz képest, hogy nem kell használnia a $ jelet. Vagyis a SZÁM=33 kifejezés; nem fog működni.

Előre meghatározott állandók

A programozó által létrehozott állandókon kívül a PHP számos beépített konstanssal rendelkezik:

FILE__ : az aktuális fájl teljes elérési útját és nevét tárolja

LINE__ : tárolja az aktuális sorszámot, amelyet a tolmács feldolgoz

DIR__ : az aktuális fájl könyvtárát tárolja

FUNCTION__: a feldolgozás alatt álló függvény neve

CLASS__ : az aktuális osztály neve

METHOD__ : a feldolgozás alatt álló metódus neve

NAMESPACE__ : az aktuális névtér neve

Például nyomtassuk ki az aktuális végrehajtható sort és fájlnevet:

Állandó létezésének ellenőrzése

Annak ellenőrzésére, hogy egy konstans definiálva van-e, használhatjuk a bool definiált(string $name) függvényt. Ha a $name konstans definiálva van, akkor a függvény true értéket ad vissza

(PHP 5 >= 5.3.0, PHP 7)

Ez a kérdéslista két részre oszlik: általános kérdésekre és néhány konkrét megvalósításra, amelyek hasznosak a teljesebb megértéshez.

Először is általános kérdések.

1. Ha nem használok névtereket, akkor ezek bármelyikét fontosnak kell tekinteni?
2. Hogyan használhatok belső vagy globális osztályokat egy névtérben?
3. Hogyan használhatok osztályfüggvényeket a névterekben, vagy konstansokat a saját névterükben?
4. Milyen egy név \nevem vagy \névátalakítva?
5. Mint egy név, mint nevemátalakítva?
6. Minősítés nélküli osztálynévként, mint pl névátalakítva?
7. Minősítés nélküli függvénynévként vagy minősítetlen állandó névként, mint pl névátalakítva?

A névterek néhány megvalósítási részlete, amelyeket hasznos megérteni.

1. Az importált nevek nem ütközhetnek az ugyanabban a fájlban definiált osztályokkal.
2. Sem függvények, sem konstansok nem importálhatók az utasítás segítségével használat.
3. A dinamikus névterek nevének (az azonosítók idézőjelek között) el kell hagynia a fordított perjelet.
4. Nem hivatkozhat nem definiált állandókra fordított perjel használatával. Végzetes hiba történik
5. Nem írhatók felül speciális állandók, például NULL, TRUE, FALSE, ZEND_THREAD_SAFE vagy ZEND_DEBUG_BUILD

Ha nem használok névtereket, akkor ezek bármelyikét fontosnak kell tekinteni?

Nem. A névtereknek nincs hatása semmilyen formában létező kódra, vagy olyan írott kódra, amely nem tartalmaz névtereket. Ha akarod, írhatsz ilyen kódot:

Beispiel #1 Globális osztályok elérése névtéren kívül

$a = új \ stdClass ;
?>

Ez funkcionálisan egyenértékű a következővel:

Beispiel #2 Globális osztályok elérése névtéren kívül

$a = új stdClass ;
?>

Hogyan használhatok belső vagy globális osztályokat egy névtérben?

Beispiel #3 Belső osztályok elérése névterekben

névtér foo ;
$a = új \ stdClass ;

függvényteszt(\ArrayObject $typehintexample = null )()

$a = \ DirectoryIterator :: CURRENT_AS_FILEINFO ;

// belső vagy globális osztály kiterjesztése
osztály MyException extends\Exception()
?>

Hogyan használhatok osztályfüggvényeket a névterekben vagy konstansokat a saját névterükben?

Beispiel #4 Belső osztályok, függvények vagy konstansok elérése a névterekben

névtér foo ;

classMyClass()

// az aktuális névtérből származó osztály használatával
funkcióteszt (MyClass $typehintexample = null ) ()
// egy másik módja egy osztály használatának az aktuális névtérből
függvényteszt(\foo\MyClass $typehintexample = null )()

// osztálykiterjesztés az aktuális névtérből
class Extended kiterjeszti MyClass()

// hozzáférés a globális függvényhez
$a = \globalfunc();

// hozzáférés a globális állandóhoz
$b = \ INI_ALL ;
?>

Milyen egy név \nevem vagy \névátalakítva?

-vel kezdődő nevek \ mindig arra konvertálódnak, ahogy kinéznek, pl. \nevem- Valójában az nevem, És \Kivétel- Ezt Kivétel.

5. példa Abszolút nevek

névtér foo ;
$a = új\saját\nev(); // létrehozza a "my\name" osztály példányát
echo \strlen("szia"); // meghívja az "strlen" függvényt
$a = \ INI_ALL ; // a $a változóhoz az "INI_ALL" konstans értéke van hozzárendelve
?>

Mint egy név, mint nevemátalakítva?

A fordított perjelet tartalmazó, de azzal nem kezdődő nevek, mint pl nevem

az én másik név, akkor ez a szinonimája vonatkozik az én V nevem.

nevem.

6. példa Teljes nevek

névtér foo ;
használja a bla \ bla szót foo-ként;

$a = new my\name(); // létrehozza a "foo\my\name" osztály példányát
foo\bar::név(); // meghívja a statikus "name" metódust a "blah\blah\bar" osztályban
my\bar(); // meghívja a "foo\my\bar" függvényt
$a = my\ BAR ; // a $a változóhoz a "foo\my\BAR" konstans értékét rendeli
?>

Minősítés nélküli osztálynévként, mint pl névátalakítva?

A fordított perjelet nem tartalmazó osztálynevek, mint pl név kétféleképpen konvertálható.

Ha van olyan import kifejezés, amely szinonimát hoz létre név másik név, akkor ezt a szinonimát használjuk.

Ellenkező esetben az aktuális névtér neve a következő előtagja lesz nevem.

7. példa Minősítés nélküli osztálynevek

névtér foo ;
használja a bla \ bla szót foo-ként;

$a = újnév(); // létrehozza a "foo\name" osztály példányát
foo::név(); // meghívja a statikus "name" metódust a "blah\blah" osztályban
?>

Minősítés nélküli függvénynévként vagy minősítetlen állandó névként, mint pl névátalakítva?

Funkció- vagy konstansnevek, amelyek nem tartalmaznak fordított perjelet, mint pl név kétféleképpen konvertálható.

Először is, az aktuális névtér neve a következő előtagjává válik név.

Majd ha konstans vagy függvény név nem létezik az aktuális névtérben, globális állandót vagy függvényt használnak név ha létezik.

8. példa Nem minősített függvény vagy állandó nevek

névtér foo ;
használja a bla \ bla szót foo-ként;

const FOO = 1 ;

függvény my()()
functionfoo()()
függvényrendezés (& $a )
{
\sort($a); // meghívja a globális függvényt "sort"
$a = array_flip($a);
return $a ;
}

az én(); // meghívja a "foo\my"-t
$a = strlen("szia"); // "strlen" globális függvényt hív meg, mert a "foo\strlen" nem létezik
$arr = array(1 , 3 , 2 );
$b = sort($arr); // meghívja a "foo\sort" függvényt
$c = foo(); // meghívja a "foo\foo" függvényt - nincs importálás

$a = FOO ; // az $a változót a "foo\FOO" konstans értékére állítja - nincs importálás
$b = INI_ALL ; // hozzárendeli az "INI_ALL" globális állandó értékét a $b változóhoz
?>

Az importált nevek nem ütközhetnek az ugyanabban a fájlban definiált osztályokkal.

A következő szkript-kombinációk megengedettek:

névtér én \ cuccok ;
classMyClass()
?>

névtér másik ;
osztálytárgy()
?>

névtér én \ cuccok ;
tartalmazza "file1.php" ;
tartalmazza "egyéb.php" ;

$a = új MyClass ; // létrehozza a "dolg" osztály példányát a "másik" névtérből
?>

Nincs névütközés annak ellenére, hogy az osztály Az osztályom létezik a névtérben cuccom mert a MyClass definíciója külön fájlban van. A következő példa azonban végzetes névütközési hibát eredményez, mivel a MyClass osztály ugyanabban a fájlban van definiálva, mint a use utasítás.

névtér én \ cuccok ;
használj egy másik \ dolgot MyClass néven;
classMyClass() // végzetes hiba: A MyClass ütközik egy import utasítással
$a = új MyClass ;
?>

A beágyazott névterek nem engedélyezettek.

A PHP nem teszi lehetővé a névterek egymásba ágyazását.

névtér my\stuff(
névtér beágyazott (
classfoo()
}
}
?>

Azonban szimuláljon beágyazott névtereket, például:

névtér my\stuff\nested(
classfoo()
}
?>

A PHP 5.6 előtt sem függvényeket, sem konstansokat nem lehetett importálni a segítségével használat.

A PHP 5.6 előtt csak az operátor által érintett elemek használat névterek és osztálynevek. A hosszú konstans- vagy függvénynevek lerövidítéséhez importálja a tartalmukat a névtérbe.

névtér enyém ;
ultra\long\ns\name használata;

$a = név \ CONSTANT ;
name\func();
?>

A PHP 5.6 óta lehetséges a függvények és állandó nevek álneveinek importálása és létrehozása.

A dinamikus névterek nevének (az azonosítók idézőjelek között) el kell hagynia a fordított perjelet.

Fontos ennek ábrázolása, mert a fordított perjelet a karakterláncokon belül escape karakterként használják. Mindig meg kell ismételni, ha egy karakterláncon belül használják, különben nem kívánt következmények veszélye áll fenn:

9. példa Buktatók, ha névtérnevet használunk dupla idézőjeles karakterláncon belül

$a = "veszélyes\név" ; // A \n egy újsor egy idézőjeles karakterláncon belül!
$obj = új $a ;

$a = "nem\mindenképpen\veszélyes" ; // és nincs gond.
$obj = új $a ;
?>

Egy idézőjeles karakterláncokon belül a fordított perjel elválasztóként biztonságosabb, de továbbra is a legjobb gyakorlat a fordított perjel elhagyása minden karakterláncban.

Nem hivatkozhat nem definiált állandókra fordított perjel használatával. Végzetes hiba történik

Bármilyen definiálatlan állandó, amely minősíthetetlen név, mint pl FOO, egy üzenetet fog küldeni, amely szerint a PHP feltételezte ezt FOO a konstans értéke volt. Minden olyan állandó, teljesen minősített vagy abszolút, amely fordított perjelet tartalmaz, végzetes hibát eredményez, ha nem található.

10. példa Nem definiált állandók

névtér sáv ;
$a = FOO ; // figyelmeztetést nyomtat: undefined konstansok "FOO" feltételezett "FOO";
$a = \FOO ; // végzetes hiba: nem definiált névtér állandó FOO
$a = Bar\FOO ; // végzetes hiba: undefined namespace konstans bar\Bar\FOO
$a = \Bar\FOO ; // végzetes hiba: nem definiált névtér állandó Bar\FOO
?>

Nem írhatók felül speciális állandók, például NULL, TRUE, FALSE, ZEND_THREAD_SAFE vagy ZEND_DEBUG_BUILD

Bármilyen kísérlet olyan névtérállandó meghatározására, amely megegyezik a speciális beépített konstansok nevével, végzetes hibát eredményez.

11. példa Nem definiált állandók

névtér sáv ;
const NULL = 0 ; // Fatális hiba;
const true = "hülye" ; // fatális hiba is;
// stb.
?>

7 évvel ezelőtt

Van mód egy névteres konstans definiálására, ami egy speciális, beépített állandó, define függvény és beállítás segítségével a harmadik paraméter case_insensitive to false:

névtér foo ;
define (__NAMESPACE__ . "\NULL" , 10 ); // a NULL állandó értéket határozza meg az aktuális névtérben


?>

Nem kell megadni a névteret a define() hívásban, ahogy ez általában megtörténik
névtér foo ;
define(INI_ALL , "bar" ); // értesítést készít - Az INI_ALL konstans már definiált. De:

Definiálás (__NAMESPACE__ . "\INI_ALL" , "bar" ); // az INI_ALL konstanst határozza meg az aktuális névtérben
var_dump(INI_ALL); // megjelenik a string(3)"bar". Eddig semmi nem nézett meg. De:

Define("NULL" , 10 ); // a NULL állandó értéket határozza meg az aktuális névtérben...
var_dump(NULL); // 10-et fog mutatni
var_dump(null); // NULL jelenik meg
?>

Ha a kis- és nagybetűket nem érző paraméter igazra van állítva
névtér foo ;
define (__NAMESPACE__ . "\NULL" , 10 , true ); // értesítést produkál - Konstans null már definiálva
?>

3 évvel ezelőtt

osztályok létrehozásakor vagy statikus metódusok hívásakor a névterekből változók használatával, szem előtt kell tartani, hogy a teljes névtérre van szükség ahhoz, hogy a megfelelő osztályt használni lehessen; NEM használhat álnevet vagy rövid nevet, még akkor sem, ha ugyanazon a névtéren belül hívják. Ennek figyelmen kívül hagyása azt eredményezheti, hogy a kód rossz osztályt használ, végzetes hiányzó osztálykivételt dobhat, vagy hibákat vagy figyelmeztetéseket adhat.

Ezekben az esetekben használhatja a __NAMESPACE__ mágikus állandót, vagy közvetlenül megadhatja a teljes névteret és az osztálynevet. A class_exists függvény a teljes névteret és az osztálynevet is megköveteli, és használható annak biztosítására, hogy a hiányzó osztályok ne okozzanak végzetes hibát.

Névtér Foo ;
osztály bár (
nyilvános statikus függvényteszt()(
return get_ched_class();
}
}

névtér Foo \ Foo ;
osztály Bár kiterjed \ Foo \ Bar (
}

Var_dump(Bar::teszt()); // string(11) "Foo\Foo\Bar"

$bar = "Foo\Bar" ;
var_dump($bar::teszt()); // string(7) "Foo\Bar"

$bar = __NAMESPACE__ . "\Rúd" ;
var_dump($bar::teszt()); // string(11) "Foo\Foo\Bar"

$bar = "Bar" ;
var_dump($bar::teszt()); // VÉGZETES HIBA: "Bar" osztály nem található vagy Helytelen osztály \Bar használt

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.