Magické metody a předdefinované konstanty v PHP. Vytváření konstant v PHP - const a define() #3 const rozumí pouze skalárům
Dobrý den všem. Alexey Gulynin je v kontaktu. V minulém článku jsme se podívali ekvivalentní operátor v PHP. V tomto článku bych chtěl mluvit o konstanty v PHP. Ve škole jste se často setkávali s konstantami, například s „číslem PI“ nebo z fyziky s univerzální plynovou konstantou (R). Konstanty jsou definovány jednou a už se nemění. Totéž platí pro konstanty v programování, tzn. konstantu definujeme jednou a nikdy se v kódu programu nemění. Konstanty mohou být různé matematické hodnoty, cesty k souborům.
Jak se liší konstanta od proměnné:
1) Je definován jednou a nelze mu přiřadit hodnotu nikde jinde,
2) Chcete-li na ni odkazovat, nemusíte před ni dávat znak „$“ (zde je mínus - nyní nemůžeme použít název konstanty v textovém řetězci).
Vytiskneme konstantu "PI":
Existují dva typy konstant: definované interpretem a uživatelem:
Příklady konstant definovaných interpretem:
1) __FILE__ - ukládá název souboru, který obsahuje kód, který se právě provádí,
2) PHP_VERSION - verze PHP interpretu,
3) PHP_OS - verze operačního systému, pod kterým PHP běží.
Zadejte následující kód a podívejte se, jaké další konstanty existují:
Můžete definovat své vlastní konstanty, to se provádí pomocí operátoru define. Definujme 2 konstanty:
"; echo Const2; ?>
V tomto případě zobrazíme hodnoty těchto konstant.
Ve výchozím nastavení se v názvu konstanty rozlišují velká a malá písmena; lze jej zakázat pomocí volitelného třetího parametru, jako je tento:
"; echo NEW1; ?>
Uvidíte, že vše funguje (v předchozím příkladu to fungovat nebude, protože se rozlišují velká a malá písmena).
Pozor na uvozovky, ve kterých je napsáno jméno konstanty. To je třeba udělat. Také nelze vytvořit konstanty se stejnými názvy.
V PHP můžete pomocí funkce zkontrolovat, zda konstanta existuje nebo ne definovaný (konstantní název). Podívejme se na příklad, aby bylo jasno:
Napište tento příklad a uvidíte, co se stane.
(PHP 5 >= 5.3.0, PHP 7)
Tento seznam otázek je rozdělen do dvou částí: obecné otázky a některá specifika implementace, která jsou užitečná pro úplnější pochopení.
Nejprve obecné otázky.
- Pokud jmenné prostory nepoužívám, mělo by se něco z toho považovat za důležité?
- Jak mohu použít vnitřní nebo globální třídy ve jmenném prostoru?
- Jak mohu použít funkce třídy ve jmenných prostorech nebo konstanty v jejich vlastním jmenném prostoru?
- Jak je takové jméno \moje jméno nebo \název přeměněn?
- Jako jméno jako moje jméno přeměněn?
- Jako nekvalifikovaný název třídy, jako např název přeměněn?
- Jako nekvalifikovaný název funkce nebo nekvalifikovaný název konstanty, jako je např název přeměněn?
Některé podrobnosti implementace jmenného prostoru, které je užitečné pochopit.
- Importované názvy nemohou být v konfliktu s třídami definovanými ve stejném souboru.
- Pomocí operátoru nelze importovat funkce ani konstanty použití.
- Názvy dynamických jmenných prostorů (identifikátory uzavřené v uvozovkách) musí obsahovat znak zpětného lomítka.
- Nelze odkazovat na nedefinované konstanty pomocí zpětného lomítka. Zobrazí se kritická chyba
- Není možné přepsat speciální konstanty jako NULL, TRUE, FALSE, ZEND_THREAD_SAFE nebo ZEND_DEBUG_BUILD
Pokud jmenné prostory nepoužívám, mělo by se něco z toho považovat za důležité?
Ne. Jmenné prostory nemají žádný vliv na jakýkoli existující kód v jakékoli formě nebo na jakýkoli napsaný kód, který neobsahuje jmenné prostory. Pokud chcete, můžete napsat kód takto:
Příklad č. 1 Přístup ke globálním třídám mimo jmenné prostory
$a = new \ stdClass ;
?>
To je funkčně ekvivalentní následujícímu:
Příklad č. 2 Přístup ke globálním třídám mimo jmenné prostory
$a = nová stdClass ;
?>
Jak mohu použít vnitřní nebo globální třídy ve jmenném prostoru?
Příklad č. 3 Přístup k vnitřním třídám ve jmenných prostorech
jmenný prostor foo ;
$a = new \ stdClass ;
test funkce (\ArrayObject $type hintexample = null ) ()
$a = \ DirectoryIterator :: CURRENT_AS_FILEINFO ;
// rozšíření interní nebo globální třídy
třída MyException extends\Exception()
?>
Jak mohu používat funkce třídy ve jmenných prostorech nebo konstanty v jejich vlastním jmenném prostoru?
Příklad č. 4 Přístup k vnitřním třídám, funkcím nebo konstantám ve jmenných prostorech
jmenný prostor foo ;
třída MyClass()
// použijte třídu z aktuálního jmenného prostoru
funkční test (MyClass $type hintexample = null ) ()
// jiný způsob použití třídy z aktuálního jmenného prostoru
test funkce (\foo\MyClass $typehintexample = null)()
// rozšíření třídy z aktuálního jmenného prostoru
class Extended rozšiřuje MyClass()
// přístup ke globální funkci
$a = \globalfunc();
// přístup ke globální konstantě
$b = \INI_ALL ;
?>
Jak je takové jméno \moje jméno nebo \název přeměněn?
Jména začínající na \ jsou vždy převedeny na to, jak vypadají, tzn. \moje jméno- to je vlastně moje jméno, A \Výjimka- Tento Výjimka.
Příklad č. 5 Absolutní jména
jmenný prostor foo ;
$a = new \ my \ name (); // vytvoří instanci třídy "my\name"
echo\strlen("ahoj"); // volá funkci "strlen".
$a = \INI_ALL ; // proměnné $a je přiřazena hodnota konstanty "INI_ALL"
?>
Jako jméno jako moje jméno přeměněn?
Jména, která obsahují zpětné lomítko, ale nezačínají jedním, jako např moje jméno
můj jiné jméno, pak toto synonymum platí můj PROTI moje jméno.
moje jméno.
Příklad č. 6 Celá jména
jmenný prostor foo ;
použít bla \ bla jako foo;
$a = new my\name(); // vytvoří instanci třídy "foo\my\name"
foo\bar::name(); // volá statickou metodu "name" ve třídě "blah\blah\bar"
my\bar(); // volá funkci "foo\my\bar"
$a = můj\BAR; // přiřadí proměnné $a hodnotu konstanty "foo\my\BAR"
?>
Jako nekvalifikovaný název třídy, jako např název přeměněn?
Názvy tříd, které neobsahují zpětné lomítko, jako např název lze převést dvěma různými způsoby.
Pokud existuje importující výraz, který vytváří synonymum název jiné jméno, pak se použije toto synonymum.
Jinak se aktuální název jmenného prostoru stane předponou pro moje jméno.
Příklad č. 7 Nekvalifikované názvy tříd
jmenný prostor foo ;
použít bla \ bla jako foo;
$a = nové jméno(); // vytvoří instanci třídy "foo\name"
foo::name(); // volá statickou metodu "name" ve třídě "bla\blah"
?>
Jako nekvalifikovaný název funkce nebo nekvalifikovaný název konstanty, jako je např název přeměněn?
Názvy funkcí nebo konstant, které neobsahují zpětné lomítko, jako např název lze převést dvěma různými způsoby.
Nejprve má předponu aktuální název jmenného prostoru název.
Pak je-li konstanta nebo funkce název neexistuje v aktuálním jmenném prostoru pomocí globální konstanty nebo funkce název, pokud existuje.
Příklad č. 8 Neúplné názvy funkcí nebo konstant
jmenný prostor foo ;
použít bla \ bla jako foo;
const FOO = 1;
funkce my()()
funkce foo()()
řazení funkcí (& $a )
{
\sort($a); // volá globální funkci "sort"
$a = array_flip($a);
vrátit $a ;
}
Můj(); // volá "foo\my"
$a = strlen("ahoj"); // volá globální funkci "strlen", protože "foo\strlen" neexistuje
$arr = pole(1, 3, 2);
$b = sort($arr); // volá funkci "foo\sort"
$c = foo(); // volá funkci "foo\foo" - import se nepoužije
$a = FOO ; // přiřadí proměnné $a hodnotu konstanty "foo\FOO" - import se nepoužije
$b = INI_ALL ; // přiřadí proměnné $b hodnotu globální konstanty "INI_ALL"
?>
Importované názvy nemohou být v konfliktu s třídami definovanými ve stejném souboru.
Platné jsou následující kombinace skriptů:
jmenný prostor my\věci;
třída MyClass()
?>
jmenný prostor jiný ;
třídní věc()
?>
jmenný prostor my\věci;
zahrnout "soubor1.php" ;
zahrnout "jiný.php" ;
$a = new MyClass ; // vytvoří instanci třídy "thing" ze jmenného prostoru "jiný"
?>
Neexistuje žádný konflikt jmen, i když třída Moje třída existuje uvnitř jmenného prostoru moje věci protože definice MyClass je v samostatném souboru. Následující příklad však způsobí závažnou chybu konfliktu názvů, protože třída MyClass je definována ve stejném souboru, kde je umístěn příkaz use.
jmenný prostor my\věci;
použijte jinou \ věc jako MyClass ;
třída MyClass() // závažná chyba: Moje třída je v konfliktu s výrazem importu
$a = new MyClass ;
?>
Vnořené jmenné prostory nejsou povoleny.
PHP neumožňuje vnořování jmenných prostorů do sebe
jmenný prostor moje\věci(
vnořený jmenný prostor (
třída foo()
}
}
?>
Chcete-li však simulovat vnořené jmenné prostory, jako je tento:
jmenný prostor moje\věci\vnořené (
třída foo()
}
?>
Před PHP 5.6 nebylo možné pomocí operátoru importovat funkce ani konstanty použití.
Před PHP 5.6 jsou jediné prvky, které jsou ovlivněny operátorem použití jsou jmenné prostory a názvy tříd. Chcete-li zkrátit dlouhé názvy konstant nebo funkcí, importujte jejich obsah do jmenného prostoru.
jmenný prostor důl ;
použijte ultra\long\ns\name;
$a = jméno \ KONSTANTNÍ ;
jmeno\func();
?>
Od PHP 5.6 je možné importovat a vytvářet aliasy pro funkce a názvy konstant.
Názvy dynamických jmenných prostorů (identifikátory uzavřené v uvozovkách) musí obsahovat znak zpětného lomítka.
Je velmi důležité to reprezentovat, protože zpětné lomítko se používá jako znak escape uvnitř řetězců. Při použití v řetězci by měl být vždy duplikován, jinak hrozí nezamýšlené následky:
Příklad č. 9 Úskalí při použití názvu jmenného prostoru uvnitř řetězce s dvojitými uvozovkami
$a = "nebezpečné\jméno" ; // \n je nový řádek v řetězci s dvojitými uvozovkami!
$obj = nový $a ;
$a = "ne\at\all\nebezpečné" ; // tady není problém.
$obj = nový $a ;
?>
V rámci řetězců v jednoduchých uvozovkách je zpětné lomítko jako oddělovač bezpečnější, ale doporučený postup escapování zpětného lomítka ve všech řetězcích je stále nejlepší.
Nelze odkazovat na nedefinované konstanty pomocí zpětného lomítka. Zobrazí se kritická chyba
Jakákoli nedefinovaná konstanta, která je nekvalifikovaným názvem, jako např FOO, bude mít za následek zprávu o tom, že to PHP předpokládalo FOO byla hodnota konstanty. Jakákoli konstanta s kvalifikovaným nebo absolutním názvem, která obsahuje znak zpětného lomítka, bude mít za následek závažnou chybu, pokud nebude nalezena.
Příklad č. 10 Nedefinované konstanty
pruh jmenného prostoru;
$a = FOO ; // zobrazí varování: nedefinované konstanty "FOO" předpokládá "FOO";
$a = \FOO ; // závažná chyba: nedefinovaná konstanta jmenného prostoru FOO
$a = Bar\FOO; // fatální chyba: nedefinovaný jmenný prostor konstantní bar\Bar\FOO
$a = \Bar \FOO ; // závažná chyba: nedefinovaná konstanta jmenného prostoru Bar\FOO
?>
Není možné přepsat speciální konstanty jako NULL, TRUE, FALSE, ZEND_THREAD_SAFE nebo ZEND_DEBUG_BUILD
Jakýkoli pokus o definování konstanty jmenného prostoru, která se shoduje s názvy speciálních vestavěných konstant, bude mít za následek závažnou chybu.
Příklad č. 11 Nedefinované konstanty
pruh jmenného prostoru;
const NULL = 0 ; // Fatální chyba;
const true = "hloupý" ; // také fatální chyba;
// atd.
?>
před 7 lety
Existuje způsob, jak definovat jmennou konstantu, která je speciální, vestavěnou konstantou, pomocí funkce define a nastavením třetího parametru case_insensitive na hodnotu false:
jmenný prostor foo ;
definovat (__NAMESPACE__ . "\NULL" , 10 ); // definuje konstantu NULL v aktuálním jmenném prostoru
?>
Není třeba zadávat jmenný prostor ve vašem volání define(), jak se to obvykle stává
jmenný prostor foo ;
define(INI_ALL, "bar"); // vytvoří upozornění - Konstanta INI_ALL je již definována. Ale:
Definovat (__NAMESPACE__ . "\INI_ALL" , "bar" ); // definuje konstantu INI_ALL v aktuálním jmenném prostoru
var_dump(INI_ALL); // zobrazí string(3)"bar". Zatím nic nekontrolovaného. Ale:
Define("NULL", 10); // definuje konstantu NULL v aktuálním jmenném prostoru...
var_dump(NULL); // zobrazí 10
var_dump(null); // zobrazí NULL
?>
Pokud je parametr case_insensitive nastaven na hodnotu true
jmenný prostor foo ;
definovat (__NAMESPACE__ . "\NULL" , 10 , true ); // vytvoří upozornění - Konstanta null je již definována
?>
před 3 lety
Při vytváření tříd nebo volání statických metod ze jmenných prostorů pomocí proměnných musíte mít na paměti, že vyžadují úplný jmenný prostor, aby mohla být použita příslušná třída; NEMŮŽETE použít alias nebo krátké jméno, i když je voláno ve stejném jmenném prostoru. Zanedbání tohoto zohlednění může způsobit, že váš kód použije špatnou třídu, vyvolá závažnou výjimku chybějící třídy nebo vyvolá chyby či varování.
V těchto případech můžete použít magickou konstantu __NAMESPACE__ nebo zadat přímo celý jmenný prostor a název třídy. Funkce class_exists také vyžaduje úplný jmenný prostor a název třídy a lze ji použít k zajištění toho, že kvůli chybějícím třídám nebude vyvolána závažná chyba.
jmenný prostor foo ;
třída bar (
veřejný test statické funkce() (
return get_known_class();
}
}
jmenný prostor Foo\Foo;
class Bar rozšiřuje \Foo \Bar (
}
Var_dump(Bar::test()); // string(11) "Foo\Foo\Bar"
$bar = "Foo\Bar" ;
var_dump($bar::test()); // string(7) "Foo\Bar"
$bar = __NAMESPACE__ . "\Bar" ;
var_dump($bar::test()); // string(11) "Foo\Foo\Bar"
$bar = "Bar" ;
var_dump($bar::test()); // FATAL ERROR: Třída "Bar" nebyla nalezena nebo byla použita nesprávná třída \Bar
V této poznámce budeme hovořit o konstantách. Jako obvykle se podívejme na samotný koncept konstant v programovacích jazycích a podívejme se, jak jsou deklarovány a používány konstanty v PHP.
Koncept konstanty a konstant v PHP
Slovo konstanta by vám již mělo být známé z matematiky:
"Matematická konstanta."- veličina, jejíž hodnota se nemění."
V PHP je to stejné. Konstanta v PHP je identifikátor, který slouží k označení jednoduché hodnoty (řetězec, nějaké číslo), která se nemůže během provádění kódu změnit.
Chcete-li deklarovat konstantu (přiřadit jí hodnotu), použijte funkci definovat. Příklad deklarace konstanty:
Konstantní názvy v PHP rozlišují velká a malá písmena (velká a malá písmena se liší), takže musíte být opatrní. Existuje také konvence, že názvy konstant jsou vždy psány velkými písmeny.
Název konstanty musí začínat písmenem nebo podtržítkem „_“ a může se skládat z písmen, číslic a podtržítek.
Podívejme se na jednoduchý příklad použití konstanty:
V tomto příkladu jsme deklarovali konstantu a použili ji v programu.
K čemu slouží konstanty a není jednodušší použít proměnné?
Jak již bylo zmíněno, konstanty nemohou měnit své hodnoty během provádění programu. Konstanty obvykle ukládají trvalé parametry webu, jako jsou podrobnosti o přístupu k databázi (hostitel, uživatelské jméno a heslo, název databáze), umístění webu na disku a mnoho dalších nastavení.
Pokud použijeme proměnné, skript může náhodně (v případě chyby) změnit hodnotu proměnné a nebude fungovat tak, jak jste zamýšleli.
Použití konstant zajistí, že hodnota, kterou zadáte při deklaraci konstanty, zůstane nezměněna.
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 přebírá booleovskou hodnotu true nebo false . Pokud je hodnota nepravda, pak se při použití konstanty bude brát v úvahu její velikost, pokud je pravda, velikost písmen 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
Konstanty jsou identifikátory (názvy) jednoduchých hodnot. Podle jejich názvu lze snadno pochopit, že se jejich hodnota nemůže během provádění skriptu měnit (výjimkou jsou „magické“ konstanty, které vlastně nejsou konstanty v plném slova smyslu). Konstantní názvy 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 pravidly jako ostatní názvy v PHP. Platný název začíná písmenem nebo podtržítkem a skládá se z písmen, číslic a podtržítek. Regulární výraz pro kontrolu správnosti názvu konstanty vypadá takto: *
Komentář: Konceptem „písmen“ jsou zde znaky a-z, A-Z a další znaky s kódy ASCII od 127 do 255 (0x7f-0xff).
Syntax
Konstantu můžete definovat pomocí funkce define() nebo pomocí klíčového slova konst mimo deklaraci třídy od PHP 5.3.0. Jakmile je konstanta definována, nelze její hodnotu změnit ani zneplatnit.
Konstanty mohou obsahovat pouze skalární data (typy boolean, integer, float a string). Je také možné definovat konstanty typu , ale tomu je třeba se vyhnout, protože to může vést k neočekávaným výsledkům.
Hodnotu konstanty můžete získat zadáním jejího názvu. Na rozdíl od proměnných vy není třeba před název konstanty symbol $ . Pokud dynamicky generujete název konstanty, můžete také použít funkci Constant() k získání hodnoty konstanty. Pomocí funkce get_defined_constants() získáte seznam všech deklarovaných konstant.
Komentář: Konstanty a (globální) proměnné jsou v různých jmenných prostorech. To znamená, že např. SKUTEČNÝ a $TRUE jsou úplně jiné věci.
Pokud použijete nedefinovanou konstantu, PHP předpokládá, že máte na mysli jméno konstanty, jako byste zadali řetězcový literál (CONSTANT místo "CONSTANT"). Tím se vygeneruje chyba úrovně E_NOTICE. Viz také kapitola manuálu, která vysvětluje, proč je $foo špatně (pokud jste to samozřejmě nedeklarovali jako první). bar jako konstantu pomocí define()). Pokud chcete pouze zkontrolovat, zda je konstanta definována, použijte funkci define().
Rozdíly mezi konstantami a proměnnými:
- Konstanty nemají předponu znaku dolaru ( $ );
- Konstanty lze definovat pouze pomocí funkce define(), nikoli přiřazením hodnoty;
- Konstanty lze definovat a přistupovat k nim kdekoli bez ohledu na rozsah;
- Konstanty nelze předefinovat nebo zrušit po jejich počáteční deklaraci; A
- Konstanty mohou mít pouze skalární hodnoty.
"Magické" konstanty
PHP poskytuje velký seznam předdefinovaných konstant pro každý skript, který spustíte. 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 sedm 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. Speciální konstanty nerozlišují malá a velká písmena a jsou uvedeny níže:
| název | Popis |
|---|---|
| __ČÁRA__ | Aktuální číslo řádku v souboru. |
| __SOUBOR__ | Úplná cesta a název aktuálního souboru. Pokud je použit uvnitř zahrnutého souboru, vrátí se název tohoto souboru. Od verze PHP 4.0.2, __SOUBOR__ vždy obsahuje absolutní cestu s povolenými symbolickými odkazy, zatímco starší verze by za určitých okolností vracely relativní cestu. |
| __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 (přidáno v PHP 5.3.0.) |
| __FUNKCE__ | Název funkce. (Přidáno v PHP 4.3.0.) Od PHP 5 tato konstanta vrací název funkce přesně tak, jak byl deklarován (rozlišují se malá a velká písmena). V PHP 4 byla tato hodnota vždy malá. |
| __TŘÍDA__ | Jméno třídy. (Přidáno v PHP 4.3.0) Od PHP 5 tato konstanta vrací název třídy přesně tak, jak byl deklarován (rozlišují se malá a velká písmena). V PHP 4 byla tato hodnota vždy malá. Název třídy 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 PHP5.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. (Přidáno v PHP 5.4.0) Od PHP 5.4 tato konstanta vrací název vlastnosti přesně tak, jak byl deklarován (rozlišují se malá a velká písmena). Tento název obsahuje jmenný prostor, ve kterém byla vlastnost deklarována (např. Foo\Bar). |
| __METODA__ | Název metody třídy. (Přidáno v PHP 5.0.0) Název metody je vrácen tak, jak byl deklarován (rozlišuje se malá a velká písmena). |
| __NAMESPACE__ | Název aktuálního jmenného prostoru (rozlišují se malá a velká písmena). Tato konstanta je určena v době kompilace (Přidáno v PHP 5.3.0). |
