define() vs. const

Question

In PHP, you can declare constants in two ways:

1. With define keyword

   define('FOO', 1); 

2. Using const keyword

   const FOO = 1; 

---

• What are the main differences between those two?
• When and why should you use one and when use the other?

Answer 1

As of PHP 5.3 there are two ways to define constants: Either using the const keyword or using the define() function:

const FOO = 'BAR'; define('FOO', 'BAR'); 

The fundamental difference between those two ways is that const defines constants at compile time, whereas define defines them at run time. This causes most of const's disadvantages. Some disadvantages of const are:

• const cannot be used to conditionally define constants. To define a global constant, it has to be used in the outermost scope:

   if (...) {      const FOO = 'BAR';    // Invalid  }  // but  if (...) {      define('FOO', 'BAR'); // Valid  } 

  Why would you want to do that anyway? One common application is to check whether the constant is already defined:

   if (!defined('FOO')) {      define('FOO', 'BAR');  } 

• const accepts a static scalar (number, string or other constant like true, false, null, __FILE__), whereas define() takes any expression. Since PHP 5.6 constant expressions are allowed in const as well:

   const BIT_5 = 1 << 5;    // Valid since PHP 5.6 and invalid previously  define('BIT_5', 1 << 5); // Always valid 

• const takes a plain constant name, whereas define() accepts any expression as name. This allows to do things like this:

   for ($i = 0; $i < 32; ++$i) {      define('BIT_' . $i, 1 << $i);  } 

• consts are always case sensitive, whereas define() allows you to define case insensitive constants by passing true as the third argument (Note: defining case-insensitive constants is deprecated as of PHP 7.3.0 and removed since PHP 8.0.0):

   define('FOO', 'BAR', true);  echo FOO; // BAR  echo foo; // BAR 

So, that was the bad side of things. Now let's look at the reason why I personally always use const unless one of the above situations occurs:

• const simply reads nicer. It's a language construct instead of a function and also is consistent with how you define constants in classes.

• const, being a language construct, can be statically analysed by automated tooling.

• const defines a constant in the current namespace, while define() has to be passed the full namespace name:

   namespace A\B\C;  // To define the constant A\B\C\FOO:  const FOO = 'BAR';  define('A\B\C\FOO', 'BAR'); 

• Since PHP 5.6 const constants can also be arrays, while define() does not support arrays yet. However, arrays will be supported for both cases in PHP 7.

   const FOO = [1, 2, 3];    // Valid in PHP 5.6  define('FOO', [1, 2, 3]); // Invalid in PHP 5.6 and valid in PHP 7.0 

Finally, note that const can also be used within a class or interface to define a class constant or interface constant. define cannot be used for this purpose:

class Foo {     const BAR = 2; // Valid } // But class Baz {     define('QUX', 2); // Invalid } 

Summary

Unless you need any type of conditional or expressional definition, use consts instead of define()s - simply for the sake of readability!

Answer 2

Until PHP 5.3, const could not be used in the global scope. You could only use this from within a class. This should be used when you want to set some kind of constant option or setting that pertains to that class. Or maybe you want to create some kind of enum.

define can be used for the same purpose, but it can only be used in the global scope. It should only be used for global settings that affect the entire application.

An example of good const usage is to get rid of magic numbers. Take a look at PDO's constants. When you need to specify a fetch type, you would type PDO::FETCH_ASSOC, for example. If consts were not used, you'd end up typing something like 35 (or whatever FETCH_ASSOC is defined as). This makes no sense to the reader.

An example of good define usage is maybe specifying your application's root path or a library's version number.