Отличие define от const php

Constants

A constant is an identifier (name) for a simple value. As the name suggests, that value cannot change during the execution of the script (except for magic constants, which aren’t actually constants). Constants are case-sensitive. By convention, constant identifiers are always uppercase.

Note:

Prior to PHP 8.0.0, constants defined using the define() function may be case-insensitive.

The name of a constant follows the same rules as any label in PHP. A valid constant name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thusly: ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$

It is possible to define() constants with reserved or even invalid names, whose value can only be retrieved with the constant() function. However, doing so is not recommended.

Example #1 Valid and invalid constant names

// Valid constant names
define ( «FOO» , «something» );
define ( «FOO2» , «something else» );
define ( «FOO_BAR» , «something more» );

// Invalid constant names
define ( «2FOO» , «something» );

// This is valid, but should be avoided:
// PHP may one day provide a magical constant
// that will break your script
define ( «__FOO__» , «something» );

Note: For our purposes here, a letter is a-z, A-Z, and the ASCII characters from 128 through 255 (0x80-0xff).

Like superglobals, the scope of a constant is global. Constants can be accessed from anywhere in a script without regard to scope. For more information on scope, read the manual section on variable scope.

Note: As of PHP 7.1.0, class constant may declare a visibility of protected or private, making them only available in the hierarchical scope of the class in which it is defined.

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 ;
?>

Источник

Что лучше использовать define() или const?

В PHP, когда вы используете:

define(‘FOO’, 1);

или когда вы используете:

const FOO = 1;

каковы основные различия между этими двумя вариантами?

Ответ 1

1. const нельзя использовать для условного определения констант. Чтобы определить глобальную константу, она должна быть использована в самой внешней области видимости:

1. Зачем вообще это нужно? Одно из распространенных применений — проверка того, определена ли уже константа:

1. const принимает статический скаляр (число, строку или другую константу типа true, false, null, __FILE__), тогда как define() принимает любое выражение. Начиная с PHP 5.6 , константные выражения допускаются и в const:

1. const принимает обычное имя константы, в то время как define() принимает любое выражение в качестве имени. Это позволяет делать такие вещи, как:

1. const всегда чувствител ьна к регистру, тогда как define() позволяет вам определять константы без учета регистра, передавая true в качестве третьего аргумента ( п римечание: определение констант без учета регистра устарело , начиная с PHP 7.3.0 , и удалено в PHP 8.0.0):

1. const просто читается приятнее. Это языковая конструкция вместо функции, а также соответствует тому, как вы определяете константы в классах.
2. const, будучи языковой конструкцией, может быть статически проанализирована автоматизированными инструментами.
3. const определяет константу в текущем пространстве имен, в то время как define() должно быть передано полное имя пространства имен:

1. Начиная с PHP 5.6 , константы const также могут быть массивами, в то время как define() пока не поддерживает массивы. Однако в PHP 7 массивы будут поддерживаться в обоих случаях.

Ответ 2

До версии PHP 5.3 const нельзя было использовать в глобальной области видимости. Его можно было использовать только внутри класса. Это следует использовать, когда вы хотите установить какую-то константную опцию или параметр, относящийся к данному классу. Или, может быть, вы хотите создать какое-то перечисление. define можно использовать для той же цели, но только в глобальной области видимости. Его следует использовать только для глобальных настроек, которые влияют на все приложение. Примером хорошего использования const является избавление от «магических» чисел. Взгляните на константы PDO. Когда вам нужно указать тип выборки, вы набираете, например, PDO::FETCH_ASSOC. Если бы константы не использовались, то в итоге вы бы набрали что-то вроде «35» (или любое другое значение FETCH_ASSOC). Это не имеет смысла для читателя. Примером хорошего использования define может быть указание корневого пути вашего приложения или номера версии библиотеки.

Ответ 3

1. Константы не могут быть определены из выражения. const FOO = 4 * 3; не работает, но define(‘CONST’, 4 * 3); работает.
2. Имя, передаваемое в define, должно включать пространство имен, в котором оно должно быть определено.

Ответ 4

Предыдущий ответ является лучшим, но позвольте мне добавить неочевидную оговорку при использовании пространств имен, чтобы вы не столкнулись с неожиданным поведением. Необходимо помнить, что определяемые объекты всегда находятся в глобальном пространстве имен, если только вы явно не добавите пространство имен как часть идентификатора определяемого объекта. Что не очевидно, так это то, что идентификатор пространства имен имеет приоритет над глобальным идентификатором. Поэтому:

namespace foo

// Примечание: при ссылке в этом файле или пространстве имен const маскирует определяемую версию.

// это может быть не то, что вы хотите/ожидаете

const BAR = ‘cheers’;

define(‘BAR’, ‘wonka’);

printf(«What kind of bar is a %s bar?\n», BAR);

// Чтобы добраться до определения в глобальном пространстве имен, необходимо явно сослаться на него printf(«What kind of bar is a %s bar?\n», \BAR);

>

namespace foo2

// Но теперь в другом пространстве имен (например, по умолчанию) тот же синтаксис вызывает

// определенную версию!

printf(«Willy %s\n», BAR);

printf(«three %s\n», \foo\BAR);

>

?>

В итоге:

What kind of bar is a cheers bar?

What kind of bar is a wonka bar?

willy wonka

three cheers

Что, на мой взгляд, делает всю концепцию const излишне запутанной, поскольку идея const в десятках других языков заключается в том, что она всегда одна и та же, где бы вы ни находились в коде, а PHP этого не гарантирует.

Ответ 5

Да, const определяются во время компиляции и н е могут быть присвоены выражению, как это может сделать define(). Но также const не может быть условно объявлен (по той же причине). т . е . вы не можете сделать этого:

if (/* некоторое условие */)

const WHIZZ = true; // не работает

>

В то же время вы могли бы использовать define(). Таким образом, это не сводится к личным предпочтениям, есть правильный и неправильный способы использования обоих.

Ответ 6

При использовании константы define keyword вы получите возможность нечувствительности к регистру, а при использовании const keyword — нет.

define(«FOO», 1, true);

echo foo; //1

echo «
«;

echo FOO; //1

echo «
«;

class A

const FOO = 1;

>

echo A::FOO; //допустимо

echo «
«;

//но

class B

define FOO = 1; // синтаксическая ошибка, не определенный ‘define’

>

echo B::FOO; // не допустимо

Мы будем очень благодарны

если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.

Источник