Константы в PHP
Константа PHP противоположна переменной в том смысле, что после определения ее нельзя изменить.
Константы особенно полезны для определения значения, которое вы часто используете, и которое никогда не меняется. Например, вы можете определить константу INCHES_SM_METR, которая содержит количество сантиметров в метре. Поскольку эта величина, которая никогда не меняется, имеет смысл определить её как константу. И наоборот, значение, которое может измениться, например курс доллара к рублю, лучше всего определять как переменную.
Считается, что константы PHP имеют глобальную область действия. Это означает, что после того, как вы определили константу, она становится доступной из любой функции или объекта в вашем коде PHP.
Кроме того, чтобы облегчить жизнь разработчикам, PHP предоставляет ряд встроенных констант, которые доступны для использования.
Определение константы PHP
Вместо использования оператора присваивания (=) , как мы это делали при определении переменных, константы создаются с помощью функции define() . У констант также отсутствует префикс $ для имен переменных.
Функция определения принимает три аргумента:
define(name, value, case-insensitive)
- name — имя, которое вы хотите присвоить константе
- value — значение, которое будет сохранено в константе
- case-insensitive — определяет, является ли константа нечувствительной к регистру. По умолчанию это значение false , т.е. с учетом регистра.
Имена констант чувствительны к регистру. Хотя это не является обязательным требованием, соглашение, перенесенное из других языков программирования, предполагает, что имена констант следует использовать с символами верхнего регистра. В следующем примере демонстрируется использование функции define() для указания константы с именем, чувствительным к регистру:
Пример
define("GREETING", "Добро пожаловать на wm-school.ru!");
echo GREETING;
?> Обратите внимание, что мы не указали третий параметр при определении константы т.к. его значение по умолчанию false , т.е. с учетом регистра.
Давайте создадим константу с именем без учета регистра:
Пример
define("GREETING", "Добро пожаловать на wm-school.ru!");
echo greeting;
?> Проверка существования констант
Часто бывает полезно узнать, действительно ли определена константа. Этого можно добиться с помощью функции defined() . Функция defined() принимает имя проверяемой константы в качестве аргумента и возвращает значение true или false , чтобы указать, существует ли эта константа.
Например, предположим, что мы хотим узнать, определена ли константа с именем MY_FIRST_CONSTANT. Мы можем просто вызвать функцию defined() , передавая имя, а затем протестировать результат с помощью оператора if . else (см. Условные операторы PHP для более подробной информации об использовании if . else ) :
Пример
define ('MY_FIRST_CONSTANT', 'wm-school.ru');
if (defined ('MY_FIRST_CONSTANT'))
<
echo "Константа определена"; // выведет "Константа определена"
>
else
<
echo "Константа не определена";
>
?> Результат выполнения кода:
Постоянные массивы PHP
В PHP7 вы можете создать константу массива с помощью функции defined() :
Пример
define("fruit", [
"apple",
"pear",
"plum"
]);
echo fruit[0];
?> Результат выполнения кода:
Глобальные константы
Константы автоматически становятся глобальными и могут использоваться во всем скрипте.
В следующем примере константа используется внутри функции не смотря на то, что она определена вне функции:
Пример
define("GREETING", "Добро пожаловать на wm-school.ru!");
function myTest() echo GREETING;
>
myTest();
?> Результат выполнения кода:
Константы
Константа — это идентификатор (имя) для простого значения. Как следует из названия, это значение не может измениться в ходе выполнения скрипта (кроме магических констант, которые на самом деле не являются константами). Константы чувствительны к регистру. По принятому соглашению, имена констант всегда пишутся в верхнем регистре.
Замечание:
До PHP 8.0.0 константы, определённые с помощью функции define() , могли быть нечувствительными к регистру.
Имя константы должно соответствовать тем же правилам именования, что и другие имена в PHP. Правильное имя начинается с буквы или символа подчёркивания, за которым следует любое количество букв, цифр и символов подчёркивания. Регулярное выражение для проверки правильности имени константы выглядит так: ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$
Возможно определить константы с помощью функции define() зарезервированными или даже некорректными именами, значения которых могут быть получены только с помощью constant() . Однако, делать это не рекомендуется.
Пример #1 Правильные и неправильные имена констант
// Правильные имена констант
define ( «FOO» , «что-то» );
define ( «FOO2» , «что-то ещё» );
define ( «FOO_BAR» , «что-то большее» );
// Неправильные имена констант
define ( «2FOO» , «что-то» );
// Это верное объявление, но лучше его не использовать:
// PHP однажды может зарегистрировать волшебную константу,
// которая нарушит работу скрипта
define ( «__FOO__» , «что-то» );
Замечание: Понятие «буквы» здесь — это символы a-z, A-Z, и другие символы с ASCII-кодами от 128 до 255 (0x80-0xff).
Как и superglobals, константы доступны из любой области видимости. Константы можно использовать из любого места скрипта независимо от области видимости. Подробную информацию об областях видимости можно найти здесь.
Замечание: Начиная с PHP 7.1.0, константе класса можно объявлять видимость защищённая или закрытая, делая её доступной только в иерархической области видимости класса, в котором она определена.
User Contributed Notes 13 notes
11/14/2016 — note updated by sobak
——
CONSTANTS and PHP Class Definitions
Using «define(‘MY_VAR’, ‘default value’)» INSIDE a class definition does not work as expected. You have to use the PHP keyword ‘const’ and initialize it with a scalar value — boolean, int, float, string (or array in PHP 5.6+) — right away.
define ( ‘MIN_VALUE’ , ‘0.0’ ); // RIGHT — Works OUTSIDE of a class definition.
define ( ‘MAX_VALUE’ , ‘1.0’ ); // RIGHT — Works OUTSIDE of a class definition.
//const MIN_VALUE = 0.0; RIGHT — Works both INSIDE and OUTSIDE of a class definition.
//const MAX_VALUE = 1.0; RIGHT — Works both INSIDE and OUTSIDE of a class definition.
class Constants
<
//define(‘MIN_VALUE’, ‘0.0’); WRONG — Works OUTSIDE of a class definition.
//define(‘MAX_VALUE’, ‘1.0’); WRONG — Works OUTSIDE of a class definition.
const MIN_VALUE = 0.0 ; // RIGHT — Works INSIDE of a class definition.
const MAX_VALUE = 1.0 ; // RIGHT — Works INSIDE of a class definition.
public static function getMinValue ()
<
return self :: MIN_VALUE ;
>
public static function getMaxValue ()
<
return self :: MAX_VALUE ;
>
>
?>
#Example 1:
You can access these constants DIRECTLY like so:
* type the class name exactly.
* type two (2) colons.
* type the const name exactly.
#Example 2:
Because our class definition provides two (2) static functions, you can also access them like so:
* type the class name exactly.
* type two (2) colons.
* type the function name exactly (with the parentheses).
#Example 1:
$min = Constants :: MIN_VALUE ;
$max = Constants :: MAX_VALUE ;
#Example 2:
$min = Constants :: getMinValue ();
$max = Constants :: getMaxValue ();
?>
Once class constants are declared AND initialized, they cannot be set to different values — that is why there are no setMinValue() and setMaxValue() functions in the class definition — which means they are READ-ONLY and STATIC (shared by all instances of the class).
Lets expand comment of ‘storm’ about usage of undefined constants. His claim that ‘An undefined constant evaluates as true. ‘ is wrong and right at same time. As said further in documentation ‘ If you use an undefined constant, PHP assumes that you mean the name of the constant itself, just as if you called it as a string. ‘. So yeah, undefined global constant when accessed directly will be resolved as string equal to name of sought constant (as thought PHP supposes that programmer had forgot apostrophes and autofixes it) and non-zero non-empty string converts to True.
There are two ways to prevent this:
1. always use function constant(‘CONST_NAME’) to get constant value (BTW it also works for class constants — constant(‘CLASS_NAME::CONST_NAME’) );
2. use only class constants (that are defined inside of class using keyword const) because they are not converted to string when not found but throw exception instead (Fatal error: Undefined class constant).
Warning, constants used within the heredoc syntax (http://www.php.net/manual/en/language.types.string.php) are not interpreted!
Editor’s Note: This is true. PHP has no way of recognizing the constant from any other string of characters within the heredoc block.
The documentation says, «You can access constants anywhere in your script without regard to scope», but it’s worth keeping in mind that a const declaration must appear in the source file before the place where it’s used.
This doesn’t work (using PHP 5.4):
foo ();
const X = 1 ;
function foo () echo «Value of X: » . X ;
>
?>
Result: «Value of X: X»
But this works:
const X = 1 ;
foo ();
function foo () echo «Value of X: » . X ;
>
?>
Result: «Value of X: 1»
This is potentially confusing because you can refer to a function that occurs later in your source file, but not a constant. Even though the const declaration is processed at compile time, it behaves a bit like it’s being processed at run time.
I find using the concatenation operator helps disambiguate value assignments with constants. For example, setting constants in a global configuration file:
define ( ‘LOCATOR’ , «/locator» );
define ( ‘CLASSES’ , LOCATOR . «/code/classes» );
define ( ‘FUNCTIONS’ , LOCATOR . «/code/functions» );
define ( ‘USERDIR’ , LOCATOR . «/user» );
?>
Later, I can use the same convention when invoking a constant’s value for static constructs such as require() calls:
require_once( FUNCTIONS . «/database.fnc» );
require_once( FUNCTIONS . «/randchar.fnc» );
?>
as well as dynamic constructs, typical of value assignment to variables:
$userid = randchar ( 8 , ‘anc’ , ‘u’ );
$usermap = USERDIR . «/» . $userid . «.png» ;
?>
The above convention works for me, and helps produce self-documenting code.
If you are looking for predefined constants like
* PHP_OS (to show the operating system, PHP was compiled for; php_uname(‘s’) might be more suitable),
* DIRECTORY_SEPARATOR («\\» on Win, ‘/’ Linux. )
* PATH_SEPARATOR (‘;’ on Win, ‘:’ on Linux. )
they are buried in ‘Predefined Constants’ under ‘List of Reserved Words’ in the appendix:
http://www.php.net/manual/en/reserved.constants.php
while the latter two are also mentioned in ‘Directory Functions’
http://www.php.net/manual/en/ref.dir.php
PHP Modules also define constants. Make sure to avoid constant name collisions. There are two ways to do this that I can think of.
First: in your code make sure that the constant name is not already used. ex. ?> This can get messy when you start thinking about collision handling, and the implications of this.
Second: Use some off prepend to all your constant names without exception ex.
Perhaps the developers or documentation maintainers could recommend a good prepend and ask module writers to avoid that prepend in modules.
class constant are by default public in nature but they cannot be assigned visibility factor and in turn gives syntax error
const MAX_VALUE = 10 ;
public const MIN_VALUE = 1 ;
// This will work
echo constants :: MAX_VALUE ;
// This will return syntax error
echo constants :: MIN_VALUE ;
?>