Php операции с константами

Константы в PHP — const и define()

В этой заметке разберемся, в чем разница в объявлении PHP констант с помощью ключевого слова const и функции define() . Константы в PHP — это «постоянные», значения которых указывается всего один раз и затем не может быть изменено. При попытке изменить значение, оно не изменится и появится PHP заметка: «Constant already defined» (константа уже определена):

define('FOO', 'val'); define('FOO', 'val2'); // Notice: Constant already defined echo FOO; //> val

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

У каждого способа есть свои особенности, чтобы их понять, давайте рассмотрим все поэтапно, как и что менялось с каждой версией PHP.

Как создавать константы

PHP меньше 5.3

До 5.3 в PHP, константы можно было определять только через define() . Ключевое слово const появилось с версии 5.3.

Константы могут хранить только скаляры. Скалярные значения — это примитивы: integer , float , string и boolean . Типы array , object , resource и т.д. не являются скалярными.

// скаляры define( 'FOO', 10 ); define( 'FOO', 10.9 ); define( 'FOO', 'val' ); define( 'FOO', true ); // не скаляры define( 'FOO', array(1) ); // константа не установиться и получим Warning define( 'FOO', (object) array(1) ); // константа не установиться и получим Warning

С версии PHP 5.3

Появилось ключевое слово const и теперь константу можно определять еще и с помощью него.

Однако, в const нельзя указать выражение: переменную, функцию, конкатинацию, а нужно передавать только скаляр:

const FOO = 'val'; // нет ошибок const FOO = $var; // Parse error const FOO = home_url(); // Parse error const FOO = 5 + 10; // Parse error const FOO = 'foo'.'bar'; // Parse error

Тогда как для define() таких ограничений нет.

define( 'FOO', 'val' ); // нет ошибок define( 'FOO', $var ); // нет ошибок define( 'FOO', home_url() ); // нет ошибок define( 'FOO', 5 + 10 ); // нет ошибок define( 'FOO', 'foo'.'bar' ); // нет ошибок

PHP 5.6

Стало возможным указывать в значения const примитивные PHP выражения (выражения из скаляров):

const FOO = 1 + 2; const FOO = 'foo' . 'bar';

Стало возможным хранить массивы в константах:

const FOO = [1, 2, 3]; // работает define( 'FOO', [1, 2, 3] ); // не работает в PHP 5.6, работает в PHP 7.0

Разница между define() и const

#1 const должны быть объявлены в верхней области

Потому что они определяются при компилировании скрипта. Это значит, что const нельзя использовать внутри функций/циклов/выражений if или try/catch блоков.

#2 const всегда регистрозависима

В то время как define() позволяет создать регистро-независимые константы:

define( 'NAME', 'VALUE', true ); echo NAME; // VALUE echo name; // VALUE

#3 const понимает только скаляры, массивы и выражения из примитивов

const нельзя передать переменные, функции, выражения, а define() можно:

const FOO = $var; // Parse error const FOO = home_url(); // Parse error define( 'FOO', $var ); // нет ошибок define( 'FOO', home_url() ); // нет ошибок

С версии PHP 5.6 в const также можно указывать примитивные выражения и массивы, а не только скаляры.

#4 const может хранить массивы с версии PHP 5.6, а define с PHP 7.0

const FOO = [1, 2, 3]; // работает с PHP 5.6 define( 'FOO', [1, 2, 3] ); // работает с PHP 7.0

#5 const зависит от пространства имен, а define нет

Если мы создаем константу в namespace, то:

• При использовании const — константа будет нахоидтся в этом прастранстве и не будет доступна вне его.
• При использовании define — константа регистрируется как глобальная и будет доступна за пределами namespace.

namespace My\Space; const FOO = 'bar'; define( 'FOOO', 'baz' );

Теперь чтобы обратиться к этим константам за пределами пространства имен, например из другого файла, нужно писать так:

echo \My\Space\FOO; // bar echo FOOO; // baz

Итог сравнения

Определять константу почти всегда лучше с помощью define() , потому что тут больше возможностей и меньше вариантов «поймать» ошибку. Исключения:

• У вас версия PHP 5.6 и вам нужно сохранить массив в константу, тут поможет const .
• Вам нужно, чтобы константа была не в глобальной видимости, а в видимости пространства имен (namespace).

Константы PHP класса

Объявляются только с помощью const . Правила для них такие как описано выше: принимают только скаляры, не понимают PHP переменные, функции, выражения.

Объявленная константа принадлежит классу, она не принадлежит ни одному объекту, но является общей для всех объектов (экземпляров) класса.

class My_Class < const NAME = 'VALUE'; // начиная с PHP 5.6 можно использовать математические выражения const SEC_PER_DAY = 60 * 60 * 24; function print_name() < // обращение к константе класса внутри метода через self (сам класс) echo self::NAME; >> // обращение к константе вне класса // можно вызывать из глобальной области видимости без инициализации экземпляра класса echo My_Class::NAME;

До PHP 7.1 постоянные класса всегда общедоступны — нет статуса private или protected . Однако с версии PHP 7.1 константам класса можно указать модификатор:

Константы для классов чем-то похожи на static свойства класса. Не углубляясь в подробности, разница в том, что константу нельзя изменить.

class My_Class < const NAME = 'VALUE'; static $name = 'VALUE'; >echo My_Class::NAME; echo My_Class::$name;

«Волшебные» константы

И в заключении вспомним про особые константы PHP.

В PHP есть девять волшебных констант, которые меняют свое значение в зависимости от контекста, в котором они используются. Например, значение __LINE__ зависит от строки в скрипте, на которой эта константа указана.

Все «волшебные» константы разрешаются во время компиляции, в отличии от обычных констант, которые разрешаются во время исполнения. Специальные константы нечувствительны к регистру и их список приведен ниже:

Константа	Описание
__LINE__	Текущий номер строки в файле.
__FILE__	Полный путь и имя текущего файла, в котором вызывается константа.
__DIR__	PHP 5.3.0. Директория файла, в котором используется константа. То же самое что dirname(__FILE__) . Не имеет слэша в конце, кроме корневой директории.
__FUNCTION__	Имя функции.
__CLASS__	Имя класса. Это имя содержит название пространства имен, в котором класс был объявлен (например, Foo\Bar). Также работает в трейтах. При использовании в методах трейтов является именем класса, в котором эти методы используется.
__TRAIT__	PHP 5.4.0. Имя трейта. Это имя содержит название пространства имен, в котором трейт был объявлен (например, Foo\Bar).
__METHOD__	Имя метода класса.
__NAMESPACE__	PHP 5.3.0. Имя текущего пространства имен.
ClassName::class	PHP 5.5.0. Полное имя класса (с указанием пространства имен).

До этого из: PHP

Источник

constant

Возвращает значение константы, указанной в параметре name .

Функция constant() полезна, если вам необходимо получить значение константы, но неизвестно её имя. Например, если оно хранится в переменной или возвращается функцией.

Список параметров

Возвращаемые значения

Возвращает значение константы.

Ошибки

Если константа не определена, выбрасывается исключение Error . До PHP 8.0.0 в этом случае выдавалась ошибка уровня E_WARNING .

Список изменений

Версия	Описание
8.0.0	Если константа не определена, функция constant() теперь выбрасывает исключение Error ; ранее выдавалась ошибка уровня E_WARNING и возвращалось значение null .

Примеры

Пример #1 Пример использования constant() с константами

echo MAXSIZE ;
echo constant ( «MAXSIZE» ); // результат аналогичен предыдущему выводу

interface bar const test = ‘foobar!’ ;
>

class foo const test = ‘foobar!’ ;
>

var_dump ( constant ( ‘bar::’ . $const )); // string(7) «foobar!»
var_dump ( constant ( ‘foo::’ . $const )); // string(7) «foobar!»

Пример #2 Пример использования constant() с вариантами перечисления (начиная с PHP 8.1.0)

enum Suit
case Hearts ;
case Diamonds ;
case Clubs ;
case Spades ;
>

var_dump ( constant ( ‘Suit::’ . $case )); // enum(Suit::Hearts)

Смотрите также

• define() — Определяет именованную константу
• defined() — Проверяет существование указанной именованной константы
• get_defined_constants() — Возвращает ассоциативный массив с именами всех констант и их значений
• Смотрите раздел Константы

User Contributed Notes 17 notes

The constant name can be an empty string.

If you are referencing class constant (either using namespaces or not, because one day you may want to start using them), you’ll have the least headaches when doing it like this:

class Foo const BAR = 42 ;
>
?>
namespace Baz ;
use \ Foo as F ;

echo constant ( F ::class. ‘::BAR’ );
?>

since F::class will be dereferenced to whatever namespace shortcuts you are using (and those are way easier to refactor for IDE than just plain strings with hardcoded namespaces in string literals)

As of PHP 5.4.6 constant() pays no attention to any namespace aliases that might be defined in the file in which it’s used. I.e. constant() always behaves as if it is called from the global namespace. This means that the following will not work:

echo constant ( ‘F::BAR’ );
?>

However, calling constant(‘Foo::BAR’) will work as expected.

It is worth noting, that keyword ‘self’ can be used for constant retrieval from within the class it is defined

class Foo const PARAM_BAR = ‘baz’ ;

public function getConst ( $name ) return constant ( «self:: < $name >» );
>
>

$foo = new Foo ();
echo $foo -> getConst ( ‘PARAM_BAR’ ); // prints ‘baz’
?>

Technically you can define constants with names that are not valid for variables:

// $3some is not a valid variable name
// This will not work
$ 3some = ‘invalid’ ;

// This works
define ( ‘3some’ , ‘valid’ );
echo constant ( ‘3some’ );

?>

Of course this is not a good practice, but PHP has got you covered.

$file_ext is the file Extension of the image

When you often write lines like

if( defined ( ‘FOO’ ) && constant ( ‘FOO’ ) === ‘bar’ )
.
>

?>

to prevent errors, you can use the following function to get the value of a constant.

function getconst ( $const )
return ( defined ( $const )) ? constant ( $const ) : null ;
>

?>

Finally you can check the value with

To access the value of a class constant use the following technique.

In reply to VGR_experts_exchange at edainworks dot com

To check if a constant is boolean, use this instead:

if ( TRACE === true ) <>
?>

Much quicker and cleaner than using defined() and constant() to check for a simple boolean.

IMO, using ($var === true) or ($var === false) instead of ($var) or (!$var) is the best way to check for booleans no matter what. Leaves no chance of ambiguity.

Checking if a constant is empty is bork.

if (empty( B )) // syntax error
if (empty( constant ( ‘B’ ))) // fatal error

// so instead, thanks to LawnGnome on IRC, you can cast the constants to boolean (empty string is false)
if (((boolean) A ) && ((boolean) B ))
// do stuff
?>

This function is namespace sensitive when calling class constants.

class foo const BAR = ‘Hello World’ ;
>

constant ( ‘sub\foo::BAR’ ); // works

?>

This does not seem to affect constants defined with the ‘define’ function. Those all end up defined in the root namespace unless another namespace is implicitly defined in the string name of the constant.

define ( __NAMESPACE__ . ‘\Bar’ , ‘its work’ ); // ..but IDE may make notice

You can define values in your config file using the names of your defined constants, e.g.

in your php code:
define(«MY_CONST»,999);

in you config file:
my = MY_CONST

When reading the file do this:

$my = constant($value); // where $value is the string «MY_CONST»

now $my holds the value of 999

Return constants from an object. You can filter by regexp or match by value to find a constant name from the value.

function findConstantsFromObject ( $object , $filter = null , $find_value = null )
$reflect = new ReflectionClass ( $object );
$constants = $reflect -> getConstants ();

class Example
const GENDER_UNKNOW = 0 ;
const GENDER_FEMALE = 1 ;
const GENDER_MALE = 2 ;

const USER_OFFLINE = false ;
const USER_ONLINE = true ;
>

$all = findConstantsFromObject ( ‘Example’ );

$genders = findConstantsFromObject ( ‘Example’ , ‘/^GENDER_/’ );

$my_gender = 1 ;
$gender_name = findConstantsFromObject ( ‘Example’ , ‘/^GENDER_/’ , $my_gender );

if (isset( $gender_name [ 0 ]))
$gender_name = str_replace ( ‘GENDER_’ , » , key ( $gender_name ));
>
else
$gender_name = ‘WTF!’ ;
>

The use of constant() (or some other method) to ensure the your_constant was defined is particularly important when it is to be defined as either `true` or `false`.

If `BOO` did NOT get defined as a constant, for some reason,

would evaluate to `TRUE` and run anyway. A rather unexpected result.

The reason is that PHP ASSUMES you «forgot» quotation marks around `BOO` when it did not see it in its list of defined constants.
So it evaluates: `if (‘BOO’)`.
Since every string, other than the empty string, is «truthy», the expression evaluates to `true` and the do_something() is run, unexpectedly.

then if `BOO` has not been defined, `constant(BOO)` evaluates to `null`,
which is falsey, and `if (null)`. becomes `false`, so do_something() is skipped, as expected.

The PHP behavior regarding undefined constants is particularly glaring when having a particular constant defined is the exception, «falsey» is the default, and having a «truthy» value exposes a security issue. For example,
.

Note that only the version using `defined()` works without also throwing a PHP Warning «error message.»

(disclosure: I also submitted an answer to the SO question linked to above)

Источник