Константы классов в ООП на PHP
Сейчас мы с вами разберем классов. Константы по сути являются свойствами, значения которых нельзя изменить. Неизменяемые свойства нужны для того, чтобы хранить какие-то значения, которые являются постоянными и не должны быть случайно изменены.
Чтобы создать константу, ее нужно объявить через ключевое слово const , затем написать имя константы без доллара и обязательно сразу же задать ее значение:
Общепринято имена констант писать большими буквами, то есть не constant , а CONSTANT . Это делается для того, чтобы визуально легко было отличать константы в коде.
Давайте поправим наш класс:
Давайте теперь рассмотрим, как прочитать значения константы. Здесь следует сказать то, что константы класса больше похожи не на обычные свойства, а на статические.
Это значит, что константы класса задаются один раз для всего класса, а не отдельно для каждого объекта этого класса.
Поэтому обращение к константам происходит почти так же, как и для статических свойств: пишем имя класса, два двоеточия и название константы без доллара перед именем:
Как уже упоминалось выше, значения констант можно прочитывать, но не записывать. Попытка что-то записать в нее выдаст ошибку:
Обращение к константам внутри класса
Внутри класса также можно обратится к константе через ::self , вот так:
Воспользуемся нашим методом:
Применение
Давайте сделаем класс Circle , с помощью которого можно будет найти площадь круга и длину окружности. Для работы с кругом нам понадобится число Пи, равное 3.14 . Логично будет для хранения этого числа использовать константу, чтобы случайно где-нибудь в коде наше число Пи вдруг не поменялось.
Вот частичная реализация нашего класса:
Реализуйте предложенный класс Circle самостоятельно.
С помощью написанного класса Circle найдите длину окружности и площадь круга с радиусом 10 .
Объявить константу php в классе
Константы также могут быть объявлены в пределах одного класса. Область видимости констант по умолчанию public .
Замечание:
Константы класса могут быть переопределены дочерним классом. Начиная с PHP 8.1.0, константы класса не могут быть переопределены дочерним классом, если он определён как окончательный (final).
Интерфейсы также могут содержать константы . За примерами обращайтесь к разделу об интерфейсах.
К классу можно обратиться с помощью переменной. Значение переменной не может быть ключевым словом (например, self , parent и static ).
Обратите внимание, что константы класса задаются один раз для всего класса, а не отдельно для каждого созданного объекта этого класса.
Пример #1 Объявление и использование константы
class MyClass
const CONSTANT = ‘значение константы’ ;
function showConstant () echo self :: CONSTANT . «\n» ;
>
>
echo MyClass :: CONSTANT . «\n» ;
$classname = «MyClass» ;
echo $classname :: CONSTANT . «\n» ;
$class = new MyClass ();
$class -> showConstant ();
Специальная константа ::class , которой на этапе компиляции присваивается полное имя класса, полезна при использовании с классами, использующими пространства имён.
Пример #2 Пример использования ::class с пространством имён
Пример #3 Пример констант, заданных выражением
class foo const TWO = ONE * 2 ;
const THREE = ONE + self :: TWO ;
const SENTENCE = ‘Значение константы THREE — ‘ . self :: THREE ;
>
?>
Пример #4 Модификаторы видимости констант класса, начиная с PHP 7.1.0
class Foo public const BAR = ‘bar’ ;
private const BAZ = ‘baz’ ;
>
echo Foo :: BAR , PHP_EOL ;
echo Foo :: BAZ , PHP_EOL ;
?>
Результат выполнения данного примера в PHP 7.1:
bar Fatal error: Uncaught Error: Cannot access private const Foo::BAZ in …
Замечание:
Начиная с PHP 7.1.0 для констант класса можно использовать модификаторы области видимости.
User Contributed Notes 12 notes
it’s possible to declare constant in base class, and override it in child, and access to correct value of the const from the static method is possible by ‘get_called_class’ method:
abstract class dbObject
<
const TABLE_NAME = ‘undefined’ ;
public static function GetAll ()
$c = get_called_class ();
return «SELECT * FROM `» . $c :: TABLE_NAME . «`» ;
>
>
class dbPerson extends dbObject
const TABLE_NAME = ‘persons’ ;
>
class dbAdmin extends dbPerson
const TABLE_NAME = ‘admins’ ;
>
echo dbPerson :: GetAll (). «
» ; //output: «SELECT * FROM `persons`»
echo dbAdmin :: GetAll (). «
» ; //output: «SELECT * FROM `admins`»
As of PHP 5.6 you can finally define constant using math expressions, like this one:
class MyTimer const SEC_PER_DAY = 60 * 60 * 24 ;
>
Most people miss the point in declaring constants and confuse then things by trying to declare things like functions or arrays as constants. What happens next is to try things that are more complicated then necessary and sometimes lead to bad coding practices. Let me explain.
A constant is a name for a value (but it’s NOT a variable), that usually will be replaced in the code while it gets COMPILED and NOT at runtime.
So returned values from functions can’t be used, because they will return a value only at runtime.
Arrays can’t be used, because they are data structures that exist at runtime.
One main purpose of declaring a constant is usually using a value in your code, that you can replace easily in one place without looking for all the occurences. Another is, to avoid mistakes.
Think about some examples written by some before me:
1. const MY_ARR = «return array(\»A\», \»B\», \»C\», \»D\»);»;
It was said, this would declare an array that can be used with eval. WRONG! This is just a string as constant, NOT an array. Does it make sense if it would be possible to declare an array as constant? Probably not. Instead declare the values of the array as constants and make an array variable.
2. const magic_quotes = (bool)get_magic_quotes_gpc();
This can’t work, of course. And it doesn’t make sense either. The function already returns the value, there is no purpose in declaring a constant for the same thing.
3. Someone spoke about «dynamic» assignments to constants. What? There are no dynamic assignments to constants, runtime assignments work _only_ with variables. Let’s take the proposed example:
/**
* Constants that deal only with the database
*/
class DbConstant extends aClassConstant <
protected $host = ‘localhost’ ;
protected $user = ‘user’ ;
protected $password = ‘pass’ ;
protected $database = ‘db’ ;
protected $time ;
function __construct () <
$this -> time = time () + 1 ; // dynamic assignment
>
>
?>
Those aren’t constants, those are properties of the class. Something like «this->time = time()» would even totally defy the purpose of a constant. Constants are supposed to be just that, constant values, on every execution. They are not supposed to change every time a script runs or a class is instantiated.
Conclusion: Don’t try to reinvent constants as variables. If constants don’t work, just use variables. Then you don’t need to reinvent methods to achieve things for what is already there.
I think it’s useful if we draw some attention to late static binding here:
class A const MY_CONST = false ;
public function my_const_self () return self :: MY_CONST ;
>
public function my_const_static () return static:: MY_CONST ;
>
>
class B extends A const MY_CONST = true ;
>
$b = new B ();
echo $b -> my_const_self ? ‘yes’ : ‘no’ ; // output: no
echo $b -> my_const_static ? ‘yes’ : ‘no’ ; // output: yes
?>
const can also be used directly in namespaces, a feature never explicitly stated in the documentation.
const BAR = 1 ;
?>
# bar.php
require ‘foo.php’ ;
var_dump ( Foo \ BAR ); // => int(1)
?>
Hi, i would like to point out difference between self::CONST and $this::CONST with extended class.
Let us have class a:
class a <
const CONST_INT = 10 ;
public function getSelf () return self :: CONST_INT ;
>
public function getThis () return $this :: CONST_INT ;
>
>
?>
And class b (which extends a)
class b extends a const CONST_INT = 20 ;
public function getSelf () return parent :: getSelf ();
>
public function getThis () return parent :: getThis ();
>
>
?>
Both classes have same named constant CONST_INT.
When child call method in parent class, there is different output between self and $this usage.
print_r ( $b -> getSelf ()); //10
print_r ( $b -> getThis ()); //20
Константы классов
Константы также могут быть объявлены и в пределах одного класса. Отличие переменных и констант состоит в том, что при объявлении последних или при обращении к ним не используется символ $ .
Значение должно быть неизменяемым выражением, не (к примеру) переменной, свойством, результатом математической операции или вызовом функции.
Интерфейсы также могут содержать константы (constants). За примерами обращайтесь к разделу об интерфейсах.
Начиная с версии PHP 5.3.0, стало возможным обратиться к классу с помощью переменной. Значение переменной не должно быть ключевым словом (например, self, parent или static).
Пример #1 Объявление и использование константы
class MyClass
const CONSTANT = ‘значение константы’ ;
function showConstant () echo self :: CONSTANT . «\n» ;
>
>
echo MyClass :: CONSTANT . «\n» ;
$classname = «MyClass» ;
echo $classname :: CONSTANT . «\n» ; // начиная с версии PHP 5.3.0
$class = new MyClass ();
$class -> showConstant ();
echo $class :: CONSTANT . «\n» ; // начиная с версии PHP 5.3.0
?>
Пример #2 Пример со статичными данными
В отличие от heredoc, nowdoc может быть использован в любом контексте статичных данных.
Замечание:
Поддержка nowdoc была добавлена в версии PHP 5.3.0.