Constants in PHP — const and define()

In this note, we will understand the difference in declaring PHP constants using the const keyword and the define() function.

Constants in PHP are "immutable" values that are specified only once and cannot be changed afterwards. When attempting to change the value, it will not change, and a PHP notice will appear: "Constant already defined":

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

echo FOO; //> val

Constants in PHP can be declared in two ways:

// 1
define( 'NAME', 'VALUE' );

// 2
const NAME = 'VALUE';

Each method has its own characteristics. To understand them, let's consider each step by step, and what changed with each PHP version.

How to create constants

PHP less than 5.3

Before 5.3 in PHP, constants could only be defined using define(). The const keyword appeared in version 5.3.

Constants can only store scalars. Scalar values are primitives: integer, float, string, and boolean. Types array, object, resource, etc. are not scalars.

// scalars
define( 'FOO', 10 );
define( 'FOO', 10.9 );
define( 'FOO', 'val' );
define( 'FOO', true );

// non-scalars
define( 'FOO', array(1) );          // the constant will not be set, and we will get a Warning
define( 'FOO', (object) array(1) ); // the constant will not be set, and we will get a Warning

Since PHP 5.3

The keyword const appeared, and now a constant can also be defined using it.

However, in const, you cannot specify an expression: variable, function, concatenation, and you must pass only a scalar:

const FOO = 'val';       // no errors
const FOO = $var;        // Parse error
const FOO = home_url();  // Parse error
const FOO = 5 + 10;      // Parse error
const FOO = 'foo'.'bar'; // Parse error

While for define(), there are no such limitations.

define( 'FOO', 'val' );        // no errors
define( 'FOO', $var );         // no errors
define( 'FOO', home_url() );   // no errors
define( 'FOO', 5 + 10 );       // no errors
define( 'FOO', 'foo'.'bar' );  // no errors

PHP 5.6

It became possible to specify primitive PHP expressions in the values of const:

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

It became possible to store arrays in constants:

const FOO = [1, 2, 3];      // works

define( 'FOO', [1, 2, 3] ); // does not work in PHP 5.6, works in PHP 7.0

Difference between define() and const

#1 const must be declared in the top scope

Because they are defined during script compilation. This means that const cannot be used inside functions/loops/expressions or try/catch blocks.

if ( 1 ) {
	const NAME = 'VALUE';  // does not work
}
// but
if ( 1 ) {
	define('NAME', 'VALUE');  // works

#2 const is always case-sensitive

While define() allows creating case-insensitive constants:

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

#3 const only understands scalars, arrays, and expressions of primitives

You cannot pass variables, functions, expressions to const, but you can to define():

const FOO = $var;       // Parse error
const FOO = home_url(); // Parse error

define('FOO', $var);        // no errors
define('FOO', home_url());  // no errors

#4 const can store arrays from PHP 5.6, while define can from PHP 7.0

const FOO = [1, 2, 3];      // works in PHP 5.6
define('FOO', [1, 2, 3]); // works in PHP 7.0

#5 const depends on namespaces, while define does not

If we create a constant in a namespace, then:

• When using const, the constant will be in this namespace and will not be available outside of it.
• When using define, the constant is registered as global and will be available outside the namespace.

namespace My\Space;

const FOO = 'bar';

define('FOOO', 'baz');

Now to refer to these constants outside the namespace, for example, from another file, you need to write like this:

echo \My\Space\FOO; // bar

echo FOOO; // baz

Comparison summary

It is almost always better to define a constant using define(), because there are more possibilities and fewer chances to "catch" an error. Exceptions:

• If you have PHP version 5.6 and need to store an array in a constant, const will help.
• If you need the constant to not be in global visibility, but in namespace visibility.

PHP Class Constants

Declared only using const. The rules for them are as described above: they only accept scalars, do not understand PHP variables, functions, expressions.

The declared constant belongs to the class, it does not belong to any object, but is common to all objects (instances) of the class.

class My_Class {

	const NAME = 'VALUE';

	// starting from PHP 5.6, you can use mathematical expressions
	const SEC_PER_DAY = 60 * 60 * 24;

	function print_name() {
		// accessing the class constant inside a method using self (the class itself)
		echo self::NAME;
	}
}

// accessing the constant outside the class
// can be called from the global scope without instantiating a class instance
echo My_Class::NAME;

class Foo {
	// Starting from PHP 7.1.0
	public const BAR = 'bar';
	private const BAZ = 'baz';
}

class My_Class {
	const NAME = 'VALUE';
	static $name = 'VALUE';
}

echo My_Class::NAME;
echo My_Class::$name;

"Magic" Constants

And finally, let's remember the special constants in PHP.

PHP has nine "magic" constants that change their value depending on the context in which they are used. For example, the value of __LINE__ depends on the line in the script where this constant is specified.

All "magic" constants are resolved during compilation, unlike regular constants, which are resolved during execution. Special constants are case-insensitive, and their list is given below: