Konstantní přepsání PHP. Konstanty v PHP. K čemu slouží konstanty a není jednodušší používat proměnné?

Konstanty- to jsou hodnoty, které se v průběhu času nemění. I ze školy pravděpodobně znáte mnoho konstant, například číslo P, číslo E, zrychlení volný pád a další. A samozřejmě při programování je také velmi často potřeba zadat konstanty. A o tom jak vytvářet a používat konstanty v PHP, o tom si povíme v tomto článku.

Pojďme s vámi vytvoříme konstantučísla P:

definovat(PI, 3,1415926);
echo PI;
?>

Operátor definovat vytváří konstantní P.I. a přiřadí mu hodnotu 3.1415926 . Dále tuto konstantu vypíšeme přes operátor echo. Vše je velmi jednoduché, nicméně existuje jedno doporučení, které vám radím vždy dodržovat. Určitě napiš konstanty velkými písmeny. Ne že by to bylo nutné, ale vysoce žádoucí. A to je zvykem nejen v PHP, ale i v jiných jazycích.

Samozřejmě později měnit konstantu PI nebude dovoleno (proto ona konstantní).

Nyní se podívejme na jednu funkci, která kontroluje: " Je daná konstanta definována?". Pojďme napsat tento skript:

if (!defined("PI")) define(PI, 3,1415926);
echo PI;
?>

Tady kontroluje existenci konstanty P.I.. A pokud neexistuje (tj funkce define(). vrátil Nepravdivé), pak tuto konstantu inicializujeme. Poté jej jednoduše zobrazíme.

Jak vidíte, vytvořte a používejte své konstanty v PHP- je to velmi jednoduché.

A nakonec bych chtěl mluvit o vestavěné konstanty PHP. Napíšeme jednoduchý skript:

phpinfo();
?>

Na konci je sekce " PHP proměnná„Ve skutečnosti to tak úplně není konstanty však jsou konstanty při provádění tohoto skriptu. Samozřejmě, když je spuštěn další skript, budou mít různé hodnoty (ne všechny, samozřejmě). Vezmeme vás ven jako pár konstanty, abyste pochopili, jak s nimi pracovat, protože se používají neuvěřitelně často:

echo $_SERVER["REMOTE_ADDR"];
echo"
";
echo $_SERVER["QUERY_STRING"];
?>

V tomto skriptu vypíšeme IP adresa uživatele, který spustil skript, a na dalším řádku zobrazíme řetězec dotazu (například " index.php?id=7 Když se podívám trochu dopředu, říkám, že zde pracujeme s globálními pole $_SERVER. S poli se seznámíme později, ale myslím, že kdo pracoval s poli v jiných programovacích jazycích, syntaxi bez problémů rozezná. Pokud jde o ostatní konstanty, pak práce s nimi probíhá stejným způsobem.

Pro každý spuštěný skript. Mnohé z těchto konstant jsou definovány různými moduly a budou přítomny pouze v případě, že jsou tyto moduly dostupné prostřednictvím dynamického načítání nebo statického sestavení.

Existuje devět magických konstant, které mění svůj význam v závislosti na kontextu, ve kterém jsou použity. Například hodnota __ČÁRA__ závisí na řádku ve skriptu, na kterém je tato konstanta zadána. Všechny magické konstanty jsou vyřešeny v době kompilace, na rozdíl od běžných konstant, které jsou vyřešeny za běhu. Speciální konstanty nerozlišují malá a velká písmena a jsou uvedeny níže:

Některé magické konstanty PHP

název	Popis
__ČÁRA__	Aktuální číslo řádku v souboru.
__SOUBOR__	Úplná cesta a název aktuálního souboru s rozšířenými symbolickými odkazy. Pokud je použit uvnitř zahrnutého souboru, vrátí se název tohoto souboru.
__DIR__	Adresář souborů. Pokud se použije uvnitř zahrnutého souboru, vrátí se adresář tohoto souboru. To je ekvivalentní volání dirname(__FILE__). Vrácený název adresáře nekončí lomítkem, s výjimkou kořenového adresáře.
__FUNKCE__	Název funkce popř (uzavření) v případě anonymní funkce.
__TŘÍDA__	Jméno třídy. Tento název obsahuje název jmenného prostoru, ve kterém byla třída deklarována (např. Foo\Bar). Vezměte prosím na vědomí, že od PHP 5.4 __CLASS__ funguje také ve vlastnostech. Při použití v metodách vlastností je __CLASS__ název třídy, ve které jsou metody použity.
__VLASTNOST__	Název vlastnosti. Tento název obsahuje název jmenného prostoru, ve kterém byla vlastnost deklarována (např. Foo\Bar).
__METODA__	Název metody třídy.
__NAMESPACE__	Název aktuálního jmenného prostoru.
ClassName::class	Celé jméno třída (s uvedením jmenného prostoru). Viz také ::třída.

viz také get_class(), get_object_vars(), soubor existuje() A function_exists().

Seznam změn

před 14 lety

Rozdíl mezi
__FUNCTION__ a __METHOD__ jako v PHP 5.0.4 je to

FUNCTION__ vrací pouze název funkce

zatímco jako __METHOD__ vrací název třídy spolu s názvem funkce

třídní trik
{
funkce doit()
{
echo __FUNKCE__;
}
funkce doitagain()
{
echo __METHOD__;
}
}
$obj=nový trik();
$obj->doit();
výstup bude ---- doit
$obj->doitagain();
výstup bude ----- trik::doitagain

před 13 lety

Magická konstanta __CLASS__ pěkně doplňuje funkci get_class().

Někdy potřebuješ znát oba:
- název zděděné třídy
- název třídy, která se skutečně provádí

Zde je příklad, který ukazuje možné řešení:

Třída základní_třída
{
funkce say_a()
{

" ;
}

Funkce say_b()
{

" ;
}

třída odvozená_třída rozšiřuje základní_třídu
{
funkce say_a()
{
rodič::say_a();
echo ""a" - řekl " . __CLASS__ . "
" ;
}

Funkce say_b()
{
rodič::say_b();
echo ""b" - řekl " . get_class($this) . "
" ;
}
}

$obj_b = nová odvozená_třída();

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

?>

Výstup by měl vypadat zhruba takto:

"a" - řekla základní_třída
"a" - řekla odvozená_třída

"b" - řekla odvozená_třída
"b" - řekla odvozená_třída

před 3 lety

Všimněte si malé nekonzistence při použití __CLASS__ a __METHOD__ ve vlastnostech (stand php 7.0.4): Zatímco __CLASS__ funguje tak, jak je inzerováno a dynamicky vrací název třídy, ve které je vlastnost používána, __METHOD__ ve skutečnosti předpíše název vlastnosti namísto jméno třídy!

před 8 lety

Neexistuje žádný způsob, jak implementovat zpětně kompatibilní __DIR__ ve verzích před 5.3.0.

Jediná věc, kterou můžete udělat, je provést rekurzivní vyhledávání a nahradit ho dirname(__FILE__):
najít . -typ f -tisk0 | xargs -0 sed -i "s/__DIR__/dirname(__FILE__)/"

před 5 lety

Mnoho poznámek se týká definování magické konstanty __DIR__ pro verze PHP, které tuto funkci nepodporují. Samozřejmě můžete definovat tuto magickou konstantu pro verze PHP, které tuto konstantu ještě nemají, ale ztratí svůj účel, jakmile konstantu použijete v přiloženém souboru, který může být v jiném adresáři než soubor definující konstantu __DIR__ . Konstanta jako taková ztratila své *kouzlo* a byla by spíše k ničemu, pokud se nezajistíte, že budete mít všechna vaše zahrnutí ve stejném adresáři.

Na závěr: poznámka na gmail dot com ohledně toho, zda můžete nebo nemůžete definovat magické konstanty, je platná, ale tvrzení, že definování __DIR__ není zbytečné, není!

před 7 lety

Nemůžete zkontrolovat, zda je definována magická konstanta. To znamená, že nemá smysl kontrolovat, zda je __DIR__ definován, a poté jej definovat. `defined("__DIR__")` vždy vrátí hodnotu false. Definování __DIR__ v PHP 5.3+ tiše selže. To může způsobit problémy s kompatibilitou, pokud váš skript obsahuje jiné skripty.

echo (definováno ("__DIR__" ) ? "__DIR__ je definováno" : "__DIR__ NENÍ definováno" . PHP_EOL );
echo (definováno ("__FILE__" ) ? "__FILE__ je definováno" : "__FILE__ NENÍ definováno" . PHP_EOL );
echo (definováno ("PHP_VERSION" ) ? "PHP_VERSION je definováno" : "PHP_VERSION NENÍ definováno" ) . PHP_EOL ;
echo "Verze PHP: " . PHP_VERSION. PHP_EOL ;
?>
Výstup:
__DIR__ NENÍ definován
__FILE__ NENÍ definován
PHP_VERSION je definováno
Verze PHP: 5.3.6

Poslední aktualizace: 1.11.2015

Konstanty, stejně jako proměnné, ukládají konkrétní hodnotu, ale na rozdíl od proměnných lze hodnotu konstant nastavit pouze jednou a pak ji nemůžeme změnit. Definujme například číselnou konstantu:

Chcete-li definovat konstantu, použijte operátor define, který má následující tvar: define(řetězec $jméno, řetězec $hodnota, bool $case_sen=false) . Parametr $name vyjadřuje název konstanty a parametr $value její hodnotu. Třetí volitelný parametr má logickou hodnotu skutečný nebo nepravdivý. Je-li hodnota nepravda, pak se při použití konstanty bude brát v úvahu její případ, je-li pravdivý, případ se nebere v úvahu. V našem případě se třetí parametr nepoužívá, takže je ve výchozím nastavení false.

Po definování konstanty ji můžeme použít stejně jako běžnou proměnnou. Jedinou výjimkou je, že nebudeme moci změnit jeho hodnotu. Dalším rozdílem u proměnné je, že nemusíte používat znak $. Tedy výraz ČÍSLO=33; nebude fungovat.

Předdefinované konstanty

Kromě konstant vytvořených programátorem má PHP několik vestavěných konstant:

FILE__ : ukládá úplnou cestu a název aktuálního souboru

LINE__ : ukládá aktuální číslo řádku, které interpret zpracovává

DIR__: ukládá adresář aktuálního souboru

FUNCTION__ : název zpracovávané funkce

CLASS__ : název aktuální třídy

METHOD__ : název zpracovávané metody

NAMESPACE__ : název aktuálního jmenného prostoru

Vytiskněme například aktuální spouštěný řádek a název souboru:

Kontrola existence konstanty

Pro kontrolu, zda je konstanta definována, můžeme použít funkci bool define(string $name). Pokud je definována konstanta $name, funkce vrátí hodnotu true

Konstanta je identifikátor (název) jednoduché hodnoty. Jak název napovídá, jejich hodnota se během provádění skriptu nemůže změnit (kromě magických konstant, které ve skutečnosti konstanty nejsou). V názvech konstant se ve výchozím nastavení rozlišují velká a malá písmena. Podle konvence jsou jména konstant vždy psána velkými písmeny.

Název konstanty se musí řídit stejnými konvencemi pro pojmenování jako ostatní názvy v PHP. Platný název začíná písmenem nebo podtržítkem následovaným libovolným počtem písmen, číslic a podtržítek. Regulární výraz pro kontrolu správnosti názvu konstanty vypadá takto: ^*$

Pomocí funkce je možné definovat konstanty definovat() vyhrazená nebo dokonce neplatná jména, jejichž hodnoty lze (pouze) získat pomocí funkce konstantní(). To se však nedoporučuje.

Příklad č. 1 Správné a nesprávné názvy konstant

// Opravte názvy konstant
definovat ("FOO" , "něco" );
definovat ("FOO2" , "něco jiného" );
definovat ("FOO_BAR" , "něco víc" );

// Nesprávné názvy konstant
definovat ("2FOO" , "něco" );

// Toto je platná deklarace, ale je lepší ji nepoužívat:
// PHP může jednoho dne zaregistrovat magickou konstantu,
// což poruší skript
definovat ("__FOO__" , "něco");

Komentář: Koncept „písmen“ zde je znaky a-z, A-Z a další znaky s kódy ASCII od 128 do 255 (0x80-0xff).

Před 2 roky

Výkon konstant. PHP 7.1.10 32 bitů (Opcache aktivní, Windows 10 i7-64bits), ale zdá se, že trendy jsou stejné s 5.x

pomocí konstanty deklarované pomocí DEFINE("CNS",hodnota): 0,63575601577759s
pomocí konstanty deklarované const CNS=hodnota: 0,61372208595276s
pomocí proměnné deklarované pomocí $v=value: 0,51184010505676s

V průměru je použití DEFINE a CONST přibližně stejné s poněkud lepším výkonem CONST místo DEFINE. Použití proměnné je však o 10–50 % lepší než použití konstanty. Pro úkoly náročné na výkon tedy konstanta není tou nejlepší volbou.

$p1=mikročas(true);
$x=0;
for($i=0;$i<50000000;$i++) {
$x+=CNS;
}
$p2=mikročas(true);

před 14 lety

Nedefinovaná konstanta se vyhodnotí jako pravdivá, není-li použita správně. Řekněte například, že jste měli něco takového:

nastavení.php
// Debugovací mód
definovat ("DEBUG" , false );
?>

test.php
include("nastavení.php" );

if (LADIT) (
// echo nějaká citlivá data.
}
?>

Pokud z nějakého důvodu není settings.php zahrnuto a konstanta DEBUG není nastavena, PHP STÁLE vytiskne citlivá data. Řešením je vyhodnotit je. Třeba takto:

nastavení.php
// Debugovací mód
definovat ("DEBUG" , 0 );
?>

test.php
include("nastavení.php" );

if (LADĚNÍ == 1) (
// echo nějaká citlivá data.
}
?>

Nyní to funguje správně.

V tomto příspěvku zjistíme, v čem je rozdíl PHP reklama konstanty pomocí klíčového slova const a funkce define().

Konstanty v PHP jsou „konstanty“, jejichž hodnoty jsou zadány pouze jednou a poté je nelze změnit. Pokud se pokusíte změnit hodnotu, nezmění se a objeví se poznámka PHP: „Konstanta již definována“:

Define("FOO", "val"); define("FOO", "val2"); // Upozornění: Konstanta již definovaná echo FOO; //> val

Existují dva způsoby, jak deklarovat konstanty v PHP:

// 1 define("NAME", "VALUE"); // 2 const NAME = "VALUE";

Každá metoda má své vlastnosti, abychom jim porozuměli, podívejme se na vše krok za krokem, jak a co se s jednotlivými verzemi PHP změnilo.

Jak vytvořit konstanty

PHP nižší než 5.3

Před verzí 5.3 v PHP bylo možné konstanty definovat pouze pomocí define() . Klíčové slovo const se objevilo ve verzi 5.3.

Pouze skaláry mohou ukládat konstanty. Skalární proměnné jsou proměnné typu integer, float, string a boolean. Typy pole, objektů a prostředků nejsou skalární.

// skaláry definovat("FOO", 10); define("FOO", 10.9); define("FOO", "val"); define("FOO", true); // ne skaláry definovat("FOO", pole(1)); // konstanta není nastavena a dostáváme Warning define("FOO", (object) array(1)); // konstanta není nastavena a dostáváme Varování

Od PHP 5.3

Objevil se klíčové slovo const a nyní lze pomocí něj definovat také konstantu.

Nemůžete však zadat proměnnou, funkci nebo nějaký druh výrazu v const, ale musíte předat skalár „přímo“:

Const FOO = "val"; // žádné chyby const FOO = $var; // Chyba analýzy const FOO = home_url(); // Chyba analýzy const FOO = 5 + 10; // Chyba analýzy const FOO = "foo"."bar"; // Chyba analýzy

Zatímco pro define() žádná taková omezení neexistují...

Define("FOO", "val"); // žádné chyby definovat("FOO", $var); // žádné chyby define("FOO", home_url()); // žádné chyby definovat("FOO", 5 + 10); // no errors define("FOO", "foo"."bar"); // bez chyb

PHP 5.6

Stalo se možné specifikovat primitivní PHP výrazy (výrazy ze skalárů) jako konstantní hodnoty:

Const FOO = 1 + 2; const FOO = "foo" . "bar";

Bylo možné ukládat pole do konstant:

Const FOO = ; // funguje definovat("FOO", ); // nefunguje v PHP 5.6, funguje v PHP 7.0

Rozdíl mezi define() a const

#1 const musí být deklarován v horní oblasti

Na rozdíl od define() musí být const deklarován úplně nahoře v rozsahu, protože jsou definovány při kompilaci skriptu. To znamená, že je nelze deklarovat uvnitř příkazů funkcí/loops/if nebo try/catch bloků.

If (1) ( const NAME = "VALUE"; // nefunguje ) // ale if (1) ( define("NAME", "VALUE"); // funguje )

#2 const vždy rozlišuje velká a malá písmena

const vždy rozlišuje malá a velká písmena, zatímco define() umožňuje vytvářet konstanty bez ohledu na velikost písmen:

Define("NAME", "VALUE", true); echo JMÉNO; // VALUE název echa; // HODNOTA

#3 const rozumí pouze skalárům

Toto platí pouze pro PHP verze 5.6 a nižší...

const nelze předat proměnným, funkcím, výrazům, ale define() může být:

Const FOO = $var; // Chyba analýzy const FOO = home_url(); // Chyba analýzy define("FOO", $var); // žádné chyby define("FOO", home_url()); // bez chyb

#4 const může ukládat pole od PHP 5.6 a definovat od PHP 7.0

const FOO = ; // funguje v PHP 5.6 define("FOO", ); // nefunguje v PHP 5.6, funguje v PHP 7.0

Výsledky srovnání

Téměř vždy je lepší definovat konstantu pomocí define() , protože existuje více možností a méně možností, jak „chytit“ chybu... Výjimkou je situace, kdy máte PHP 5.6 a potřebujete pole uložit do konstanty, zde pomůže const.

Konstanty třídy PHP

Jsou deklarovány pouze pomocí const . Pravidla pro ně jsou taková, jaká byla popsána výše: přijímají pouze skaláry, nerozumí PHP proměnným, funkcím, výrazům...

Konstanty třídy jsou vždy veřejné – neexistuje žádný soukromý nebo chráněný stav.

Deklarovaná konstanta patří specificky do třídy, nepatří k žádnému objektu a je společná všem objektům (instancím) třídy.

Třída My_Class ( const NAME = "VALUE"; // počínaje PHP 5.6 můžete použít matematické výrazy const SEC_PER_DAY = 60 * 60 * 24; funkce print_name() ( // přístup ke konstantě třídy uvnitř metody přes self (samotná třída ) echo self ::NAME ) ) // přístup ke konstantě mimo třídu // lze volat z globálního rozsahu bez inicializace instance třídy echo My_Class::NAME;

Třídní konstanty jsou velmi podobné vlastnostem statických tříd.

Třída Moje_třída ( const NAME = "VALUE"; static $name = "VALUE";; ) echo My_Class::NAME; echo My_Class::$name;

"Magické" konstanty

A na závěr si připomeňme speciální PHP konstanty...

PHP má devět magických konstant, které mění svůj význam v závislosti na kontextu, ve kterém jsou použity. Například hodnota __LINE__ závisí na řádku ve skriptu, na kterém je tato konstanta zadána. Všechny "magické" konstanty jsou vyřešeny v době kompilace, na rozdíl od běžných konstant, které jsou vyřešeny za běhu. Speciální konstanty nerozlišují malá a velká písmena a jsou uvedeny níže:

Konstantní	Popis
__ČÁRA__	Aktuální číslo řádku v souboru.
__SOUBOR__	Úplná cesta a název aktuálního souboru, ve kterém je konstanta volána.
__DIR__	PHP 5.3.0. Adresář souboru, ve kterém je konstanta použita. Stejné jako dirname(__FILE__) . Nemá koncové lomítko, s výjimkou kořenového adresáře.
__FUNKCE__	Název funkce.
__TŘÍDA__	Jméno třídy. Tento název obsahuje název oboru názvů, ve kterém byla třída deklarována (například Foo\Bar). Funguje také ve vlastnostech. Při použití v metodách vlastností se jedná o název třídy, ve které jsou tyto metody použity.
__VLASTNOST__	PHP 5.4.0. Název vlastnosti. Tento název obsahuje název jmenného prostoru, ve kterém byla vlastnost deklarována (například Foo\Bar).
__METODA__	Název metody třídy.
__NAMESPACE__	PHP 5.3.0. Název aktuálního jmenného prostoru.
ClassName::class	PHP 5.5.0. Celý název třídy (včetně jmenného prostoru). Viz také::třída.